Mirrors_UI_SDK/wxWidgets
1
0
Fork 0
mirror of https://github.com/wxWidgets/wxWidgets.git synced 2026-09-28 15:50:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

1. added a brief overview of Unicode support

Browse Source 
2. added and documented wxBITMAP() macros (as wxICON)
3. restructured wxFont class, added support of encoding parameter
4. regenerated makefiles to compile the new fontcmn.cpp file
5. corrected bug with non existing files in document-view history


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3753 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-09-29 19:02:07 +00:00
parent 7a3ac80489
commit 0c5d3e1ccd
24 changed files with 1848 additions and 750 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/latex/wx/font.tex
+18 -1
View File
@@ -41,7 +41,8 @@ wxSWISS\_FONT}
Default constructor.
\func{}{wxFont}{\param{int}{ pointSize}, \param{int}{ family}, \param{int}{ style}, \param{int}{ weight},
\param{const bool}{ underline = FALSE}, \param{const wxString\& }{faceName = ""}}
\param{const bool}{ underline = FALSE}, \param{const wxString\& }{faceName = ""},
\param{wxFontEncoding }{encoding = wxFONTENCODING\_DEFAULT}}
Creates a font object.
@@ -70,6 +71,22 @@ Creates a font object.
\docparam{faceName}{An optional string specifying the actual typeface to be used. If the empty string,
a default typeface will chosen based on the family.}
\docparam{encoding}{An encoding which may be one of
\twocolwidtha{5cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf wxFONTENCODING\_SYSTEM}}{Default system encoding.}
\twocolitem{{\bf wxFONTENCODING\_DEFAULT}}{Default application encoding: this
is the encoding set by calls to
\helpref{SetDefaultEncoding}{wxfontsetdefaultencoding} and which may beset to,
say, KOI8 to create all fonts by default with KOI8 encoding. Initially, the
default application encoding is the same as default system encoding.}
\twocolitem{{\bf wxFONTENCODING\_ISO8859\_1...15}}{ISO8859 encodings.}
\twocolitem{{\bf wxFONTENCODING\_KOI8}}{The standard russian encoding for Internet.}
\twocolitem{{\bf wxFONTENCODING\_CP1250...1252}}{Windows encodings similar to ISO8859 (but not identical).}
\end{twocollist}
If the specified encoding isn't available, no font is created.
}
\wxheading{Remarks}
If the desired font does not exist, the closest match will be chosen.
docs/latex/wx/function.tex
+34
View File
@@ -1928,6 +1928,23 @@ base classes.
<wx/object.h>
\membersection{wxBITMAP}\label{wxbitmap}
\func{}{wxBITMAP}{bitmapName}
This macro loads a bitmap from either application resources (on the platforms
for which they exist, i.e. Windows and OS2) or from an XPM file. It allows to
avoid using {\tt #ifdef}s when creating bitmaps.
\wxheading{See also}
\helpref{Bitmaps and icons overview}{wxbitmapoverview},
\helpref{wxICON}{wxicon}
\wxheading{Include files}
<wx/gdicmn.h>
\membersection{WXDEBUG\_NEW}\label{debugnew}
\func{}{WXDEBUG\_NEW}{arg}
@@ -1975,6 +1992,23 @@ Example:
\helpref{RTTI overview}{runtimeclassoverview}
\membersection{wxICON}\label{wxicon}
\func{}{wxICON}{iconName}
This macro loads an icon from either application resources (on the platforms
for which they exist, i.e. Windows and OS2) or from an XPM file. It allows to
avoid using {\tt #ifdef}s when creating icons.
\wxheading{See also}
\helpref{Bitmaps and icons overview}{wxbitmapoverview},
\helpref{wxBITMAP}{wxbitmap}
\wxheading{Include files}
<wx/gdicmn.h>
\membersection{WXTRACE}\label{trace}
\wxheading{Include files}
docs/latex/wx/tbitmap.tex
+25 -1
View File
@@ -30,7 +30,7 @@ XPM icon file to be available at run-time.
#endif
\end{verbatim}
A macro, wxICON, is available which creates an icon using an XPM
A macro, \helpref{wxICON}{wxicon}, is available which creates an icon using an XPM
on the appropriate platform, or an icon resource on Windows.
\begin{verbatim}
@@ -47,6 +47,30 @@ wxIcon icon("mondrian");
#endif
\end{verbatim}
There is also a corresponding \helpref{wxBITMAP}{wxbitmap} macro which allows
to create the bitmaps in much the same way as \helpref{wxICON}{wxicon} creates
icons. It assumes that bitmaps live in resources under Windows or OS2 and XPM
files under all other platforms (for XPMs, the corresponding file must be
included before this macro is used, of course, and the name of the bitmap
should be the same as the resource name under Windows with {\tt \_xpm}
suffix). For example:
\begin{verbatim}
// an easy and portable way to create a bitmap
wxBitmap bmp(wxBITMAP(bmpname));
// which is roughly equivalent to the following
#if defined(__WXMSW__) || defined(__WXPM__)
wxBitmap bmp("bmpname", wxBITMAP_TYPE_RESOURCE);
#else // Unix
wxBitmap bmp(bmpname_xpm, wxBITMAP_TYPE_XPM);
#endif
\end{verbatim}
You should always use wxICON and wxBITMAP macros because they work for any
platform (unlike the code above which doesn't deal with wxMac, wxBe, ...) and
are more short and clear than versions with {\tt #ifdef}s.
\subsection{Supported bitmap file formats}\label{supportedbitmapformats}
The following lists the formats handled on different platforms. Note
docs/latex/wx/tunicode.tex
+156
View File
@@ -0,0 +1,156 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: tunicode.tex
%% Purpose: Overview of the Unicode support in wxWindows
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 22.09.99
%% RCS-ID: $Id$
%% Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
%% Licence: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Unicode support in wxWindows}\label{unicode}
This section briefly describes the state of the Unicode support in wxWindows.
Read it if you want to know more about how to write programs able to work with
characters from languages other than English.
\subsection{What is Unicode?}
Starting with release 2.1 wxWindows has support for compiling in Unicode mode
on the platforms which support it. Unicode is a standard for character
encoding which addreses the shortcomings of the previous, 8 bit standards, by
using 16 bit for encoding each character. This allows to have 65536 characters
instead of the usual 256 and is sufficient to encode all of the world
languages at once. More details about Unicode may be found at {\tt www.unicode.org}.
% TODO expand on it, say that Unicode extends ASCII, mention ISO8859, ...
As this solution is obviously preferable to the previous ones (think of
incompatible encodings for the same language, locale chaos and so on), many
modern ooperating systems support it. The probably first example is Windows NT
which uses only Unicode internally since its very first version.
Writing internationalized programs is much easier with Unicode and, as the
support for it improves, it should become more and more so. Moreover, in the
Windows NT/2000 case, even the program which uses only standard ASCII can profit
from using Unicode because they will work more efficiently - there will be no
need for the system to convert all strings hte program uses to/from Unicode
each time a system call is made.
\subsection{Unicode and ANSI modes}
As not all platforms supported by wxWindows support Unicode (fully) yet, in
many cases it is unwise to write a program which can only work in Unicode
environment. A better solution is to write programs in such way that they may
be compiled either in ANSI (traditional) mode or in the Unicode one.
This can be achieved quite simply by using the means provided by wxWindows.
Basicly, there are only a few things to watch out for:
\begin{itemize}
\item Character type ({\tt char} or {\tt wchar\_t})
\item Literal strings (i.e. {\tt "Hello, world!"} or {\tt '*'})
\item String functions ({\tt strlen()}, {\tt strcpy()}, ...)
\end{itemize}
Let's look at them in order. First of all, each character in an Unicode
program takes 2 bytes instead of usual one, so another type should be used to
store the characters ({\tt char} only holds 1 byte usually). This type is
called {\tt wchar\_t} which stands for {\it wide-character type}.
Also, the string and character constants should be encoded on 2 bytes instead
of one. This is achieved by using the standard C (and C++) way: just put the
letter {\tt 'L'} after any string constant and it becomes a {\it long}
constant, i.e. a wide character one. To make things a bit more readable, you
are also allowed to prefix the constant with {\tt 'L'} instead of putting it
after it.
Finally, the standard C functions don't work with {\tt wchar\_t} strings, so
another set of functions exists which do the same thing but accept
{\tt wchar\_t *} instead of {\tt char *}. For example, a function to get the
length of a wide-character string is called {\tt wcslen()} (compare with
{\tt strlen()} - you see that the only difference is that the "str" prefix
standing for "string" has been replaced with "wcs" standing for
"wide-character string").
To summarize, here is a brief example of how a program which can be compiled
in both ANSI and Unicode modes could look like:
\begin{verbatim}
#ifdef __UNICODE__
wchar_t wch = L'*';
const wchar_t *ws = L"Hello, world!";
int len = wcslen(ws);
#else // ANSI
char ch = '*';
const char *s = "Hello, world!";
int len = strlen(s);
#endif // Unicode/ANSI
\end{verbatim}
Of course, it would be nearly impossibly to write such programs if it had to
be done this way (try to imagine the number of {\tt #ifdef UNICODE} an average
program would have had!). Luckily, there is another way - see the next
section.
\subsection{Unicode support in wxWindows}
In wxWindows, the code fragment froim above should be written instead:
\begin{verbatim}
wxChar ch = T('*');
wxString s = T("Hello, world!");
int len = s.Len();
\end{verbatim}
What happens here? First of all, you see that there are no more {\tt #ifdef}s
at all. Instead, we define some types and macros which behave differently in
the Unicode and ANSI builds and allows us to avoid using conditional
compilation in the program itself.
We have a {\tt wxChar} type which maps either on {\tt char} or {\tt wchar\_t}
depending on the mode in which program is being compiled. There is no need for
a separate type for strings though, because the standard
\helpref{wxString}{wxstring} supports Unicode, i.e. it stores iether ANSI or
Unicode strings depending on the mode.
Finally, there is a special {\tt T()} macro which should enclose all literal
strings in the program. As it's easy to see comparing the last fragment with
the one above, this macro expands to nothing in the (usual) ANSI mode and
prefixes {\tt 'L'} to its argument in the Unicode mode.
The important conclusion is that if you use {\tt wxChar} instead of
{\tt char}, avoid using C style strings and use {\tt wxString} instead and
don't forget to enclose all string literals inside {\tt T()} macro, your
program automatically becomes (almost) Unicode compliant!
Just let us state once again the rules:
\begin{itemize}
\item Always use {\tt wxChar} instead of {\tt char}
\item Always enclose literal string constants in {\tt T()} macro unless
they're already converted to the right representation (another standard
wxWindows macro {\tt \_()} does it, so there is no need for {\tt T()} in this
case) or you intend to pass the constant directly to an external function
which doesn't accept wide-character strings.
\item Use {\tt wxString} instead of C style strings.
\end{itemize}
\subsection{Unicode and the outside world}
We have seen that it was easy to write Unicode programs using wxWindows types
and macros, but it has been also mentioned that it isn't quite enough.
Although everything works fine inside the program, things can get nasty when
it tries to communicate with the outside world which, sadly, often expects
ANSI strings (a notable exception is the entire Win32 API which accepts either
Unicode or ANSI strings and which thus makes it unnecessary to ever perform
any convertions in the program).
To get a ANSI string from a wxString, you may use
\helpref{mb\_str()}{wxstringmbstr} function which always returns an ANSI
string (independently of the mode - while the usual
\helpref{c\_str()}{wxstringcstr} returns a pointer to the internal
representation which is either ASCII or Unicode). More rarely used, but still
useful, is \helpref{wc\_str()}{wxstringwcstr} function which always returns
the Unicode string.
% TODO describe fn_str(), wx_str(), wxCharBuf classes, ...
include/wx/docview.h
+2
View File
@@ -362,6 +362,7 @@ public:
// File history management
virtual void AddFileToHistory(const wxString& file);
virtual void RemoveFileFromHistory(int i);
virtual int GetNoHistoryFiles() const;
virtual wxString GetHistoryFile(int i) const;
virtual void FileHistoryUseMenu(wxMenu *menu);
@@ -553,6 +554,7 @@ public:
// Operations
virtual void AddFileToHistory(const wxString& file);
virtual void RemoveFileFromHistory(int i);
virtual int GetMaxFiles() const { return m_fileMaxFiles; }
virtual void UseMenu(wxMenu *menu);
include/wx/font.h
+188 -7
View File
File diff suppressed because it is too large Load Diff
include/wx/gdicmn.h
+10
View File
@@ -149,6 +149,16 @@ enum wxStockCursor
#define wxICON(X) wxIcon("" #X "")
#endif // platform
/* Another macro: this one is for portable creation of bitmaps. We assume that
under Unix bitmaps live in XPMs and under Windows they're in ressources.
*/
#if defined(__WXMSW__) || defined(__WXPM__)
#define wxBITMAP(name) wxBitmap(#name, wxBITMAP_TYPE_RESOURCE)
#else // !(Windows || OS2)
#define wxBITMAP(name) wxBitmap(name##_xpm, wxBITMAP_TYPE_XPM)
#endif // platform
// ===========================================================================
// classes
// ===========================================================================
include/wx/gtk/font.h
+85 -53
View File
@@ -7,12 +7,11 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKFONTH__
#define __GTKFONTH__
#ifdef __GNUG__
#pragma interface
#pragma interface
#endif
#include "wx/defs.h"
@@ -21,79 +20,111 @@
#include "wx/hash.h"
#include "wx/gdiobj.h"
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// conditional compilation
// ----------------------------------------------------------------------------
#define wxUSE_FONTNAMEDIRECTORY 0
// ----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxDC;
class wxPaintDC;
class wxWindow;
class wxFont;
/*
class wxFontNameDirectory;
*/
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
class wxFontNameDirectory;
#endif
// ----------------------------------------------------------------------------
// global variables
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/*
extern wxFontNameDirectory *wxTheFontNameDirectory;
*/
extern const wxChar* wxEmptyString;
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
extern wxFontNameDirectory *wxTheFontNameDirectory;
#endif
// ----------------------------------------------------------------------------
// wxFont
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxFont: public wxGDIObject
class wxFont : public wxFontBase
{
DECLARE_DYNAMIC_CLASS(wxFont)
public:
wxFont();
wxFont( int pointSize, int family, int style, int weight, bool underlined = FALSE,
const wxString& face = wxEmptyString );
wxFont( const wxFont& font );
~wxFont();
wxFont& operator = ( const wxFont& font );
bool operator == ( const wxFont& font ) const;
bool operator != ( const wxFont& font ) const;
bool Ok() const;
// ctors and such
wxFont() { Init(); }
wxFont(const wxFont& font) { Init(); Ref(font); }
int GetPointSize() const;
int GetFamily() const;
int GetStyle() const;
int GetWeight() const;
bool GetUnderlined() const;
// assignment
wxFont& operator=(const wxFont& font);
void SetPointSize( int pointSize );
void SetFamily( int family );
void SetStyle( int style );
void SetWeight( int weight );
void SetFaceName( const wxString& faceName );
void SetUnderlined( bool underlined );
wxString GetFaceName() const;
wxString GetFamilyString() const;
wxString GetStyleString() const;
wxString GetWeightString() const;
// implementation
wxFont( GdkFont* font, char *xFontName );
void Unshare();
wxFont(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Init();
GdkFont* GetInternalFont(float scale = 1.0) const;
(void)Create(size, family, style, weight, underlined, face, encoding);
}
// no data :-)
bool Create(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
~wxFont();
// implement base class pure virtuals
virtual int GetPointSize() const;
virtual int GetFamily() const;
virtual int GetStyle() const;
virtual int GetWeight() const;
virtual wxString GetFaceName() const;
virtual bool GetUnderlined() const;
virtual wxFontEncoding GetEncoding() const;
virtual void SetPointSize( int pointSize );
virtual void SetFamily( int family );
virtual void SetStyle( int style );
virtual void SetWeight( int weight );
virtual void SetFaceName( const wxString& faceName );
virtual void SetUnderlined( bool underlined );
virtual void SetEncoding(wxFontEncoding encoding);
// implementation from now on
wxFont( GdkFont* font, char *xFontName );
void Unshare();
GdkFont* GetInternalFont(float scale = 1.0) const;
// no data :-)
protected:
// common part of all ctors
void Init();
private:
DECLARE_DYNAMIC_CLASS(wxFont)
};
/*
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
// ----------------------------------------------------------------------------
// wxFontDirectory
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxFontNameDirectory: public wxObject
{
@@ -118,6 +149,7 @@ class wxFontNameDirectory: public wxObject
class wxHashTable *table;
int nextFontId;
};
*/
#endif // wxUSE_FONTNAMEDIRECTORY
#endif // __GTKFONTH__
include/wx/gtk1/font.h
+85 -53
View File
@@ -7,12 +7,11 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKFONTH__
#define __GTKFONTH__
#ifdef __GNUG__
#pragma interface
#pragma interface
#endif
#include "wx/defs.h"
@@ -21,79 +20,111 @@
#include "wx/hash.h"
#include "wx/gdiobj.h"
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// conditional compilation
// ----------------------------------------------------------------------------
#define wxUSE_FONTNAMEDIRECTORY 0
// ----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxDC;
class wxPaintDC;
class wxWindow;
class wxFont;
/*
class wxFontNameDirectory;
*/
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
class wxFontNameDirectory;
#endif
// ----------------------------------------------------------------------------
// global variables
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/*
extern wxFontNameDirectory *wxTheFontNameDirectory;
*/
extern const wxChar* wxEmptyString;
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
extern wxFontNameDirectory *wxTheFontNameDirectory;
#endif
// ----------------------------------------------------------------------------
// wxFont
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxFont: public wxGDIObject
class wxFont : public wxFontBase
{
DECLARE_DYNAMIC_CLASS(wxFont)
public:
wxFont();
wxFont( int pointSize, int family, int style, int weight, bool underlined = FALSE,
const wxString& face = wxEmptyString );
wxFont( const wxFont& font );
~wxFont();
wxFont& operator = ( const wxFont& font );
bool operator == ( const wxFont& font ) const;
bool operator != ( const wxFont& font ) const;
bool Ok() const;
// ctors and such
wxFont() { Init(); }
wxFont(const wxFont& font) { Init(); Ref(font); }
int GetPointSize() const;
int GetFamily() const;
int GetStyle() const;
int GetWeight() const;
bool GetUnderlined() const;
// assignment
wxFont& operator=(const wxFont& font);
void SetPointSize( int pointSize );
void SetFamily( int family );
void SetStyle( int style );
void SetWeight( int weight );
void SetFaceName( const wxString& faceName );
void SetUnderlined( bool underlined );
wxString GetFaceName() const;
wxString GetFamilyString() const;
wxString GetStyleString() const;
wxString GetWeightString() const;
// implementation
wxFont( GdkFont* font, char *xFontName );
void Unshare();
wxFont(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Init();
GdkFont* GetInternalFont(float scale = 1.0) const;
(void)Create(size, family, style, weight, underlined, face, encoding);
}
// no data :-)
bool Create(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
~wxFont();
// implement base class pure virtuals
virtual int GetPointSize() const;
virtual int GetFamily() const;
virtual int GetStyle() const;
virtual int GetWeight() const;
virtual wxString GetFaceName() const;
virtual bool GetUnderlined() const;
virtual wxFontEncoding GetEncoding() const;
virtual void SetPointSize( int pointSize );
virtual void SetFamily( int family );
virtual void SetStyle( int style );
virtual void SetWeight( int weight );
virtual void SetFaceName( const wxString& faceName );
virtual void SetUnderlined( bool underlined );
virtual void SetEncoding(wxFontEncoding encoding);
// implementation from now on
wxFont( GdkFont* font, char *xFontName );
void Unshare();
GdkFont* GetInternalFont(float scale = 1.0) const;
// no data :-)
protected:
// common part of all ctors
void Init();
private:
DECLARE_DYNAMIC_CLASS(wxFont)
};
/*
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
// ----------------------------------------------------------------------------
// wxFontDirectory
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxFontNameDirectory: public wxObject
{
@@ -118,6 +149,7 @@ class wxFontNameDirectory: public wxObject
class wxHashTable *table;
int nextFontId;
};
*/
#endif // wxUSE_FONTNAMEDIRECTORY
#endif // __GTKFONTH__
include/wx/msw/font.h
+62 -65
View File
@@ -13,88 +13,85 @@
#define _WX_FONT_H_
#ifdef __GNUG__
#pragma interface "font.h"
#pragma interface "font.h"
#endif
#include "wx/gdiobj.h"
class WXDLLEXPORT wxFont;
class WXDLLEXPORT wxFontRefData: public wxGDIRefData
{
friend class WXDLLEXPORT wxFont;
public:
wxFontRefData(void);
wxFontRefData(const wxFontRefData& data);
~wxFontRefData(void);
protected:
bool m_temporary; // If TRUE, the pointer to the actual font
// is temporary and SHOULD NOT BE DELETED by
// destructor
int m_pointSize;
int m_family;
int m_fontId;
int m_style;
int m_weight;
bool m_underlined;
wxString m_faceName;
WXHFONT m_hFont;
};
#define M_FONTDATA ((wxFontRefData *)m_refData)
WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
// Font
class WXDLLEXPORT wxFont: public wxGDIObject
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxFont : public wxFontBase
{
DECLARE_DYNAMIC_CLASS(wxFont)
public:
wxFont(void);
wxFont(int PointSize, int Family, int Style, int Weight, bool underlined = FALSE, const wxString& Face = wxEmptyString);
inline wxFont(const wxFont& font) { Ref(font); }
// ctors and such
wxFont() { Init(); }
wxFont(const wxFont& font) { Init(); Ref(font); }
~wxFont(void);
wxFont(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Init();
bool Create(int PointSize, int Family, int Style, int Weight, bool underlined = FALSE, const wxString& Face = wxEmptyString);
(void)Create(size, family, style, weight, underlined, face, encoding);
}
// Internal
virtual bool RealizeResource(void);
virtual WXHANDLE GetResourceHandle(void) ;
virtual bool FreeResource(bool force = FALSE);
/*
virtual bool UseResource(void);
virtual bool ReleaseResource(void);
*/
bool Create(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
virtual bool IsFree() const;
virtual bool Ok(void) const { return (m_refData != NULL) ; }
virtual ~wxFont();
inline int GetPointSize(void) const { return M_FONTDATA->m_pointSize; }
inline int GetFamily(void) const { return M_FONTDATA->m_family; }
inline int GetFontId(void) const { return M_FONTDATA->m_fontId; } /* New font system */
inline int GetStyle(void) const { return M_FONTDATA->m_style; }
inline int GetWeight(void) const { return M_FONTDATA->m_weight; }
wxString GetFamilyString(void) const ;
wxString GetFaceName(void) const ;
wxString GetStyleString(void) const ;
wxString GetWeightString(void) const ;
inline bool GetUnderlined(void) const { return M_FONTDATA->m_underlined; }
// implement base class pure virtuals
virtual int GetPointSize() const;
virtual int GetFamily() const;
virtual int GetStyle() const;
virtual int GetWeight() const;
virtual bool GetUnderlined() const;
virtual wxString GetFaceName() const;
virtual wxFontEncoding GetEncoding() const;
void SetPointSize(int pointSize);
void SetFamily(int family);
void SetStyle(int style);
void SetWeight(int weight);
void SetFaceName(const wxString& faceName);
void SetUnderlined(bool underlined);
virtual void SetPointSize(int pointSize);
virtual void SetFamily(int family);
virtual void SetStyle(int style);
virtual void SetWeight(int weight);
virtual void SetFaceName(const wxString& faceName);
virtual void SetUnderlined(bool underlined);
virtual void SetEncoding(wxFontEncoding encoding);
wxFont& operator = (const wxFont& font) { if (*this == font) return (*this); Ref(font); return *this; }
bool operator == (const wxFont& font) const { return m_refData == font.m_refData; }
bool operator != (const wxFont& font) const { return m_refData != font.m_refData; }
// implementation only from now on
// -------------------------------
int GetFontId() const;
virtual bool IsFree() const;
virtual bool RealizeResource();
virtual WXHANDLE GetResourceHandle();
virtual bool FreeResource(bool force = FALSE);
/*
virtual bool UseResource();
virtual bool ReleaseResource();
*/
protected:
void Unshare();
// common part of all ctors
void Init();
void Unshare();
private:
DECLARE_DYNAMIC_CLASS(wxFont)
};
#endif
src/common/docview.cpp
+79 -6
View File
@@ -98,6 +98,12 @@
static inline wxString FindExtension(const wxChar *path);
// ----------------------------------------------------------------------------
// local constants
// ----------------------------------------------------------------------------
static const char *s_MRUEntryFormat = _T("&%d %s");
// ============================================================================
// implementation
// ============================================================================
@@ -1095,6 +1101,12 @@ void wxDocManager::AddFileToHistory(const wxString& file)
m_fileHistory->AddFileToHistory(file);
}
void wxDocManager::RemoveFileFromHistory(int i)
{
if (m_fileHistory)
m_fileHistory->RemoveFileFromHistory(i);
}
wxString wxDocManager::GetHistoryFile(int i) const
{
wxString histFile;
@@ -1482,9 +1494,27 @@ void wxDocParentFrame::OnExit(wxCommandEvent& WXUNUSED(event))
void wxDocParentFrame::OnMRUFile(wxCommandEvent& event)
{
wxString f(m_docManager->GetHistoryFile(event.GetSelection() - wxID_FILE1));
if (f != _T(""))
(void)m_docManager->CreateDocument(f, wxDOC_SILENT);
int n = event.GetSelection() - wxID_FILE1; // the index in MRU list
wxString filename(m_docManager->GetHistoryFile(n));
if ( !filename.IsEmpty() )
{
// verify that the file exists before doing anything else
if ( wxFile::Exists(filename) )
{
// try to open it
(void)m_docManager->CreateDocument(filename, wxDOC_SILENT);
}
else
{
// remove the bogus filename from the MRU list and notify the user
// about it
m_docManager->RemoveFileFromHistory(n);
wxLogError(_("The file '%s' doesn't exist and couldn't be opened.\n"
"It has been also removed from the MRU files list."),
filename.c_str());
}
}
}
// Extend event processing to search the view's event table
@@ -1855,7 +1885,7 @@ void wxFileHistory::AddFileToHistory(const wxString& file)
if (m_fileHistory[i])
{
wxString buf;
buf.Printf(_T("&%d %s"), i+1, m_fileHistory[i]);
buf.Printf(s_MRUEntryFormat, i+1, m_fileHistory[i]);
wxNode* node = m_fileMenus.First();
while (node)
{
@@ -1866,6 +1896,49 @@ void wxFileHistory::AddFileToHistory(const wxString& file)
}
}
void wxFileHistory::RemoveFileFromHistory(int i)
{
wxCHECK_RET( i < m_fileHistoryN,
_T("invalid index in wxFileHistory::RemoveFileFromHistory") );
wxNode* node = m_fileMenus.First();
while ( node )
{
wxMenu* menu = (wxMenu*) node->Data();
// wxMenu::Delete() is missing from wxGTK, so this can't be done :-(
#if 0
// delete the menu items
menu->Delete(wxID_FILE1 + i);
#endif
// delete the element from the array (could use memmove() too...)
delete [] m_fileHistory[i];
int j;
for ( j = i; j < m_fileHistoryN - 1; j++ )
{
m_fileHistory[j] = m_fileHistory[j + 1];
}
// shuffle filenames up
wxString buf;
for ( j = i; j < m_fileHistoryN - 1; j++ )
{
buf.Printf(s_MRUEntryFormat, j + 1, m_fileHistory[j]);
menu->SetLabel(wxID_FILE1 + j, buf);
}
// to be removed as soon as wxMenu::Delete() is implemented
#if 1
menu->SetLabel(wxID_FILE1 + m_fileHistoryN - 1, _T(""));
#endif
node = node->Next();
}
m_fileHistoryN--;
}
wxString wxFileHistory::GetHistoryFile(int i) const
{
if (i < m_fileHistoryN)
@@ -1929,7 +2002,7 @@ void wxFileHistory::AddFilesToMenu()
if (m_fileHistory[i])
{
wxString buf;
buf.Printf(_T("&%d %s"), i+1, m_fileHistory[i]);
buf.Printf(s_MRUEntryFormat, i+1, m_fileHistory[i]);
menu->Append(wxID_FILE1+i, buf);
}
}
@@ -1949,7 +2022,7 @@ void wxFileHistory::AddFilesToMenu(wxMenu* menu)
if (m_fileHistory[i])
{
wxString buf;
buf.Printf(_T("&%d %s"), i+1, m_fileHistory[i]);
buf.Printf(s_MRUEntryFormat, i+1, m_fileHistory[i]);
menu->Append(wxID_FILE1+i, buf);
}
}
src/common/fontcmn.cpp
+112
View File
@@ -0,0 +1,112 @@
/////////////////////////////////////////////////////////////////////////////
// Name: common/fontcmn.cpp
// Purpose: implementation of wxFontBase methods
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.09.99
// RCS-ID: $Id$
// Copyright: (c) wxWindows team
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/font.h"
#endif // WX_PRECOMP
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxFontBase
// ----------------------------------------------------------------------------
wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM;
wxFont *wxFontBase::New(int size,
int family,
int style,
int weight,
bool underlined,
const wxString& face,
wxFontEncoding encoding)
{
return new wxFont(size, family, style, weight, underlined, face, encoding);
}
wxFont& wxFont::operator=(const wxFont& font)
{
if ( this != &font )
Ref(font);
return (wxFont &)*this;
}
// VZ: is it correct to compare pointers and not the contents? (FIXME)
bool wxFontBase::operator==(const wxFont& font) const
{
return m_refData == font.m_refData;
}
bool wxFontBase::operator!=(const wxFont& font) const
{
return m_refData != font.m_refData;
}
wxString wxFontBase::GetFamilyString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch ( GetFamily() )
{
case wxDECORATIVE: return _T("wxDECORATIVE");
case wxROMAN: return _T("wxROMAN");
case wxSCRIPT: return _T("wxSCRIPT");
case wxSWISS: return _T("wxSWISS");
case wxMODERN: return _T("wxMODERN");
case wxTELETYPE: return _T("wxTELETYPE");
default: return _T("wxDEFAULT");
}
}
wxString wxFontBase::GetStyleString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch ( GetStyle() )
{
case wxNORMAL: return _T("wxNORMAL");
case wxSLANT: return _T("wxSLANT");
case wxITALIC: return _T("wxITALIC");
default: return _T("wxDEFAULT");
}
}
wxString wxFontBase::GetWeightString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch ( GetWeight() )
{
case wxNORMAL: return _T("wxNORMAL");
case wxBOLD: return _T("wxBOLD");
case wxLIGHT: return _T("wxLIGHT");
default: return _T("wxDEFAULT");
}
}
src/common/string.cpp
+6 -2
View File
@@ -1279,6 +1279,10 @@ int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
// ----------------------------------------------------------------------------
// misc other operations
// ----------------------------------------------------------------------------
// returns TRUE if the string matches the pattern which may contain '*' and
// '?' metacharacters (as usual, '?' matches any character and '*' any number
// of them)
bool wxString::Matches(const wxChar *pszMask) const
{
// check char by char
@@ -1289,8 +1293,8 @@ bool wxString::Matches(const wxChar *pszMask) const
if ( *pszTxt == _T('\0') )
return FALSE;
pszTxt++;
pszMask++;
// pszText and pszMask will be incremented in the loop statement
break;
case _T('*'):
src/gtk/font.cpp
+353 -187
View File
File diff suppressed because it is too large Load Diff
src/gtk1/font.cpp
+353 -187
View File
File diff suppressed because it is too large Load Diff
src/html/helpdata.cpp
+2 -2
View File
@@ -82,8 +82,8 @@ static int IndexCompareFunc(const void *a, const void *b)
class HP_Parser : public wxHtmlParser
{
public:
void AddText(const char* text) {}
wxObject* GetProduct() {return NULL;}
void AddText(const char* WXUNUSED(text)) { }
wxObject* GetProduct() { return NULL; }
};
src/msw/font.cpp
+252 -179
View File
File diff suppressed because it is too large Load Diff
src/msw/makefile.b32
+4 -1
View File
@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 16:55, 1999/09/29
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE B32.T!
#
@@ -130,6 +130,7 @@ COMMONOBJS = \
$(MSWDIR)\fileconf.obj \
$(MSWDIR)\filefn.obj \
$(MSWDIR)\filesys.obj \
$(MSWDIR)\fontcmn.obj \
$(MSWDIR)\framecmn.obj \
$(MSWDIR)\fs_inet.obj \
$(MSWDIR)\fs_zip.obj \
@@ -563,6 +564,8 @@ $(MSWDIR)\filefn.obj: $(COMMDIR)\filefn.$(SRCSUFF)
$(MSWDIR)\filesys.obj: $(COMMDIR)\filesys.$(SRCSUFF)
$(MSWDIR)\fontcmn.obj: $(COMMDIR)\fontcmn.$(SRCSUFF)
$(MSWDIR)\framecmn.obj: $(COMMDIR)\framecmn.$(SRCSUFF)
$(MSWDIR)\fs_inet.obj: $(COMMDIR)\fs_inet.$(SRCSUFF)
src/msw/makefile.bcc
+4 -1
View File
@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 16:55, 1999/09/29
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE BCC.T!
#
@@ -121,6 +121,7 @@ COMMONOBJS = \
$(MSWDIR)\fileconf.obj \
$(MSWDIR)\filefn.obj \
$(MSWDIR)\filesys.obj \
$(MSWDIR)\fontcmn.obj \
$(MSWDIR)\framecmn.obj \
$(MSWDIR)\fs_inet.obj \
$(MSWDIR)\fs_zip.obj \
@@ -471,6 +472,8 @@ $(MSWDIR)\filefn.obj: $(COMMDIR)\filefn.$(SRCSUFF)
$(MSWDIR)\filesys.obj: $(COMMDIR)\filesys.$(SRCSUFF)
$(MSWDIR)\fontcmn.obj: $(COMMDIR)\fontcmn.$(SRCSUFF)
$(MSWDIR)\framecmn.obj: $(COMMDIR)\framecmn.$(SRCSUFF)
$(MSWDIR)\fs_inet.obj: $(COMMDIR)\fs_inet.$(SRCSUFF)
src/msw/makefile.dos
+7 -1
View File
@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE DOS.T!
#
@@ -108,6 +108,7 @@ COMMONOBJS = \
$(COMMDIR)\fileconf.obj \
$(COMMDIR)\filefn.obj \
$(COMMDIR)\filesys.obj \
$(COMMDIR)\fontcmn.obj \
$(COMMDIR)\framecmn.obj \
$(COMMDIR)\fs_inet.obj \
$(COMMDIR)\fs_zip.obj \
@@ -774,6 +775,11 @@ $(COMMDIR)/filesys.obj: $*.$(SRCSUFF)
$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
<<
$(COMMDIR)/fontcmn.obj: $*.$(SRCSUFF)
cl @<<
$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
<<
$(COMMDIR)/framecmn.obj: $*.$(SRCSUFF)
cl @<<
$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
src/msw/makefile.g95
+2 -1
View File
@@ -1,5 +1,5 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE G95.T!
#
@@ -81,6 +81,7 @@ COMMONOBJS = \
$(COMMDIR)/fileconf.$(OBJSUFF) \
$(COMMDIR)/filefn.$(OBJSUFF) \
$(COMMDIR)/filesys.$(OBJSUFF) \
$(COMMDIR)/fontcmn.$(OBJSUFF) \
$(COMMDIR)/framecmn.$(OBJSUFF) \
$(COMMDIR)/fs_inet.$(OBJSUFF) \
$(COMMDIR)/fs_zip.$(OBJSUFF) \
src/msw/makefile.sc
+2 -1
View File
@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE SC.T!
# Symantec C++ makefile for the msw objects
@@ -69,6 +69,7 @@ COMMONOBJS = \
$(COMMDIR)\fileconf.obj \
$(COMMDIR)\filefn.obj \
$(COMMDIR)\filesys.obj \
$(COMMDIR)\fontcmn.obj \
$(COMMDIR)\framecmn.obj \
$(COMMDIR)\fs_inet.obj \
$(COMMDIR)\fs_zip.obj \
src/msw/makefile.vc
+2 -1
View File
@@ -1,4 +1,4 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE VC.T!
# File: makefile.vc
@@ -146,6 +146,7 @@ COMMONOBJS = \
..\common\$D\fileconf.obj \
..\common\$D\filefn.obj \
..\common\$D\filesys.obj \
..\common\$D\fontcmn.obj \
..\common\$D\framecmn.obj \
..\common\$D\fs_inet.obj \
..\common\$D\fs_zip.obj \
src/msw/makefile.wat
+5 -1
View File
@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE WAT.T!
#!/binb/wmake.exe
@@ -95,6 +95,7 @@ COMMONOBJS = &
fileconf.obj &
filefn.obj &
filesys.obj &
fontcmn.obj &
framecmn.obj &
fs_inet.obj &
fs_zip.obj &
@@ -613,6 +614,9 @@ filefn.obj: $(COMMDIR)\filefn.cpp
filesys.obj: $(COMMDIR)\filesys.cpp
*$(CCC) $(CPPFLAGS) $(IFLAGS) $<
fontcmn.obj: $(COMMDIR)\fontcmn.cpp
*$(CCC) $(CPPFLAGS) $(IFLAGS) $<
framecmn.obj: $(COMMDIR)\framecmn.cpp
*$(CCC) $(CPPFLAGS) $(IFLAGS) $<