From 0c5d3e1ccd1d27ab0cf913ddbffb1b54b5802f3a Mon Sep 17 00:00:00 2001 From: Vadim Zeitlin Date: Wed, 29 Sep 1999 19:02:07 +0000 Subject: [PATCH] 1. added a brief overview of Unicode support 2. added and documented wxBITMAP() macros (as wxICON) 3. restructured wxFont class, added support of encoding parameter 4. regenerated makefiles to compile the new fontcmn.cpp file 5. corrected bug with non existing files in document-view history git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3753 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- docs/latex/wx/font.tex | 19 +- docs/latex/wx/function.tex | 34 +++ docs/latex/wx/tbitmap.tex | 26 ++- docs/latex/wx/tunicode.tex | 156 +++++++++++++ include/wx/docview.h | 2 + include/wx/font.h | 195 +++++++++++++++- include/wx/gdicmn.h | 10 + include/wx/gtk/font.h | 146 +++++++----- include/wx/gtk1/font.h | 146 +++++++----- include/wx/msw/font.h | 199 ++++++++--------- src/common/docview.cpp | 85 ++++++- src/common/fontcmn.cpp | 112 ++++++++++ src/common/string.cpp | 8 +- src/gtk/font.cpp | 542 +++++++++++++++++++++++++++++---------------- src/gtk1/font.cpp | 542 +++++++++++++++++++++++++++++---------------- src/html/helpdata.cpp | 4 +- src/msw/font.cpp | 429 ++++++++++++++++++++--------------- src/msw/makefile.b32 | 5 +- src/msw/makefile.bcc | 5 +- src/msw/makefile.dos | 8 +- src/msw/makefile.g95 | 3 +- src/msw/makefile.sc | 3 +- src/msw/makefile.vc | 3 +- src/msw/makefile.wat | 6 +- 24 files changed, 1893 insertions(+), 795 deletions(-) create mode 100644 docs/latex/wx/tunicode.tex rewrite include/wx/msw/font.h (81%) create mode 100644 src/common/fontcmn.cpp diff --git a/docs/latex/wx/font.tex b/docs/latex/wx/font.tex index 5c4b554..d8c5046 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 0aca78a..c9b30b5 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 bb9fa87..64bde53 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 0000000..43f36eb --- /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 fb93a4a..3a11b7b 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 fdd9d9d..ff010a2 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 236479a..b787855 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 14a6533..9f7cb9b 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; - - int GetPointSize() const; - int GetFamily() const; - int GetStyle() const; - int GetWeight() const; - bool GetUnderlined() 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 ); - - wxString GetFaceName() const; - wxString GetFamilyString() const; - wxString GetStyleString() const; - wxString GetWeightString() const; - - // implementation - - wxFont( GdkFont* font, char *xFontName ); - void Unshare(); - - GdkFont* GetInternalFont(float scale = 1.0) const; - - // no data :-) + // ctors and such + wxFont() { Init(); } + wxFont(const wxFont& font) { Init(); Ref(font); } + + // assignment + wxFont& operator=(const wxFont& font); + + wxFont(int size, + int family, + int style, + int weight, + bool underlined = FALSE, + const wxString& face = wxEmptyString, + wxFontEncoding encoding = wxFONTENCODING_DEFAULT) + { + Init(); + + (void)Create(size, family, style, weight, underlined, face, encoding); + } + + 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 14a6533..9f7cb9b 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; - - int GetPointSize() const; - int GetFamily() const; - int GetStyle() const; - int GetWeight() const; - bool GetUnderlined() 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 ); - - wxString GetFaceName() const; - wxString GetFamilyString() const; - wxString GetStyleString() const; - wxString GetWeightString() const; - - // implementation - - wxFont( GdkFont* font, char *xFontName ); - void Unshare(); - - GdkFont* GetInternalFont(float scale = 1.0) const; - - // no data :-) + // ctors and such + wxFont() { Init(); } + wxFont(const wxFont& font) { Init(); Ref(font); } + + // assignment + wxFont& operator=(const wxFont& font); + + wxFont(int size, + int family, + int style, + int weight, + bool underlined = FALSE, + const wxString& face = wxEmptyString, + wxFontEncoding encoding = wxFONTENCODING_DEFAULT) + { + Init(); + + (void)Create(size, family, style, weight, underlined, face, encoding); + } + + 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 dissimilarity index 81% index a7a6609..36642fd 100644 --- a/include/wx/msw/font.h +++ b/include/wx/msw/font.h @@ -1,101 +1,98 @@ -///////////////////////////////////////////////////////////////////////////// -// Name: font.h -// Purpose: wxFont class -// Author: Julian Smart -// Modified by: -// Created: 01/02/97 -// RCS-ID: $Id$ -// Copyright: (c) Julian Smart -// Licence: wxWindows licence -///////////////////////////////////////////////////////////////////////////// - -#ifndef _WX_FONT_H_ -#define _WX_FONT_H_ - -#ifdef __GNUG__ -#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 -{ - 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); } - - ~wxFont(void); - - bool Create(int PointSize, int Family, int Style, int Weight, bool underlined = FALSE, const wxString& Face = wxEmptyString); - - // Internal - virtual bool RealizeResource(void); - virtual WXHANDLE GetResourceHandle(void) ; - virtual bool FreeResource(bool force = FALSE); -/* - virtual bool UseResource(void); - virtual bool ReleaseResource(void); -*/ - - virtual bool IsFree() const; - virtual bool Ok(void) const { return (m_refData != NULL) ; } - - 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; } - - 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); - - 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; } - -protected: - void Unshare(); -}; - -#endif - // _WX_FONT_H_ +///////////////////////////////////////////////////////////////////////////// +// Name: font.h +// Purpose: wxFont class +// Author: Julian Smart +// Modified by: +// Created: 01/02/97 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_FONT_H_ +#define _WX_FONT_H_ + +#ifdef __GNUG__ + #pragma interface "font.h" +#endif + +#include "wx/gdiobj.h" + +WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString; + +// ---------------------------------------------------------------------------- +// wxFont +// ---------------------------------------------------------------------------- + +class WXDLLEXPORT wxFont : public wxFontBase +{ +public: + // ctors and such + wxFont() { Init(); } + wxFont(const wxFont& font) { Init(); Ref(font); } + + wxFont(int size, + int family, + int style, + int weight, + bool underlined = FALSE, + const wxString& face = wxEmptyString, + wxFontEncoding encoding = wxFONTENCODING_DEFAULT) + { + Init(); + + (void)Create(size, family, style, weight, underlined, face, encoding); + } + + bool Create(int size, + int family, + int style, + int weight, + bool underlined = FALSE, + const wxString& face = wxEmptyString, + wxFontEncoding encoding = wxFONTENCODING_DEFAULT); + + virtual ~wxFont(); + + // 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; + + 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 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: + // common part of all ctors + void Init(); + + void Unshare(); + +private: + DECLARE_DYNAMIC_CLASS(wxFont) +}; + +#endif + // _WX_FONT_H_ diff --git a/src/common/docview.cpp b/src/common/docview.cpp index 61c7923..b0e3db1 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 0000000..57a8cf3 --- /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 b7221a4..baa9faf 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 7de3862..db03f43 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; -*/ +// ---------------------------------------------------------------------------- -//----------------------------------------------------------------------------- -// wxFont -//----------------------------------------------------------------------------- +#if wxUSE_FONTNAMEDIRECTORY + extern wxFontNameDirectory *wxTheFontNameDirectory; +#endif -class wxFontRefData: public wxObjectRefData +// ---------------------------------------------------------------------------- +// private functions +// ---------------------------------------------------------------------------- + +// 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(); - - if (family == wxDEFAULT) - M_FONTDATA->m_family = wxSWISS; - else - M_FONTDATA->m_family = family; - - if (!face.IsEmpty()) M_FONTDATA->m_faceName = face; + m_refData = new wxFontRefData(pointSize, family, style, weight, + underlined, face, encoding); - 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(); + } + + 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(wxBuffer) ); + 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 7de3862..db03f43 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; -*/ +// ---------------------------------------------------------------------------- -//----------------------------------------------------------------------------- -// wxFont -//----------------------------------------------------------------------------- +#if wxUSE_FONTNAMEDIRECTORY + extern wxFontNameDirectory *wxTheFontNameDirectory; +#endif -class wxFontRefData: public wxObjectRefData +// ---------------------------------------------------------------------------- +// private functions +// ---------------------------------------------------------------------------- + +// 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(); - - if (family == wxDEFAULT) - M_FONTDATA->m_family = wxSWISS; - else - M_FONTDATA->m_family = family; - - if (!face.IsEmpty()) M_FONTDATA->m_faceName = face; + m_refData = new wxFontRefData(pointSize, family, style, weight, + underlined, face, encoding); - 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(); + } + + 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(wxBuffer) ); + 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 b3c25e1..df9d785 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 b615928..31f47b0 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; - m_fontId = 0; - m_style = 0; - m_weight = 0; - m_underlined = 0; - m_faceName = ""; - m_hFont = 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); + } -wxFontRefData::wxFontRefData(const wxFontRefData& data) + 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 = data.m_style; + 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_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); -} - -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(); + 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(); +} + +// ---------------------------------------------------------------------------- +// accessors +// ---------------------------------------------------------------------------- + +int wxFont::GetPointSize() const +{ + return M_FONTDATA->m_pointSize; +} + +int wxFont::GetFamily() const +{ + return M_FONTDATA->m_family; } -wxString wxFont::GetFaceName(void) const +int wxFont::GetFontId() const { - wxString str(_T("")); - if (M_FONTDATA) - str = M_FONTDATA->m_faceName ; - return str; + return M_FONTDATA->m_fontId; } -wxString wxFont::GetStyleString(void) const +int wxFont::GetStyle() 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_style; } -wxString wxFont::GetWeightString(void) const +int wxFont::GetWeight() 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_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 a15b3b5..81c3599 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 5cdf787..a8f6bfe 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 0f533bb..fa050bb 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 28e6075..50f2494 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 9749bb4..d8e8be0 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 ac2e148..1daf224 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 eaac121..b89805b 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) $< -- 2.7.4