diff --git a/docs/latex/wx/font.tex b/docs/latex/wx/font.tex index 5c4b5548b9..d8c5046c3a 100644 --- a/docs/latex/wx/font.tex +++ b/docs/latex/wx/font.tex @@ -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. diff --git a/docs/latex/wx/function.tex b/docs/latex/wx/function.tex index 0aca78aa50..c9b30b5a37 100644 --- a/docs/latex/wx/function.tex +++ b/docs/latex/wx/function.tex @@ -1928,6 +1928,23 @@ base classes. +\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} + + + \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} + + + \membersection{WXTRACE}\label{trace} \wxheading{Include files} diff --git a/docs/latex/wx/tbitmap.tex b/docs/latex/wx/tbitmap.tex index bb9fa8717e..64bde5334c 100644 --- a/docs/latex/wx/tbitmap.tex +++ b/docs/latex/wx/tbitmap.tex @@ -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 diff --git a/docs/latex/wx/tunicode.tex b/docs/latex/wx/tunicode.tex new file mode 100644 index 0000000000..43f36eb773 --- /dev/null +++ b/docs/latex/wx/tunicode.tex @@ -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 +%% 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, ... diff --git a/include/wx/docview.h b/include/wx/docview.h index fb93a4a378..3a11b7b5c5 100644 --- a/include/wx/docview.h +++ b/include/wx/docview.h @@ -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); diff --git a/include/wx/font.h b/include/wx/font.h index fdd9d9d8c6..ff010a2443 100644 --- a/include/wx/font.h +++ b/include/wx/font.h @@ -1,21 +1,202 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: wx/font.h +// Purpose: wxFontBase class: the interface of wxFont +// Author: Vadim Zeitlin +// Modified by: +// Created: 20.09.99 +// RCS-ID: $Id$ +// Copyright: (c) wxWindows team +// Licence: wxWindows license +///////////////////////////////////////////////////////////////////////////// + #ifndef _WX_FONT_H_BASE_ #define _WX_FONT_H_BASE_ +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + +#include "wx/defs.h" // for wxDEFAULT &c +#include "wx/gdiobj.h" // the base class + +// ---------------------------------------------------------------------------- +// forward declarations +// ---------------------------------------------------------------------------- + +class WXDLLEXPORT wxFontBase; +class WXDLLEXPORT wxFont; + +// ---------------------------------------------------------------------------- +// font constants +// ---------------------------------------------------------------------------- + +// standard font families +enum wxFontFamily +{ + wxFONTFAMILY_DEFAULT = wxDEFAULT, + wxFONTFAMILY_DECORATIVE = wxDECORATIVE, + wxFONTFAMILY_ROMAN = wxROMAN, + wxFONTFAMILY_SCRIPT = wxSCRIPT, + wxFONTFAMILY_SWISS = wxSWISS, + wxFONTFAMILY_MODERN = wxMODERN, + wxFONTFAMILY_TELETYPE = wxTELETYPE, + wxFONTFAMILY_MAX +}; + +// font styles +enum wxFontStyle +{ + wxFONTSTYLE_NORMAL = wxNORMAL, + wxFONTSTYLE_ITALIC = wxITALIC, + wxFONTSTYLE_SLANT = wxSLANT, + wxFONTSTYLE_MAX +}; + +// font weights +enum wxFontWeight +{ + wxFONTWEIGHT_NORMAL = wxNORMAL, + wxFONTWEIGHT_LIGHT = wxLIGHT, + wxFONTWEIGHT_BOLD = wxBOLD, + wxFONTWEIGHT_MAX +}; + +// font encodings +enum wxFontEncoding +{ + wxFONTENCODING_SYSTEM = -1, // system default + wxFONTENCODING_DEFAULT, // current default encoding + + // ISO8859 standard defines a number of single-byte charsets + wxFONTENCODING_ISO8859_1, // West European (Latin1) + wxFONTENCODING_ISO8859_2, // Central and East European (Latin2) + wxFONTENCODING_ISO8859_3, // Esperanto (Latin3) + wxFONTENCODING_ISO8859_4, // Baltic languages (Estonian) (Latin4) + wxFONTENCODING_ISO8859_5, // Cyrillic + wxFONTENCODING_ISO8859_6, // Arabic + wxFONTENCODING_ISO8859_7, // Greek + wxFONTENCODING_ISO8859_8, // Hebrew + wxFONTENCODING_ISO8859_9, // Turkish (Latin5) + wxFONTENCODING_ISO8859_10, // Variation of Latin4 (Latin6) + wxFONTENCODING_ISO8859_11, // Thai + wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it + // here anyhow to make all ISO8859 + // consecutive numbers + wxFONTENCODING_ISO8859_13, // Latin7 + wxFONTENCODING_ISO8859_14, // Latin8 + wxFONTENCODING_ISO8859_15, // Latin9 (a.k.a. Latin0, includes euro) + + // Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html) + wxFONTENCODING_KOI8, // we don't support any of KOI8 variants + wxFONTENCODING_ALTERNATIVE, // same as MS-DOS CP866 + wxFONTENCODING_BULGARIAN, // used under Linux in Bulgaria + + // what would we do without Microsoft? They have their own encodings + // for DOS + wxFONTENCODING_CP437, // original MS-DOS codepage + wxFONTENCODING_CP850, // CP437 merged with Latin1 + wxFONTENCODING_CP852, // CP437 merged with Latin2 + wxFONTENCODING_CP855, // another cyrillic encoding + wxFONTENCODING_CP866 = wxFONTENCODING_ALTERNATIVE, + // and for Windows + wxFONTENCODING_CP1250, // WinLatin2 + wxFONTENCODING_CP1251, // WinCyrillic + wxFONTENCODING_CP1252, // WinLatin1 + + wxFONTENCODING_MAX +}; + +// ---------------------------------------------------------------------------- +// wxFontBase represents a font object +// ---------------------------------------------------------------------------- + +class wxFontBase : public wxGDIObject +{ +public: + // creator function + static wxFont *New( + int pointSize, // size of the font in points + int family, // see wxFontFamily enum + int style, // see wxFontStyle enum + int weight, // see wxFontWeight enum + bool underlined = FALSE, // not underlined by default + const wxString& face = wxEmptyString, // facename + wxFontEncoding encoding = wxFONTENCODING_DEFAULT); // ISO8859-X, ... + + // was the font successfully created? + bool Ok() const { return m_refData != NULL; } + + // comparison + bool operator == (const wxFont& font) const; + bool operator != (const wxFont& font) const; + + // accessors: get the font characteristics + virtual int GetPointSize() const = 0; + virtual int GetFamily() const = 0; + virtual int GetStyle() const = 0; + virtual int GetWeight() const = 0; + virtual bool GetUnderlined() const = 0; + virtual wxString GetFaceName() const = 0; + virtual wxFontEncoding GetEncoding() const = 0; + + // change the font characteristics + virtual void SetPointSize( int pointSize ) = 0; + virtual void SetFamily( int family ) = 0; + virtual void SetStyle( int style ) = 0; + virtual void SetWeight( int weight ) = 0; + virtual void SetFaceName( const wxString& faceName ) = 0; + virtual void SetUnderlined( bool underlined ) = 0; + virtual void SetEncoding(wxFontEncoding encoding) = 0; + + // translate the fonts into human-readable string (i.e. GetStyleString() + // will return "wxITALIC" for an italic font, ...) + wxString GetFamilyString() const; + wxString GetStyleString() const; + wxString GetWeightString() const; + + // the default encoding is used for creating all fonts with default + // encoding parameter + static wxFontEncoding GetDefaultEncoding() + { return ms_encodingDefault; } + static void SetDefaultEncoding(wxFontEncoding encoding) + { ms_encodingDefault = encoding; } + +protected: + // get the internal data + class WXDLLEXPORT wxFontRefData *GetFontData() const + { return (wxFontRefData *)m_refData; } + +private: + // the currently default encoding: by default, it's the default system + // encoding, but may be changed by the application using + // SetDefaultEncoding() to make all subsequent fonts created without + // specifing encoding parameter using this encoding + static wxFontEncoding ms_encodingDefault; +}; + +// include the real class declaration #if defined(__WXMSW__) -#include "wx/msw/font.h" + #include "wx/msw/font.h" #elif defined(__WXMOTIF__) -#include "wx/motif/font.h" + #include "wx/motif/font.h" #elif defined(__WXGTK__) -#include "wx/gtk/font.h" + #include "wx/gtk/font.h" #elif defined(__WXQT__) -#include "wx/qt/font.h" + #include "wx/qt/font.h" #elif defined(__WXMAC__) -#include "wx/mac/font.h" + #include "wx/mac/font.h" #elif defined(__WXPM__) -#include "wx/os2/font.h" + #include "wx/os2/font.h" #elif defined(__WXSTUBS__) -#include "wx/stubs/font.h" + #include "wx/stubs/font.h" #endif +// ---------------------------------------------------------------------------- +// macros +// ---------------------------------------------------------------------------- + +// VZ: this is ugly (FIXME) +#define M_FONTDATA GetFontData() + #endif // _WX_FONT_H_BASE_ diff --git a/include/wx/gdicmn.h b/include/wx/gdicmn.h index 236479a457..b787855e72 100644 --- a/include/wx/gdicmn.h +++ b/include/wx/gdicmn.h @@ -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 // =========================================================================== diff --git a/include/wx/gtk/font.h b/include/wx/gtk/font.h index 14a6533c72..9f7cb9b92b 100644 --- a/include/wx/gtk/font.h +++ b/include/wx/gtk/font.h @@ -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__ diff --git a/include/wx/gtk1/font.h b/include/wx/gtk1/font.h index 14a6533c72..9f7cb9b92b 100644 --- a/include/wx/gtk1/font.h +++ b/include/wx/gtk1/font.h @@ -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__ diff --git a/include/wx/msw/font.h b/include/wx/msw/font.h index a7a6609d2f..36642fd414 100644 --- a/include/wx/msw/font.h +++ b/include/wx/msw/font.h @@ -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 diff --git a/src/common/docview.cpp b/src/common/docview.cpp index 61c7923fa1..b0e3db14b2 100644 --- a/src/common/docview.cpp +++ b/src/common/docview.cpp @@ -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); } } diff --git a/src/common/fontcmn.cpp b/src/common/fontcmn.cpp new file mode 100644 index 0000000000..57a8cf3cc7 --- /dev/null +++ b/src/common/fontcmn.cpp @@ -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"); + } +} + diff --git a/src/common/string.cpp b/src/common/string.cpp index b7221a429a..baa9fafce3 100644 --- a/src/common/string.cpp +++ b/src/common/string.cpp @@ -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('*'): diff --git a/src/gtk/font.cpp b/src/gtk/font.cpp index 7de3862b47..db03f434a6 100644 --- a/src/gtk/font.cpp +++ b/src/gtk/font.cpp @@ -4,11 +4,19 @@ // Author: Robert Roebling // Id: $Id$ // Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem -// Licence: wxWindows licence +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + #ifdef __GNUG__ -#pragma implementation "font.h" + #pragma implementation "font.h" #endif #include "wx/font.h" @@ -16,35 +24,85 @@ #include "wx/log.h" #include "wx/gdicmn.h" #include "wx/tokenzr.h" + #include #include "gdk/gdk.h" -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- // local data -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- -/* -extern wxFontNameDirectory *wxTheFontNameDirectory; -*/ +#if wxUSE_FONTNAMEDIRECTORY + extern wxFontNameDirectory *wxTheFontNameDirectory; +#endif -//----------------------------------------------------------------------------- -// wxFont -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// private functions +// ---------------------------------------------------------------------------- -class wxFontRefData: public wxObjectRefData +// returns TRUE if there are any fonts matching this font spec +static bool wxTestFontSpec(const wxString& fontspec); + +static GdkFont *wxLoadQueryFont( int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString &facename, + wxFontEncoding encoding ); + +static GdkFont *wxLoadQueryNearestFont( int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString &facename, + wxFontEncoding encoding); + +// ---------------------------------------------------------------------------- +// wxFontRefData +// ---------------------------------------------------------------------------- + +class wxFontRefData : public wxObjectRefData { public: + wxFontRefData(int size = wxDEFAULT, + int family = wxDEFAULT, + int style = wxDEFAULT, + int weight = wxDEFAULT, + bool underlined = FALSE, + const wxString& faceName = wxEmptyString, + wxFontEncoding encoding = wxFONTENCODING_DEFAULT) + : m_scaled_xfonts(wxKEY_INTEGER) + { + Init(size, family, style, weight, underlined, faceName, encoding); + } - wxFontRefData(); wxFontRefData( const wxFontRefData& data ); - ~wxFontRefData(); + virtual ~wxFontRefData(); + +protected: + // common part of all ctors + void Init(int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding); + +private: wxList m_scaled_xfonts; + int m_pointSize; - int m_family, m_style, m_weight; + int m_family, + m_style, + m_weight; bool m_underlined; wxString m_faceName; + wxFontEncoding m_encoding; bool m_byXFontName; GdkFont *m_font; @@ -52,28 +110,59 @@ public: friend wxFont; }; -wxFontRefData::wxFontRefData() : m_scaled_xfonts(wxKEY_INTEGER) +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// wxFontRefData +// ---------------------------------------------------------------------------- + +void wxFontRefData::Init(int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) { + if (family == wxDEFAULT) + m_family = wxSWISS; + else + m_family = family; + + m_faceName = faceName; + + if (style == wxDEFAULT) + m_style = wxNORMAL; + else + m_style = style; + + if (weight == wxDEFAULT) + m_weight = wxNORMAL; + else + m_weight = weight; + + if (pointSize == wxDEFAULT) + m_pointSize = 12; + else + m_pointSize = pointSize; + + m_underlined = underlined; + m_encoding = encoding; + m_byXFontName = FALSE; - m_pointSize = 12; - m_family = wxSWISS; - m_style = wxNORMAL; - m_weight = wxNORMAL; - m_underlined = FALSE; m_font = (GdkFont *) NULL; } -wxFontRefData::wxFontRefData( const wxFontRefData& data ) : m_scaled_xfonts(wxKEY_INTEGER) +wxFontRefData::wxFontRefData( const wxFontRefData& data ) + : m_scaled_xfonts(wxKEY_INTEGER) { - m_byXFontName = FALSE; - m_pointSize = data.m_pointSize; - m_family = data.m_family; - m_style = data.m_style; - m_weight = data.m_weight; - m_underlined = data.m_underlined; - m_faceName = data.m_faceName; - m_font = (GdkFont *) NULL; - if (data.m_font) m_font = gdk_font_ref( data.m_font ); + Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight, + data.m_underlined, data.m_faceName, data.m_encoding); + + if (data.m_font) + m_font = gdk_font_ref( data.m_font ); } wxFontRefData::~wxFontRefData() @@ -86,23 +175,31 @@ wxFontRefData::~wxFontRefData() gdk_font_unref( font ); node = next; } - if (m_font) gdk_font_unref( m_font ); + + if (m_font) + gdk_font_unref( m_font ); } -//----------------------------------------------------------------------------- - -#define M_FONTDATA ((wxFontRefData *)m_refData) +// ---------------------------------------------------------------------------- +// wxFont +// ---------------------------------------------------------------------------- IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) -wxFont::wxFont() +void wxFont::Init() { - if (wxTheFontList) wxTheFontList->Append( this ); + if (wxTheFontList) + wxTheFontList->Append( this ); } wxFont::wxFont( GdkFont *font, char *xFontName ) { - if (!xFontName) return; + if (!xFontName) + return; + + // VZ: this ctor ddidn't append the font to wxTheFontList before, but + // there is no reason to not do it, is there? + Init(); m_refData = new wxFontRefData(); @@ -145,71 +242,45 @@ wxFont::wxFont( GdkFont *font, char *xFontName ) else if (M_FONTDATA->m_faceName == _T("UTOPIA")) M_FONTDATA->m_family = wxSCRIPT; } -wxFont::wxFont( int pointSize, int family, int style, int weight, bool underlined, const wxString& face ) +bool wxFont::Create( int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString& face, + wxFontEncoding encoding ) { - m_refData = new wxFontRefData(); + m_refData = new wxFontRefData(pointSize, family, style, weight, + underlined, face, encoding); - if (family == wxDEFAULT) - M_FONTDATA->m_family = wxSWISS; - else - M_FONTDATA->m_family = family; - - if (!face.IsEmpty()) M_FONTDATA->m_faceName = face; - - if (style == wxDEFAULT) - M_FONTDATA->m_style = wxNORMAL; - else - M_FONTDATA->m_style = style; - - if (weight == wxDEFAULT) - M_FONTDATA->m_weight = wxNORMAL; - else - M_FONTDATA->m_weight = weight; - - if (pointSize == wxDEFAULT) - M_FONTDATA->m_pointSize = 12; - else - M_FONTDATA->m_pointSize = pointSize; - - M_FONTDATA->m_underlined = underlined; - - if (wxTheFontList) wxTheFontList->Append( this ); + Init(); + return TRUE; } -wxFont::wxFont( const wxFont& font ) +void wxFont::Unshare() { - Ref( font ); - - if (wxTheFontList) wxTheFontList->Append( this ); + if (!m_refData) + { + m_refData = new wxFontRefData(); + } + else + { + wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData); + UnRef(); + m_refData = ref; + } } wxFont::~wxFont() { - if (wxTheFontList) wxTheFontList->DeleteObject( this ); + if (wxTheFontList) + wxTheFontList->DeleteObject( this ); } -wxFont& wxFont::operator = ( const wxFont& font ) -{ - if (*this == font) return (*this); - Ref( font ); - return *this; -} - -bool wxFont::operator == ( const wxFont& font ) const -{ - return m_refData == font.m_refData; -} - -bool wxFont::operator != ( const wxFont& font ) const -{ - return m_refData != font.m_refData; -} - -bool wxFont::Ok() const -{ - return (m_refData != NULL); -} +// ---------------------------------------------------------------------------- +// accessors +// ---------------------------------------------------------------------------- int wxFont::GetPointSize() const { @@ -232,24 +303,6 @@ int wxFont::GetFamily() const return M_FONTDATA->m_family; } -wxString wxFont::GetFamilyString() const -{ - wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") ); - - switch (M_FONTDATA->m_family) - { - case wxDECORATIVE: return wxString(_T("wxDECORATIVE")); - case wxROMAN: return wxString(_T("wxROMAN")); - case wxSCRIPT: return wxString(_T("wxSCRIPT")); - case wxSWISS: return wxString(_T("wxSWISS")); - case wxMODERN: return wxString(_T("wxMODERN")); - case wxTELETYPE: return wxString(_T("wxTELETYPE")); - default: return _T("wxDEFAULT"); - } - - return "wxDEFAULT"; -} - int wxFont::GetStyle() const { wxCHECK_MSG( Ok(), 0, _T("invalid font") ); @@ -257,21 +310,6 @@ int wxFont::GetStyle() const return M_FONTDATA->m_style; } -wxString wxFont::GetStyleString() const -{ - wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") ); - - switch (M_FONTDATA->m_style) - { - case wxNORMAL: return wxString(_T("wxNORMAL")); - case wxSLANT: return wxString(_T("wxSLANT")); - case wxITALIC: return wxString(_T("wxITALIC")); - default: return wxString(_T("wxDEFAULT")); - } - - return wxString(_T("wxDEFAULT")); -} - int wxFont::GetWeight() const { wxCHECK_MSG( Ok(), 0, _T("invalid font") ); @@ -279,21 +317,6 @@ int wxFont::GetWeight() const return M_FONTDATA->m_weight; } -wxString wxFont::GetWeightString() const -{ - wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") ); - - switch (M_FONTDATA->m_weight) - { - case wxNORMAL: return wxString(_T("wxNORMAL")); - case wxBOLD: return wxString(_T("wxBOLD")); - case wxLIGHT: return wxString(_T("wxLIGHT")); - default: return wxString(_T("wxDEFAULT")); - } - - return wxString(_T("wxDEFAULT")); -} - bool wxFont::GetUnderlined() const { wxCHECK_MSG( Ok(), FALSE, _T("invalid font") ); @@ -301,20 +324,18 @@ bool wxFont::GetUnderlined() const return M_FONTDATA->m_underlined; } -void wxFont::Unshare() + +wxFontEncoding wxFont::GetEncoding() const { - if (!m_refData) - { - m_refData = new wxFontRefData(); - } - else - { - wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData); - UnRef(); - m_refData = ref; - } + wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, _T("invalid font") ); + + return M_FONTDATA->m_encoding; } +// ---------------------------------------------------------------------------- +// change font attributes +// ---------------------------------------------------------------------------- + void wxFont::SetPointSize(int pointSize) { Unshare(); @@ -357,23 +378,29 @@ void wxFont::SetUnderlined(bool underlined) M_FONTDATA->m_underlined = underlined; } -//----------------------------------------------------------------------------- -// get internal representation of font -//----------------------------------------------------------------------------- +void wxFont::SetEncoding(wxFontEncoding encoding) +{ + Unshare(); -static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight, - bool underlined, const wxString &facename ); + M_FONTDATA->m_encoding = encoding; +} + +// ---------------------------------------------------------------------------- +// get internal representation of font +// ---------------------------------------------------------------------------- GdkFont *wxFont::GetInternalFont( float scale ) const { if (!Ok()) { wxFAIL_MSG( _T("invalid font") ); + return (GdkFont*) NULL; } /* short cut if the special X font constructor has been used */ - if (M_FONTDATA->m_byXFontName) return M_FONTDATA->m_font; + if (M_FONTDATA->m_byXFontName) + return M_FONTDATA->m_font; long int_scale = long(scale * 100.0 + 0.5); /* key for fontlist */ int point_scale = (M_FONTDATA->m_pointSize * 10 * int_scale) / 100; @@ -386,7 +413,7 @@ GdkFont *wxFont::GetInternalFont( float scale ) const } else { -/* +#if 0 if ((int_scale == 100) && (M_FONTDATA->m_family == wxSWISS) && (M_FONTDATA->m_style == wxNORMAL) && @@ -397,11 +424,17 @@ GdkFont *wxFont::GetInternalFont( float scale ) const font = gdk_font_load( "-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*" ); } else -*/ +#endif // 0 { - font = wxLoadQueryNearestFont( point_scale, M_FONTDATA->m_family, M_FONTDATA->m_style, - M_FONTDATA->m_weight, M_FONTDATA->m_underlined, M_FONTDATA->m_faceName ); + font = wxLoadQueryNearestFont( point_scale, + M_FONTDATA->m_family, + M_FONTDATA->m_style, + M_FONTDATA->m_weight, + M_FONTDATA->m_underlined, + M_FONTDATA->m_faceName, + M_FONTDATA->m_encoding ); } + M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font ); } @@ -417,13 +450,31 @@ GdkFont *wxFont::GetInternalFont( float scale ) const // local utilities to find a X font //----------------------------------------------------------------------------- -static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight, - bool WXUNUSED(underlined), const wxString &facename ) +// returns TRUE if there are any fonts matching this font spec +static bool wxTestFontSpec(const wxString& fontSpec) { - wxChar *xfamily = (wxChar*) NULL; - wxChar *xstyle = (wxChar*) NULL; - wxChar *xweight = (wxChar*) NULL; + GdkFont *test = gdk_font_load( wxConvCurrent->cWX2MB(fontSpec) ); + if ( test ) + { + gdk_font_unref( test ); + return TRUE; + } + else + { + return FALSE; + } +} + +static GdkFont *wxLoadQueryFont( int pointSize, + int family, + int style, + int weight, + bool WXUNUSED(underlined), + const wxString &facename, + wxFontEncoding encoding ) +{ + wxString xfamily; switch (family) { case wxDECORATIVE: xfamily = _T("lucida"); break; @@ -435,17 +486,20 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight default: xfamily = _T("*"); } + wxString fontSpec; if (!facename.IsEmpty()) { - wxSprintf( wxBuffer, _T("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"), facename.c_str() ); - GdkFont *test = gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) ); - if (test) + fontSpec.Printf(_T("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"), + facename.c_str()); + + if ( wxTestFontSpec(fontSpec) ) { - gdk_font_unref( test ); - xfamily = WXSTRINGCAST facename; + xfamily = facename; } + //else: no such family, use default one instead } + wxString xstyle; switch (style) { case wxITALIC: xstyle = _T("i"); break; @@ -453,6 +507,8 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight case wxNORMAL: xstyle = _T("r"); break; default: xstyle = _T("*"); break; } + + wxString xweight; switch (weight) { case wxBOLD: xweight = _T("bold"); break; @@ -461,46 +517,156 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight default: xweight = _T("*"); break; } - wxSprintf( wxBuffer, _T("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-*-*"), - xfamily, xweight, xstyle, pointSize); + wxString xregistry, xencoding; + if ( encoding == wxFONTENCODING_DEFAULT ) + { + // use the apps default + encoding = wxFont::GetDefaultEncoding(); + } - return gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) ); + bool test = TRUE; // should we test for availability of encoding? + switch ( encoding ) + { + case wxFONTENCODING_ISO8859_1: + case wxFONTENCODING_ISO8859_2: + case wxFONTENCODING_ISO8859_3: + case wxFONTENCODING_ISO8859_4: + case wxFONTENCODING_ISO8859_5: + case wxFONTENCODING_ISO8859_6: + case wxFONTENCODING_ISO8859_7: + case wxFONTENCODING_ISO8859_8: + case wxFONTENCODING_ISO8859_9: + case wxFONTENCODING_ISO8859_10: + case wxFONTENCODING_ISO8859_11: + case wxFONTENCODING_ISO8859_13: + case wxFONTENCODING_ISO8859_14: + case wxFONTENCODING_ISO8859_15: + { + int cp = encoding - wxFONTENCODING_ISO8859_1 + 1; + xregistry = _T("iso8859"); + xencoding.Printf(_T("%d"), cp); + } + break; + + case wxFONTENCODING_KOI8: + xregistry = _T("koi8"); + if ( wxTestFontSpec(_T("-*-*-*-*-*-*-*-*-*-*-*-*-koi8-1")) ) + { + xencoding = _T("1"); + + // test passed, no need to do it once more + test = FALSE; + } + else + { + xencoding = _T("*"); + } + break; + + case wxFONTENCODING_CP1250: + case wxFONTENCODING_CP1251: + case wxFONTENCODING_CP1252: + { + int cp = encoding - wxFONTENCODING_CP1250 + 1250; + fontSpec.Printf(_T("-*-*-*-*-*-*-*-*-*-*-*-*-microsoft-cp%d"), + cp); + if ( wxTestFontSpec(fontSpec) ) + { + xregistry = _T("microsoft"); + xencoding.Printf(_T("cp%d"), cp); + + // test passed, no need to do it once more + test = FALSE; + } + else + { + // fall back to LatinX + xregistry = _T("iso8859"); + xencoding.Printf(_T("%d"), cp - 1249); + } + } + break; + + case wxFONTENCODING_SYSTEM: + default: + test = FALSE; + xregistry = + xencoding = _T("*"); + } + + if ( test ) + { + fontSpec.Printf(_T("-*-*-*-*-*-*-*-*-*-*-*-*-%s-%s"), + xregistry.c_str(), xencoding.c_str()); + if ( !wxTestFontSpec(fontSpec) ) + { + // this encoding isn't available - what to do? + xregistry = + xencoding = _T("*"); + } + } + + // construct the X font spec from our data + fontSpec.Printf(_T("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-%s-%s"), + xfamily.c_str(), xweight.c_str(), xstyle.c_str(), + pointSize, xregistry.c_str(), xencoding.c_str()); + + return gdk_font_load( wxConvCurrent->cWX2MB(fontSpec) ); } -static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight, - bool underlined, const wxString &facename ) +static GdkFont *wxLoadQueryNearestFont( int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString &facename, + wxFontEncoding encoding ) { - GdkFont *font = wxLoadQueryFont( point_size, family, style, weight, underlined, facename ); + GdkFont *font = wxLoadQueryFont( pointSize, family, style, weight, + underlined, facename, encoding ); if (!font) { /* search up and down by stepsize 10 */ - int max_size = point_size + 20 * (1 + (point_size/180)); - int min_size = point_size - 20 * (1 + (point_size/180)); + int max_size = pointSize + 20 * (1 + (pointSize/180)); + int min_size = pointSize - 20 * (1 + (pointSize/180)); int i; /* Search for smaller size (approx.) */ - for (i=point_size-10; !font && i >= 10 && i >= min_size; i -= 10) - font = wxLoadQueryFont(i, family, style, weight, underlined, facename ); + for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 ) + { + font = wxLoadQueryFont(i, family, style, weight, underlined, + facename, encoding ); + } /* Search for larger size (approx.) */ - for (i=point_size+10; !font && i <= max_size; i += 10) - font = wxLoadQueryFont( i, family, style, weight, underlined, facename ); + for ( i = pointSize + 10; !font && i <= max_size; i += 10 ) + { + font = wxLoadQueryFont( i, family, style, weight, underlined, + facename, encoding ); + } /* Try default family */ - if (!font && family != wxDEFAULT) - font = wxLoadQueryFont( point_size, wxDEFAULT, style, weight, underlined, facename ); + if ( !font && family != wxDEFAULT ) + { + font = wxLoadQueryFont( pointSize, wxDEFAULT, style, weight, + underlined, facename, encoding ); + } /* Bogus font */ - if (!font) - font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL, underlined, facename ); + if ( !font ) + { + font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL, + underlined, facename, encoding ); + } } return font; } -/* +// wow, what's this stuff? Is it used/useful? (VZ) +#if 0 //----------------------------------------------------------------------------- // face names and index functions @@ -1047,4 +1213,4 @@ int wxFontNameDirectory::GetFamily(int fontid) return wxDEFAULT; } -*/ +#endif // 0 diff --git a/src/gtk1/font.cpp b/src/gtk1/font.cpp index 7de3862b47..db03f434a6 100644 --- a/src/gtk1/font.cpp +++ b/src/gtk1/font.cpp @@ -4,11 +4,19 @@ // Author: Robert Roebling // Id: $Id$ // Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem -// Licence: wxWindows licence +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + #ifdef __GNUG__ -#pragma implementation "font.h" + #pragma implementation "font.h" #endif #include "wx/font.h" @@ -16,35 +24,85 @@ #include "wx/log.h" #include "wx/gdicmn.h" #include "wx/tokenzr.h" + #include #include "gdk/gdk.h" -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- // local data -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- -/* -extern wxFontNameDirectory *wxTheFontNameDirectory; -*/ +#if wxUSE_FONTNAMEDIRECTORY + extern wxFontNameDirectory *wxTheFontNameDirectory; +#endif -//----------------------------------------------------------------------------- -// wxFont -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// private functions +// ---------------------------------------------------------------------------- -class wxFontRefData: public wxObjectRefData +// returns TRUE if there are any fonts matching this font spec +static bool wxTestFontSpec(const wxString& fontspec); + +static GdkFont *wxLoadQueryFont( int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString &facename, + wxFontEncoding encoding ); + +static GdkFont *wxLoadQueryNearestFont( int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString &facename, + wxFontEncoding encoding); + +// ---------------------------------------------------------------------------- +// wxFontRefData +// ---------------------------------------------------------------------------- + +class wxFontRefData : public wxObjectRefData { public: + wxFontRefData(int size = wxDEFAULT, + int family = wxDEFAULT, + int style = wxDEFAULT, + int weight = wxDEFAULT, + bool underlined = FALSE, + const wxString& faceName = wxEmptyString, + wxFontEncoding encoding = wxFONTENCODING_DEFAULT) + : m_scaled_xfonts(wxKEY_INTEGER) + { + Init(size, family, style, weight, underlined, faceName, encoding); + } - wxFontRefData(); wxFontRefData( const wxFontRefData& data ); - ~wxFontRefData(); + virtual ~wxFontRefData(); + +protected: + // common part of all ctors + void Init(int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding); + +private: wxList m_scaled_xfonts; + int m_pointSize; - int m_family, m_style, m_weight; + int m_family, + m_style, + m_weight; bool m_underlined; wxString m_faceName; + wxFontEncoding m_encoding; bool m_byXFontName; GdkFont *m_font; @@ -52,28 +110,59 @@ public: friend wxFont; }; -wxFontRefData::wxFontRefData() : m_scaled_xfonts(wxKEY_INTEGER) +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// wxFontRefData +// ---------------------------------------------------------------------------- + +void wxFontRefData::Init(int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) { + if (family == wxDEFAULT) + m_family = wxSWISS; + else + m_family = family; + + m_faceName = faceName; + + if (style == wxDEFAULT) + m_style = wxNORMAL; + else + m_style = style; + + if (weight == wxDEFAULT) + m_weight = wxNORMAL; + else + m_weight = weight; + + if (pointSize == wxDEFAULT) + m_pointSize = 12; + else + m_pointSize = pointSize; + + m_underlined = underlined; + m_encoding = encoding; + m_byXFontName = FALSE; - m_pointSize = 12; - m_family = wxSWISS; - m_style = wxNORMAL; - m_weight = wxNORMAL; - m_underlined = FALSE; m_font = (GdkFont *) NULL; } -wxFontRefData::wxFontRefData( const wxFontRefData& data ) : m_scaled_xfonts(wxKEY_INTEGER) +wxFontRefData::wxFontRefData( const wxFontRefData& data ) + : m_scaled_xfonts(wxKEY_INTEGER) { - m_byXFontName = FALSE; - m_pointSize = data.m_pointSize; - m_family = data.m_family; - m_style = data.m_style; - m_weight = data.m_weight; - m_underlined = data.m_underlined; - m_faceName = data.m_faceName; - m_font = (GdkFont *) NULL; - if (data.m_font) m_font = gdk_font_ref( data.m_font ); + Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight, + data.m_underlined, data.m_faceName, data.m_encoding); + + if (data.m_font) + m_font = gdk_font_ref( data.m_font ); } wxFontRefData::~wxFontRefData() @@ -86,23 +175,31 @@ wxFontRefData::~wxFontRefData() gdk_font_unref( font ); node = next; } - if (m_font) gdk_font_unref( m_font ); + + if (m_font) + gdk_font_unref( m_font ); } -//----------------------------------------------------------------------------- - -#define M_FONTDATA ((wxFontRefData *)m_refData) +// ---------------------------------------------------------------------------- +// wxFont +// ---------------------------------------------------------------------------- IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) -wxFont::wxFont() +void wxFont::Init() { - if (wxTheFontList) wxTheFontList->Append( this ); + if (wxTheFontList) + wxTheFontList->Append( this ); } wxFont::wxFont( GdkFont *font, char *xFontName ) { - if (!xFontName) return; + if (!xFontName) + return; + + // VZ: this ctor ddidn't append the font to wxTheFontList before, but + // there is no reason to not do it, is there? + Init(); m_refData = new wxFontRefData(); @@ -145,71 +242,45 @@ wxFont::wxFont( GdkFont *font, char *xFontName ) else if (M_FONTDATA->m_faceName == _T("UTOPIA")) M_FONTDATA->m_family = wxSCRIPT; } -wxFont::wxFont( int pointSize, int family, int style, int weight, bool underlined, const wxString& face ) +bool wxFont::Create( int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString& face, + wxFontEncoding encoding ) { - m_refData = new wxFontRefData(); + m_refData = new wxFontRefData(pointSize, family, style, weight, + underlined, face, encoding); - if (family == wxDEFAULT) - M_FONTDATA->m_family = wxSWISS; - else - M_FONTDATA->m_family = family; - - if (!face.IsEmpty()) M_FONTDATA->m_faceName = face; - - if (style == wxDEFAULT) - M_FONTDATA->m_style = wxNORMAL; - else - M_FONTDATA->m_style = style; - - if (weight == wxDEFAULT) - M_FONTDATA->m_weight = wxNORMAL; - else - M_FONTDATA->m_weight = weight; - - if (pointSize == wxDEFAULT) - M_FONTDATA->m_pointSize = 12; - else - M_FONTDATA->m_pointSize = pointSize; - - M_FONTDATA->m_underlined = underlined; - - if (wxTheFontList) wxTheFontList->Append( this ); + Init(); + return TRUE; } -wxFont::wxFont( const wxFont& font ) +void wxFont::Unshare() { - Ref( font ); - - if (wxTheFontList) wxTheFontList->Append( this ); + if (!m_refData) + { + m_refData = new wxFontRefData(); + } + else + { + wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData); + UnRef(); + m_refData = ref; + } } wxFont::~wxFont() { - if (wxTheFontList) wxTheFontList->DeleteObject( this ); + if (wxTheFontList) + wxTheFontList->DeleteObject( this ); } -wxFont& wxFont::operator = ( const wxFont& font ) -{ - if (*this == font) return (*this); - Ref( font ); - return *this; -} - -bool wxFont::operator == ( const wxFont& font ) const -{ - return m_refData == font.m_refData; -} - -bool wxFont::operator != ( const wxFont& font ) const -{ - return m_refData != font.m_refData; -} - -bool wxFont::Ok() const -{ - return (m_refData != NULL); -} +// ---------------------------------------------------------------------------- +// accessors +// ---------------------------------------------------------------------------- int wxFont::GetPointSize() const { @@ -232,24 +303,6 @@ int wxFont::GetFamily() const return M_FONTDATA->m_family; } -wxString wxFont::GetFamilyString() const -{ - wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") ); - - switch (M_FONTDATA->m_family) - { - case wxDECORATIVE: return wxString(_T("wxDECORATIVE")); - case wxROMAN: return wxString(_T("wxROMAN")); - case wxSCRIPT: return wxString(_T("wxSCRIPT")); - case wxSWISS: return wxString(_T("wxSWISS")); - case wxMODERN: return wxString(_T("wxMODERN")); - case wxTELETYPE: return wxString(_T("wxTELETYPE")); - default: return _T("wxDEFAULT"); - } - - return "wxDEFAULT"; -} - int wxFont::GetStyle() const { wxCHECK_MSG( Ok(), 0, _T("invalid font") ); @@ -257,21 +310,6 @@ int wxFont::GetStyle() const return M_FONTDATA->m_style; } -wxString wxFont::GetStyleString() const -{ - wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") ); - - switch (M_FONTDATA->m_style) - { - case wxNORMAL: return wxString(_T("wxNORMAL")); - case wxSLANT: return wxString(_T("wxSLANT")); - case wxITALIC: return wxString(_T("wxITALIC")); - default: return wxString(_T("wxDEFAULT")); - } - - return wxString(_T("wxDEFAULT")); -} - int wxFont::GetWeight() const { wxCHECK_MSG( Ok(), 0, _T("invalid font") ); @@ -279,21 +317,6 @@ int wxFont::GetWeight() const return M_FONTDATA->m_weight; } -wxString wxFont::GetWeightString() const -{ - wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") ); - - switch (M_FONTDATA->m_weight) - { - case wxNORMAL: return wxString(_T("wxNORMAL")); - case wxBOLD: return wxString(_T("wxBOLD")); - case wxLIGHT: return wxString(_T("wxLIGHT")); - default: return wxString(_T("wxDEFAULT")); - } - - return wxString(_T("wxDEFAULT")); -} - bool wxFont::GetUnderlined() const { wxCHECK_MSG( Ok(), FALSE, _T("invalid font") ); @@ -301,20 +324,18 @@ bool wxFont::GetUnderlined() const return M_FONTDATA->m_underlined; } -void wxFont::Unshare() + +wxFontEncoding wxFont::GetEncoding() const { - if (!m_refData) - { - m_refData = new wxFontRefData(); - } - else - { - wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData); - UnRef(); - m_refData = ref; - } + wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, _T("invalid font") ); + + return M_FONTDATA->m_encoding; } +// ---------------------------------------------------------------------------- +// change font attributes +// ---------------------------------------------------------------------------- + void wxFont::SetPointSize(int pointSize) { Unshare(); @@ -357,23 +378,29 @@ void wxFont::SetUnderlined(bool underlined) M_FONTDATA->m_underlined = underlined; } -//----------------------------------------------------------------------------- -// get internal representation of font -//----------------------------------------------------------------------------- +void wxFont::SetEncoding(wxFontEncoding encoding) +{ + Unshare(); -static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight, - bool underlined, const wxString &facename ); + M_FONTDATA->m_encoding = encoding; +} + +// ---------------------------------------------------------------------------- +// get internal representation of font +// ---------------------------------------------------------------------------- GdkFont *wxFont::GetInternalFont( float scale ) const { if (!Ok()) { wxFAIL_MSG( _T("invalid font") ); + return (GdkFont*) NULL; } /* short cut if the special X font constructor has been used */ - if (M_FONTDATA->m_byXFontName) return M_FONTDATA->m_font; + if (M_FONTDATA->m_byXFontName) + return M_FONTDATA->m_font; long int_scale = long(scale * 100.0 + 0.5); /* key for fontlist */ int point_scale = (M_FONTDATA->m_pointSize * 10 * int_scale) / 100; @@ -386,7 +413,7 @@ GdkFont *wxFont::GetInternalFont( float scale ) const } else { -/* +#if 0 if ((int_scale == 100) && (M_FONTDATA->m_family == wxSWISS) && (M_FONTDATA->m_style == wxNORMAL) && @@ -397,11 +424,17 @@ GdkFont *wxFont::GetInternalFont( float scale ) const font = gdk_font_load( "-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*" ); } else -*/ +#endif // 0 { - font = wxLoadQueryNearestFont( point_scale, M_FONTDATA->m_family, M_FONTDATA->m_style, - M_FONTDATA->m_weight, M_FONTDATA->m_underlined, M_FONTDATA->m_faceName ); + font = wxLoadQueryNearestFont( point_scale, + M_FONTDATA->m_family, + M_FONTDATA->m_style, + M_FONTDATA->m_weight, + M_FONTDATA->m_underlined, + M_FONTDATA->m_faceName, + M_FONTDATA->m_encoding ); } + M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font ); } @@ -417,13 +450,31 @@ GdkFont *wxFont::GetInternalFont( float scale ) const // local utilities to find a X font //----------------------------------------------------------------------------- -static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight, - bool WXUNUSED(underlined), const wxString &facename ) +// returns TRUE if there are any fonts matching this font spec +static bool wxTestFontSpec(const wxString& fontSpec) { - wxChar *xfamily = (wxChar*) NULL; - wxChar *xstyle = (wxChar*) NULL; - wxChar *xweight = (wxChar*) NULL; + GdkFont *test = gdk_font_load( wxConvCurrent->cWX2MB(fontSpec) ); + if ( test ) + { + gdk_font_unref( test ); + return TRUE; + } + else + { + return FALSE; + } +} + +static GdkFont *wxLoadQueryFont( int pointSize, + int family, + int style, + int weight, + bool WXUNUSED(underlined), + const wxString &facename, + wxFontEncoding encoding ) +{ + wxString xfamily; switch (family) { case wxDECORATIVE: xfamily = _T("lucida"); break; @@ -435,17 +486,20 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight default: xfamily = _T("*"); } + wxString fontSpec; if (!facename.IsEmpty()) { - wxSprintf( wxBuffer, _T("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"), facename.c_str() ); - GdkFont *test = gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) ); - if (test) + fontSpec.Printf(_T("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"), + facename.c_str()); + + if ( wxTestFontSpec(fontSpec) ) { - gdk_font_unref( test ); - xfamily = WXSTRINGCAST facename; + xfamily = facename; } + //else: no such family, use default one instead } + wxString xstyle; switch (style) { case wxITALIC: xstyle = _T("i"); break; @@ -453,6 +507,8 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight case wxNORMAL: xstyle = _T("r"); break; default: xstyle = _T("*"); break; } + + wxString xweight; switch (weight) { case wxBOLD: xweight = _T("bold"); break; @@ -461,46 +517,156 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight default: xweight = _T("*"); break; } - wxSprintf( wxBuffer, _T("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-*-*"), - xfamily, xweight, xstyle, pointSize); + wxString xregistry, xencoding; + if ( encoding == wxFONTENCODING_DEFAULT ) + { + // use the apps default + encoding = wxFont::GetDefaultEncoding(); + } - return gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) ); + bool test = TRUE; // should we test for availability of encoding? + switch ( encoding ) + { + case wxFONTENCODING_ISO8859_1: + case wxFONTENCODING_ISO8859_2: + case wxFONTENCODING_ISO8859_3: + case wxFONTENCODING_ISO8859_4: + case wxFONTENCODING_ISO8859_5: + case wxFONTENCODING_ISO8859_6: + case wxFONTENCODING_ISO8859_7: + case wxFONTENCODING_ISO8859_8: + case wxFONTENCODING_ISO8859_9: + case wxFONTENCODING_ISO8859_10: + case wxFONTENCODING_ISO8859_11: + case wxFONTENCODING_ISO8859_13: + case wxFONTENCODING_ISO8859_14: + case wxFONTENCODING_ISO8859_15: + { + int cp = encoding - wxFONTENCODING_ISO8859_1 + 1; + xregistry = _T("iso8859"); + xencoding.Printf(_T("%d"), cp); + } + break; + + case wxFONTENCODING_KOI8: + xregistry = _T("koi8"); + if ( wxTestFontSpec(_T("-*-*-*-*-*-*-*-*-*-*-*-*-koi8-1")) ) + { + xencoding = _T("1"); + + // test passed, no need to do it once more + test = FALSE; + } + else + { + xencoding = _T("*"); + } + break; + + case wxFONTENCODING_CP1250: + case wxFONTENCODING_CP1251: + case wxFONTENCODING_CP1252: + { + int cp = encoding - wxFONTENCODING_CP1250 + 1250; + fontSpec.Printf(_T("-*-*-*-*-*-*-*-*-*-*-*-*-microsoft-cp%d"), + cp); + if ( wxTestFontSpec(fontSpec) ) + { + xregistry = _T("microsoft"); + xencoding.Printf(_T("cp%d"), cp); + + // test passed, no need to do it once more + test = FALSE; + } + else + { + // fall back to LatinX + xregistry = _T("iso8859"); + xencoding.Printf(_T("%d"), cp - 1249); + } + } + break; + + case wxFONTENCODING_SYSTEM: + default: + test = FALSE; + xregistry = + xencoding = _T("*"); + } + + if ( test ) + { + fontSpec.Printf(_T("-*-*-*-*-*-*-*-*-*-*-*-*-%s-%s"), + xregistry.c_str(), xencoding.c_str()); + if ( !wxTestFontSpec(fontSpec) ) + { + // this encoding isn't available - what to do? + xregistry = + xencoding = _T("*"); + } + } + + // construct the X font spec from our data + fontSpec.Printf(_T("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-%s-%s"), + xfamily.c_str(), xweight.c_str(), xstyle.c_str(), + pointSize, xregistry.c_str(), xencoding.c_str()); + + return gdk_font_load( wxConvCurrent->cWX2MB(fontSpec) ); } -static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight, - bool underlined, const wxString &facename ) +static GdkFont *wxLoadQueryNearestFont( int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString &facename, + wxFontEncoding encoding ) { - GdkFont *font = wxLoadQueryFont( point_size, family, style, weight, underlined, facename ); + GdkFont *font = wxLoadQueryFont( pointSize, family, style, weight, + underlined, facename, encoding ); if (!font) { /* search up and down by stepsize 10 */ - int max_size = point_size + 20 * (1 + (point_size/180)); - int min_size = point_size - 20 * (1 + (point_size/180)); + int max_size = pointSize + 20 * (1 + (pointSize/180)); + int min_size = pointSize - 20 * (1 + (pointSize/180)); int i; /* Search for smaller size (approx.) */ - for (i=point_size-10; !font && i >= 10 && i >= min_size; i -= 10) - font = wxLoadQueryFont(i, family, style, weight, underlined, facename ); + for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 ) + { + font = wxLoadQueryFont(i, family, style, weight, underlined, + facename, encoding ); + } /* Search for larger size (approx.) */ - for (i=point_size+10; !font && i <= max_size; i += 10) - font = wxLoadQueryFont( i, family, style, weight, underlined, facename ); + for ( i = pointSize + 10; !font && i <= max_size; i += 10 ) + { + font = wxLoadQueryFont( i, family, style, weight, underlined, + facename, encoding ); + } /* Try default family */ - if (!font && family != wxDEFAULT) - font = wxLoadQueryFont( point_size, wxDEFAULT, style, weight, underlined, facename ); + if ( !font && family != wxDEFAULT ) + { + font = wxLoadQueryFont( pointSize, wxDEFAULT, style, weight, + underlined, facename, encoding ); + } /* Bogus font */ - if (!font) - font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL, underlined, facename ); + if ( !font ) + { + font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL, + underlined, facename, encoding ); + } } return font; } -/* +// wow, what's this stuff? Is it used/useful? (VZ) +#if 0 //----------------------------------------------------------------------------- // face names and index functions @@ -1047,4 +1213,4 @@ int wxFontNameDirectory::GetFamily(int fontid) return wxDEFAULT; } -*/ +#endif // 0 diff --git a/src/html/helpdata.cpp b/src/html/helpdata.cpp index b3c25e134d..df9d785d79 100644 --- a/src/html/helpdata.cpp +++ b/src/html/helpdata.cpp @@ -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; } }; diff --git a/src/msw/font.cpp b/src/msw/font.cpp index b615928b1a..31f47b02a0 100644 --- a/src/msw/font.cpp +++ b/src/msw/font.cpp @@ -9,73 +9,155 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + #ifdef __GNUG__ -#pragma implementation "font.h" + #pragma implementation "font.h" #endif // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" #ifdef __BORLANDC__ -#pragma hdrstop + #pragma hdrstop #endif #ifndef WX_PRECOMP -#include -#include "wx/setup.h" -#include "wx/list.h" -#include "wx/utils.h" -#include "wx/app.h" -#include "wx/font.h" -#endif + #include + #include "wx/setup.h" + #include "wx/list.h" + #include "wx/utils.h" + #include "wx/app.h" + #include "wx/font.h" +#endif // WX_PRECOMP #include "wx/msw/private.h" -#include #if !USE_SHARED_LIBRARIES -IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) + IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) -#if wxUSE_PORTABLE_FONTS_IN_MSW -IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject) + #if wxUSE_PORTABLE_FONTS_IN_MSW + IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject) + #endif #endif -#endif +// ---------------------------------------------------------------------------- +// wxFontRefData - the internal description of the font +// ---------------------------------------------------------------------------- -wxFontRefData::wxFontRefData(void) +class WXDLLEXPORT wxFontRefData: public wxGDIRefData { - m_style = 0; - m_temporary = FALSE; - m_pointSize = 0; - m_family = 0; +friend class WXDLLEXPORT wxFont; + +public: + wxFontRefData() + { + Init(); + } + + wxFontRefData(const wxFontRefData& data) + { + Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight, + data.m_underlined, data.m_faceName, data.m_encoding); + + m_fontId = data.m_fontId; + } + + wxFontRefData(int size, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) + { + Init(size, family, style, weight, underlined, faceName, encoding); + } + + virtual ~wxFontRefData(); + +protected: + // common part of all ctors + void Init(int size, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding); + + // If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE + // DELETED by destructor + bool m_temporary; + + int m_fontId; + + // font characterstics + int m_pointSize; + int m_family; + int m_style; + int m_weight; + bool m_underlined; + wxString m_faceName; + wxFontEncoding m_encoding; + + // Windows font handle + WXHFONT m_hFont; +}; + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// wxFontRefData +// ---------------------------------------------------------------------------- + +void wxFontRefData::Init(int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) +{ + m_style = style; + m_pointSize = pointSize; + m_family = family; + m_style = style; + m_weight = weight; + m_underlined = underlined; + m_faceName = faceName; + m_encoding = encoding; + m_fontId = 0; - m_style = 0; - m_weight = 0; - m_underlined = 0; - m_faceName = ""; - m_hFont = 0; -} - -wxFontRefData::wxFontRefData(const wxFontRefData& data) -{ - m_style = data.m_style; m_temporary = FALSE; - m_pointSize = data.m_pointSize; - m_family = data.m_family; - m_fontId = data.m_fontId; - m_style = data.m_style; - m_weight = data.m_weight; - m_underlined = data.m_underlined; - m_faceName = data.m_faceName; + m_hFont = 0; } -wxFontRefData::~wxFontRefData(void) +wxFontRefData::~wxFontRefData() { if ( m_hFont ) - ::DeleteObject((HFONT) m_hFont); + { + if ( !::DeleteObject((HFONT) m_hFont) ) + { + wxLogLastError("DeleteObject(font)"); + } + } } -wxFont::wxFont(void) +// ---------------------------------------------------------------------------- +// wxFont +// ---------------------------------------------------------------------------- + +void wxFont::Init() { if ( wxTheFontList ) wxTheFontList->Append(this); @@ -84,104 +166,107 @@ wxFont::wxFont(void) /* Constructor for a font. Note that the real construction is done * in wxDC::SetFont, when information is available about scaling etc. */ -wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName) +bool wxFont::Create(int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) { - Create(pointSize, family, style, weight, underlined, faceName); + UnRef(); + m_refData = new wxFontRefData(pointSize, family, style, weight, + underlined, faceName, encoding); - if ( wxTheFontList ) - wxTheFontList->Append(this); -} + RealizeResource(); -bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName) -{ - UnRef(); - m_refData = new wxFontRefData; - - M_FONTDATA->m_family = family; - M_FONTDATA->m_style = style; - M_FONTDATA->m_weight = weight; - M_FONTDATA->m_pointSize = pointSize; - M_FONTDATA->m_underlined = underlined; - M_FONTDATA->m_faceName = faceName; - - RealizeResource(); - - return TRUE; + return TRUE; } wxFont::~wxFont() { - if (wxTheFontList) - wxTheFontList->DeleteObject(this); + if ( wxTheFontList ) + wxTheFontList->DeleteObject(this); } -bool wxFont::RealizeResource(void) +// ---------------------------------------------------------------------------- +// real implementation +// ---------------------------------------------------------------------------- + +bool wxFont::RealizeResource() { - if (M_FONTDATA && !M_FONTDATA->m_hFont) - { + if ( GetResourceHandle() ) + { + // VZ: the old code returned FALSE in this case, but it doesn't seem + // to make sense because the font _was_ created + wxLogDebug(_T("Calling wxFont::RealizeResource() twice")); + + return TRUE; + } + BYTE ff_italic; int ff_weight = 0; int ff_family = 0; - wxString ff_face(_T("")); + wxString ff_face; switch (M_FONTDATA->m_family) { - case wxSCRIPT: ff_family = FF_SCRIPT ; - ff_face = _T("Script") ; - break ; - case wxDECORATIVE: ff_family = FF_DECORATIVE; - break; - case wxROMAN: ff_family = FF_ROMAN; - ff_face = _T("Times New Roman") ; - break; - case wxTELETYPE: - case wxMODERN: ff_family = FF_MODERN; - ff_face = _T("Courier New") ; - break; - case wxSWISS: ff_family = FF_SWISS; - ff_face = _T("Arial") ; - break; - case wxDEFAULT: - default: ff_family = FF_SWISS; - ff_face = _T("Arial") ; + case wxSCRIPT: ff_family = FF_SCRIPT ; + ff_face = _T("Script") ; + break ; + case wxDECORATIVE: ff_family = FF_DECORATIVE; + break; + case wxROMAN: ff_family = FF_ROMAN; + ff_face = _T("Times New Roman") ; + break; + case wxTELETYPE: + case wxMODERN: ff_family = FF_MODERN; + ff_face = _T("Courier New") ; + break; + case wxSWISS: ff_family = FF_SWISS; + ff_face = _T("Arial") ; + break; + case wxDEFAULT: + default: ff_family = FF_SWISS; + ff_face = _T("Arial") ; } if (M_FONTDATA->m_style == wxITALIC || M_FONTDATA->m_style == wxSLANT) - ff_italic = 1; + ff_italic = 1; else - ff_italic = 0; + ff_italic = 0; if (M_FONTDATA->m_weight == wxNORMAL) - ff_weight = FW_NORMAL; + ff_weight = FW_NORMAL; else if (M_FONTDATA->m_weight == wxLIGHT) - ff_weight = FW_LIGHT; + ff_weight = FW_LIGHT; else if (M_FONTDATA->m_weight == wxBOLD) - ff_weight = FW_BOLD; + ff_weight = FW_BOLD; const wxChar* pzFace = (const wxChar*) ff_face; if (!M_FONTDATA->m_faceName.IsNull()) pzFace = (const wxChar*) M_FONTDATA->m_faceName ; -/* Always calculate fonts using the screen DC (is this the best strategy?) - * There may be confusion if a font is selected into a printer - * DC (say), because the height will be calculated very differently. + /* Always calculate fonts using the screen DC (is this the best strategy?) + * There may be confusion if a font is selected into a printer + * DC (say), because the height will be calculated very differently. // What sort of display is it? int technology = ::GetDeviceCaps(dc, TECHNOLOGY); int nHeight; - + if (technology != DT_RASDISPLAY && technology != DT_RASPRINTER) { - // Have to get screen DC Caps, because a metafile will return 0. - HDC dc2 = ::GetDC(NULL); - nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc2, LOGPIXELSY)/72; - ::ReleaseDC(NULL, dc2); + // Have to get screen DC Caps, because a metafile will return 0. + HDC dc2 = ::GetDC(NULL); + nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc2, LOGPIXELSY)/72; + ::ReleaseDC(NULL, dc2); } else { - nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc, LOGPIXELSY)/72; + nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc, LOGPIXELSY)/72; } -*/ + */ // Have to get screen DC Caps, because a metafile will return 0. HDC dc2 = ::GetDC(NULL); int ppInch = ::GetDeviceCaps(dc2, LOGPIXELSY); @@ -191,7 +276,7 @@ bool wxFont::RealizeResource(void) // Large/Small Fonts setting in Windows. This messes // up fonts. So, set ppInch to a constant 96 dpi. ppInch = 96; - + #if wxFONT_SIZE_COMPATIBILITY // Incorrect, but compatible with old wxWindows behaviour int nHeight = (M_FONTDATA->m_pointSize*ppInch/72); @@ -203,55 +288,62 @@ bool wxFont::RealizeResource(void) bool ff_underline = M_FONTDATA->m_underlined; M_FONTDATA->m_hFont = (WXHFONT) CreateFont(nHeight, 0, 0, 0,ff_weight,ff_italic,(BYTE)ff_underline, - 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, - PROOF_QUALITY, DEFAULT_PITCH | ff_family, pzFace); + 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, + PROOF_QUALITY, DEFAULT_PITCH | ff_family, pzFace); #ifdef WXDEBUG_CREATE if (m_hFont==NULL) wxError(_T("Cannot create font"),_T("Internal Error")) ; #endif return (M_FONTDATA->m_hFont != (WXHFONT) NULL); - } - return FALSE; } bool wxFont::FreeResource(bool force) { - if (M_FONTDATA && M_FONTDATA->m_hFont) - { - ::DeleteObject((HFONT) M_FONTDATA->m_hFont); - M_FONTDATA->m_hFont = 0; - return TRUE; - } - return FALSE; + if ( GetResourceHandle() ) + { + if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) ) + { + wxLogLastError("DeleteObject(font)"); + } + + M_FONTDATA->m_hFont = 0; + + return TRUE; + } + return FALSE; } WXHANDLE wxFont::GetResourceHandle() { - if ( !M_FONTDATA ) - return 0; - else - return (WXHANDLE)M_FONTDATA->m_hFont ; + if ( !M_FONTDATA ) + return 0; + else + return (WXHANDLE)M_FONTDATA->m_hFont ; } bool wxFont::IsFree() const { - return (M_FONTDATA && (M_FONTDATA->m_hFont == 0)); + return (M_FONTDATA && (M_FONTDATA->m_hFont == 0)); } void wxFont::Unshare() { // Don't change shared data - if (!m_refData) + if ( !m_refData ) { m_refData = new wxFontRefData(); } else { - wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData); + wxFontRefData* ref = new wxFontRefData(*M_FONTDATA); UnRef(); m_refData = ref; } } +// ---------------------------------------------------------------------------- +// change font attribute: we recreate font when doing it +// ---------------------------------------------------------------------------- + void wxFont::SetPointSize(int pointSize) { Unshare(); @@ -306,77 +398,58 @@ void wxFont::SetUnderlined(bool underlined) RealizeResource(); } -wxString wxFont::GetFamilyString(void) const +void wxFont::SetEncoding(wxFontEncoding encoding) { - wxString fam(_T("")); - switch (GetFamily()) - { - case wxDECORATIVE: - fam = _T("wxDECORATIVE"); - break; - case wxROMAN: - fam = _T("wxROMAN"); - break; - case wxSCRIPT: - fam = _T("wxSCRIPT"); - break; - case wxSWISS: - fam = _T("wxSWISS"); - break; - case wxMODERN: - fam = _T("wxMODERN"); - break; - case wxTELETYPE: - fam = _T("wxTELETYPE"); - break; - default: - fam = _T("wxDEFAULT"); - break; - } - return fam; + Unshare(); + + M_FONTDATA->m_encoding = encoding; + + RealizeResource(); } -wxString wxFont::GetFaceName(void) const +// ---------------------------------------------------------------------------- +// accessors +// ---------------------------------------------------------------------------- + +int wxFont::GetPointSize() const { - wxString str(_T("")); - if (M_FONTDATA) - str = M_FONTDATA->m_faceName ; - return str; + return M_FONTDATA->m_pointSize; } -wxString wxFont::GetStyleString(void) const +int wxFont::GetFamily() const { - wxString styl(_T("")); - switch (GetStyle()) - { - case wxITALIC: - styl = _T("wxITALIC"); - break; - case wxSLANT: - styl = _T("wxSLANT"); - break; - default: - styl = _T("wxNORMAL"); - break; - } - return styl; + return M_FONTDATA->m_family; } -wxString wxFont::GetWeightString(void) const +int wxFont::GetFontId() const { - wxString w(_T("")); - switch (GetWeight()) - { - case wxBOLD: - w = _T("wxBOLD"); - break; - case wxLIGHT: - w = _T("wxLIGHT"); - break; - default: - w = _T("wxNORMAL"); - break; - } - return w; + return M_FONTDATA->m_fontId; } +int wxFont::GetStyle() const +{ + return M_FONTDATA->m_style; +} + +int wxFont::GetWeight() const +{ + return M_FONTDATA->m_weight; +} + +bool wxFont::GetUnderlined() const +{ + return M_FONTDATA->m_underlined; +} + +wxString wxFont::GetFaceName() const +{ + wxString str; + if ( M_FONTDATA ) + str = M_FONTDATA->m_faceName ; + return str; +} + +wxFontEncoding wxFont::GetEncoding() const +{ + return M_FONTDATA->m_encoding; +} diff --git a/src/msw/makefile.b32 b/src/msw/makefile.b32 index a15b3b58ef..81c3599c8b 100644 --- a/src/msw/makefile.b32 +++ b/src/msw/makefile.b32 @@ -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) diff --git a/src/msw/makefile.bcc b/src/msw/makefile.bcc index 5cdf787518..a8f6bfefd5 100644 --- a/src/msw/makefile.bcc +++ b/src/msw/makefile.bcc @@ -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) diff --git a/src/msw/makefile.dos b/src/msw/makefile.dos index 0f533bb882..fa050bb37a 100644 --- a/src/msw/makefile.dos +++ b/src/msw/makefile.dos @@ -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) diff --git a/src/msw/makefile.g95 b/src/msw/makefile.g95 index 28e60757e5..50f249453a 100644 --- a/src/msw/makefile.g95 +++ b/src/msw/makefile.g95 @@ -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) \ diff --git a/src/msw/makefile.sc b/src/msw/makefile.sc index 9749bb4efe..d8e8be09a6 100644 --- a/src/msw/makefile.sc +++ b/src/msw/makefile.sc @@ -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 \ diff --git a/src/msw/makefile.vc b/src/msw/makefile.vc index ac2e1489cf..1daf224332 100644 --- a/src/msw/makefile.vc +++ b/src/msw/makefile.vc @@ -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 \ diff --git a/src/msw/makefile.wat b/src/msw/makefile.wat index eaac121a91..b89805b8c6 100644 --- a/src/msw/makefile.wat +++ b/src/msw/makefile.wat @@ -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) $<