Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. added a brief overview of Unicode support

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


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3753 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-09-29 19:02:07 +00:00
parent 7a3ac80489
commit 0c5d3e1ccd
24 changed files with 1848 additions and 750 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
docs/latex/wx/font.tex
View File

@@ -41,7 +41,8 @@ wxSWISS\_FONT}
Default constructor.
\func{}{wxFont}{\param{int}{ pointSize}, \param{int}{ family}, \param{int}{ style}, \param{int}{ weight},
\param{const bool}{ underline = FALSE}, \param{const wxString\& }{faceName = ""}}
\param{const bool}{ underline = FALSE}, \param{const wxString\& }{faceName = ""},
\param{wxFontEncoding }{encoding = wxFONTENCODING\_DEFAULT}}
Creates a font object.
@@ -70,6 +71,22 @@ Creates a font object.
\docparam{faceName}{An optional string specifying the actual typeface to be used. If the empty string,
a default typeface will chosen based on the family.}
\docparam{encoding}{An encoding which may be one of
\twocolwidtha{5cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf wxFONTENCODING\_SYSTEM}}{Default system encoding.}
\twocolitem{{\bf wxFONTENCODING\_DEFAULT}}{Default application encoding: this
is the encoding set by calls to
\helpref{SetDefaultEncoding}{wxfontsetdefaultencoding} and which may beset to,
say, KOI8 to create all fonts by default with KOI8 encoding. Initially, the
default application encoding is the same as default system encoding.}
\twocolitem{{\bf wxFONTENCODING\_ISO8859\_1...15}}{ISO8859 encodings.}
\twocolitem{{\bf wxFONTENCODING\_KOI8}}{The standard russian encoding for Internet.}
\twocolitem{{\bf wxFONTENCODING\_CP1250...1252}}{Windows encodings similar to ISO8859 (but not identical).}
\end{twocollist}
If the specified encoding isn't available, no font is created.
}
\wxheading{Remarks}
If the desired font does not exist, the closest match will be chosen.

34
docs/latex/wx/function.tex
View File

@@ -1928,6 +1928,23 @@ base classes.
<wx/object.h>
\membersection{wxBITMAP}\label{wxbitmap}
\func{}{wxBITMAP}{bitmapName}
This macro loads a bitmap from either application resources (on the platforms
for which they exist, i.e. Windows and OS2) or from an XPM file. It allows to
avoid using {\tt #ifdef}s when creating bitmaps.
\wxheading{See also}
\helpref{Bitmaps and icons overview}{wxbitmapoverview},
\helpref{wxICON}{wxicon}
\wxheading{Include files}
<wx/gdicmn.h>
\membersection{WXDEBUG\_NEW}\label{debugnew}
\func{}{WXDEBUG\_NEW}{arg}
@@ -1975,6 +1992,23 @@ Example:
\helpref{RTTI overview}{runtimeclassoverview}
\membersection{wxICON}\label{wxicon}
\func{}{wxICON}{iconName}
This macro loads an icon from either application resources (on the platforms
for which they exist, i.e. Windows and OS2) or from an XPM file. It allows to
avoid using {\tt #ifdef}s when creating icons.
\wxheading{See also}
\helpref{Bitmaps and icons overview}{wxbitmapoverview},
\helpref{wxBITMAP}{wxbitmap}
\wxheading{Include files}
<wx/gdicmn.h>
\membersection{WXTRACE}\label{trace}
\wxheading{Include files}

26
docs/latex/wx/tbitmap.tex
View File

@@ -30,7 +30,7 @@ XPM icon file to be available at run-time.
#endif
\end{verbatim}
A macro, wxICON, is available which creates an icon using an XPM
A macro, \helpref{wxICON}{wxicon}, is available which creates an icon using an XPM
on the appropriate platform, or an icon resource on Windows.
\begin{verbatim}
@@ -47,6 +47,30 @@ wxIcon icon("mondrian");
#endif
\end{verbatim}
There is also a corresponding \helpref{wxBITMAP}{wxbitmap} macro which allows
to create the bitmaps in much the same way as \helpref{wxICON}{wxicon} creates
icons. It assumes that bitmaps live in resources under Windows or OS2 and XPM
files under all other platforms (for XPMs, the corresponding file must be
included before this macro is used, of course, and the name of the bitmap
should be the same as the resource name under Windows with {\tt \_xpm}
suffix). For example:
\begin{verbatim}
// an easy and portable way to create a bitmap
wxBitmap bmp(wxBITMAP(bmpname));
// which is roughly equivalent to the following
#if defined(__WXMSW__) || defined(__WXPM__)
wxBitmap bmp("bmpname", wxBITMAP_TYPE_RESOURCE);
#else // Unix
wxBitmap bmp(bmpname_xpm, wxBITMAP_TYPE_XPM);
#endif
\end{verbatim}
You should always use wxICON and wxBITMAP macros because they work for any
platform (unlike the code above which doesn't deal with wxMac, wxBe, ...) and
are more short and clear than versions with {\tt #ifdef}s.
\subsection{Supported bitmap file formats}\label{supportedbitmapformats}
The following lists the formats handled on different platforms. Note

156
docs/latex/wx/tunicode.tex Normal file
View File

@@ -0,0 +1,156 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: tunicode.tex
%% Purpose: Overview of the Unicode support in wxWindows
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 22.09.99
%% RCS-ID: $Id$
%% Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
%% Licence: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Unicode support in wxWindows}\label{unicode}
This section briefly describes the state of the Unicode support in wxWindows.
Read it if you want to know more about how to write programs able to work with
characters from languages other than English.
\subsection{What is Unicode?}
Starting with release 2.1 wxWindows has support for compiling in Unicode mode
on the platforms which support it. Unicode is a standard for character
encoding which addreses the shortcomings of the previous, 8 bit standards, by
using 16 bit for encoding each character. This allows to have 65536 characters
instead of the usual 256 and is sufficient to encode all of the world
languages at once. More details about Unicode may be found at {\tt www.unicode.org}.
% TODO expand on it, say that Unicode extends ASCII, mention ISO8859, ...
As this solution is obviously preferable to the previous ones (think of
incompatible encodings for the same language, locale chaos and so on), many
modern ooperating systems support it. The probably first example is Windows NT
which uses only Unicode internally since its very first version.
Writing internationalized programs is much easier with Unicode and, as the
support for it improves, it should become more and more so. Moreover, in the
Windows NT/2000 case, even the program which uses only standard ASCII can profit
from using Unicode because they will work more efficiently - there will be no
need for the system to convert all strings hte program uses to/from Unicode
each time a system call is made.
\subsection{Unicode and ANSI modes}
As not all platforms supported by wxWindows support Unicode (fully) yet, in
many cases it is unwise to write a program which can only work in Unicode
environment. A better solution is to write programs in such way that they may
be compiled either in ANSI (traditional) mode or in the Unicode one.
This can be achieved quite simply by using the means provided by wxWindows.
Basicly, there are only a few things to watch out for:
\begin{itemize}
\item Character type ({\tt char} or {\tt wchar\_t})
\item Literal strings (i.e. {\tt "Hello, world!"} or {\tt '*'})
\item String functions ({\tt strlen()}, {\tt strcpy()}, ...)
\end{itemize}
Let's look at them in order. First of all, each character in an Unicode
program takes 2 bytes instead of usual one, so another type should be used to
store the characters ({\tt char} only holds 1 byte usually). This type is
called {\tt wchar\_t} which stands for {\it wide-character type}.
Also, the string and character constants should be encoded on 2 bytes instead
of one. This is achieved by using the standard C (and C++) way: just put the
letter {\tt 'L'} after any string constant and it becomes a {\it long}
constant, i.e. a wide character one. To make things a bit more readable, you
are also allowed to prefix the constant with {\tt 'L'} instead of putting it
after it.
Finally, the standard C functions don't work with {\tt wchar\_t} strings, so
another set of functions exists which do the same thing but accept
{\tt wchar\_t *} instead of {\tt char *}. For example, a function to get the
length of a wide-character string is called {\tt wcslen()} (compare with
{\tt strlen()} - you see that the only difference is that the "str" prefix
standing for "string" has been replaced with "wcs" standing for
"wide-character string").
To summarize, here is a brief example of how a program which can be compiled
in both ANSI and Unicode modes could look like:
\begin{verbatim}
#ifdef __UNICODE__
wchar_t wch = L'*';
const wchar_t *ws = L"Hello, world!";
int len = wcslen(ws);
#else // ANSI
char ch = '*';
const char *s = "Hello, world!";
int len = strlen(s);
#endif // Unicode/ANSI
\end{verbatim}
Of course, it would be nearly impossibly to write such programs if it had to
be done this way (try to imagine the number of {\tt #ifdef UNICODE} an average
program would have had!). Luckily, there is another way - see the next
section.
\subsection{Unicode support in wxWindows}
In wxWindows, the code fragment froim above should be written instead:
\begin{verbatim}
wxChar ch = T('*');
wxString s = T("Hello, world!");
int len = s.Len();
\end{verbatim}
What happens here? First of all, you see that there are no more {\tt #ifdef}s
at all. Instead, we define some types and macros which behave differently in
the Unicode and ANSI builds and allows us to avoid using conditional
compilation in the program itself.
We have a {\tt wxChar} type which maps either on {\tt char} or {\tt wchar\_t}
depending on the mode in which program is being compiled. There is no need for
a separate type for strings though, because the standard
\helpref{wxString}{wxstring} supports Unicode, i.e. it stores iether ANSI or
Unicode strings depending on the mode.
Finally, there is a special {\tt T()} macro which should enclose all literal
strings in the program. As it's easy to see comparing the last fragment with
the one above, this macro expands to nothing in the (usual) ANSI mode and
prefixes {\tt 'L'} to its argument in the Unicode mode.
The important conclusion is that if you use {\tt wxChar} instead of
{\tt char}, avoid using C style strings and use {\tt wxString} instead and
don't forget to enclose all string literals inside {\tt T()} macro, your
program automatically becomes (almost) Unicode compliant!
Just let us state once again the rules:
\begin{itemize}
\item Always use {\tt wxChar} instead of {\tt char}
\item Always enclose literal string constants in {\tt T()} macro unless
they're already converted to the right representation (another standard
wxWindows macro {\tt \_()} does it, so there is no need for {\tt T()} in this
case) or you intend to pass the constant directly to an external function
which doesn't accept wide-character strings.
\item Use {\tt wxString} instead of C style strings.
\end{itemize}
\subsection{Unicode and the outside world}
We have seen that it was easy to write Unicode programs using wxWindows types
and macros, but it has been also mentioned that it isn't quite enough.
Although everything works fine inside the program, things can get nasty when
it tries to communicate with the outside world which, sadly, often expects
ANSI strings (a notable exception is the entire Win32 API which accepts either
Unicode or ANSI strings and which thus makes it unnecessary to ever perform
any convertions in the program).
To get a ANSI string from a wxString, you may use
\helpref{mb\_str()}{wxstringmbstr} function which always returns an ANSI
string (independently of the mode - while the usual
\helpref{c\_str()}{wxstringcstr} returns a pointer to the internal
representation which is either ASCII or Unicode). More rarely used, but still
useful, is \helpref{wc\_str()}{wxstringwcstr} function which always returns
the Unicode string.
% TODO describe fn_str(), wx_str(), wxCharBuf classes, ...

2
include/wx/docview.h
View File

@@ -362,6 +362,7 @@ public:
// File history management
virtual void AddFileToHistory(const wxString& file);
virtual void RemoveFileFromHistory(int i);
virtual int GetNoHistoryFiles() const;
virtual wxString GetHistoryFile(int i) const;
virtual void FileHistoryUseMenu(wxMenu *menu);
@@ -553,6 +554,7 @@ public:
// Operations
virtual void AddFileToHistory(const wxString& file);
virtual void RemoveFileFromHistory(int i);
virtual int GetMaxFiles() const { return m_fileMaxFiles; }
virtual void UseMenu(wxMenu *menu);

195
include/wx/font.h
View File

@@ -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_

10
include/wx/gdicmn.h
View File

@@ -149,6 +149,16 @@ enum wxStockCursor
#define wxICON(X) wxIcon("" #X "")
#endif // platform
/* Another macro: this one is for portable creation of bitmaps. We assume that
under Unix bitmaps live in XPMs and under Windows they're in ressources.
*/
#if defined(__WXMSW__) || defined(__WXPM__)
#define wxBITMAP(name) wxBitmap(#name, wxBITMAP_TYPE_RESOURCE)
#else // !(Windows || OS2)
#define wxBITMAP(name) wxBitmap(name##_xpm, wxBITMAP_TYPE_XPM)
#endif // platform
// ===========================================================================
// classes
// ===========================================================================

138
include/wx/gtk/font.h
View File

@@ -7,12 +7,11 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKFONTH__
#define __GTKFONTH__
#ifdef __GNUG__
#pragma interface
#pragma interface
#endif
#include "wx/defs.h"
@@ -21,79 +20,111 @@
#include "wx/hash.h"
#include "wx/gdiobj.h"
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// conditional compilation
// ----------------------------------------------------------------------------
#define wxUSE_FONTNAMEDIRECTORY 0
// ----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxDC;
class wxPaintDC;
class wxWindow;
class wxFont;
/*
class wxFontNameDirectory;
*/
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
class wxFontNameDirectory;
#endif
// ----------------------------------------------------------------------------
// global variables
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/*
extern wxFontNameDirectory *wxTheFontNameDirectory;
*/
extern const wxChar* wxEmptyString;
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
extern wxFontNameDirectory *wxTheFontNameDirectory;
#endif
// ----------------------------------------------------------------------------
// wxFont
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxFont: public wxGDIObject
class wxFont : public wxFontBase
{
DECLARE_DYNAMIC_CLASS(wxFont)
public:
wxFont();
wxFont( int pointSize, int family, int style, int weight, bool underlined = FALSE,
const wxString& face = wxEmptyString );
wxFont( const wxFont& font );
~wxFont();
wxFont& operator = ( const wxFont& font );
bool operator == ( const wxFont& font ) const;
bool operator != ( const wxFont& font ) const;
bool Ok() const;
// ctors and such
wxFont() { Init(); }
wxFont(const wxFont& font) { Init(); Ref(font); }
int GetPointSize() const;
int GetFamily() const;
int GetStyle() const;
int GetWeight() const;
bool GetUnderlined() const;
// assignment
wxFont& operator=(const wxFont& font);
void SetPointSize( int pointSize );
void SetFamily( int family );
void SetStyle( int style );
void SetWeight( int weight );
void SetFaceName( const wxString& faceName );
void SetUnderlined( bool underlined );
wxString GetFaceName() const;
wxString GetFamilyString() const;
wxString GetStyleString() const;
wxString GetWeightString() const;
// implementation
wxFont( GdkFont* font, char *xFontName );
void Unshare();
wxFont(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Init();
GdkFont* GetInternalFont(float scale = 1.0) const;
(void)Create(size, family, style, weight, underlined, face, encoding);
}
// no data :-)
bool Create(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
~wxFont();
// implement base class pure virtuals
virtual int GetPointSize() const;
virtual int GetFamily() const;
virtual int GetStyle() const;
virtual int GetWeight() const;
virtual wxString GetFaceName() const;
virtual bool GetUnderlined() const;
virtual wxFontEncoding GetEncoding() const;
virtual void SetPointSize( int pointSize );
virtual void SetFamily( int family );
virtual void SetStyle( int style );
virtual void SetWeight( int weight );
virtual void SetFaceName( const wxString& faceName );
virtual void SetUnderlined( bool underlined );
virtual void SetEncoding(wxFontEncoding encoding);
// implementation from now on
wxFont( GdkFont* font, char *xFontName );
void Unshare();
GdkFont* GetInternalFont(float scale = 1.0) const;
// no data :-)
protected:
// common part of all ctors
void Init();
private:
DECLARE_DYNAMIC_CLASS(wxFont)
};
/*
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
// ----------------------------------------------------------------------------
// wxFontDirectory
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxFontNameDirectory: public wxObject
{
@@ -118,6 +149,7 @@ class wxFontNameDirectory: public wxObject
class wxHashTable *table;
int nextFontId;
};
*/
#endif // wxUSE_FONTNAMEDIRECTORY
#endif // __GTKFONTH__

138
include/wx/gtk1/font.h
View File

@@ -7,12 +7,11 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKFONTH__
#define __GTKFONTH__
#ifdef __GNUG__
#pragma interface
#pragma interface
#endif
#include "wx/defs.h"
@@ -21,79 +20,111 @@
#include "wx/hash.h"
#include "wx/gdiobj.h"
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// conditional compilation
// ----------------------------------------------------------------------------
#define wxUSE_FONTNAMEDIRECTORY 0
// ----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxDC;
class wxPaintDC;
class wxWindow;
class wxFont;
/*
class wxFontNameDirectory;
*/
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
class wxFontNameDirectory;
#endif
// ----------------------------------------------------------------------------
// global variables
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/*
extern wxFontNameDirectory *wxTheFontNameDirectory;
*/
extern const wxChar* wxEmptyString;
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
extern wxFontNameDirectory *wxTheFontNameDirectory;
#endif
// ----------------------------------------------------------------------------
// wxFont
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxFont: public wxGDIObject
class wxFont : public wxFontBase
{
DECLARE_DYNAMIC_CLASS(wxFont)
public:
wxFont();
wxFont( int pointSize, int family, int style, int weight, bool underlined = FALSE,
const wxString& face = wxEmptyString );
wxFont( const wxFont& font );
~wxFont();
wxFont& operator = ( const wxFont& font );
bool operator == ( const wxFont& font ) const;
bool operator != ( const wxFont& font ) const;
bool Ok() const;
// ctors and such
wxFont() { Init(); }
wxFont(const wxFont& font) { Init(); Ref(font); }
int GetPointSize() const;
int GetFamily() const;
int GetStyle() const;
int GetWeight() const;
bool GetUnderlined() const;
// assignment
wxFont& operator=(const wxFont& font);
void SetPointSize( int pointSize );
void SetFamily( int family );
void SetStyle( int style );
void SetWeight( int weight );
void SetFaceName( const wxString& faceName );
void SetUnderlined( bool underlined );
wxString GetFaceName() const;
wxString GetFamilyString() const;
wxString GetStyleString() const;
wxString GetWeightString() const;
// implementation
wxFont( GdkFont* font, char *xFontName );
void Unshare();
wxFont(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Init();
GdkFont* GetInternalFont(float scale = 1.0) const;
(void)Create(size, family, style, weight, underlined, face, encoding);
}
// no data :-)
bool Create(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
~wxFont();
// implement base class pure virtuals
virtual int GetPointSize() const;
virtual int GetFamily() const;
virtual int GetStyle() const;
virtual int GetWeight() const;
virtual wxString GetFaceName() const;
virtual bool GetUnderlined() const;
virtual wxFontEncoding GetEncoding() const;
virtual void SetPointSize( int pointSize );
virtual void SetFamily( int family );
virtual void SetStyle( int style );
virtual void SetWeight( int weight );
virtual void SetFaceName( const wxString& faceName );
virtual void SetUnderlined( bool underlined );
virtual void SetEncoding(wxFontEncoding encoding);
// implementation from now on
wxFont( GdkFont* font, char *xFontName );
void Unshare();
GdkFont* GetInternalFont(float scale = 1.0) const;
// no data :-)
protected:
// common part of all ctors
void Init();
private:
DECLARE_DYNAMIC_CLASS(wxFont)
};
/*
//-----------------------------------------------------------------------------
#if wxUSE_FONTNAMEDIRECTORY
// ----------------------------------------------------------------------------
// wxFontDirectory
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxFontNameDirectory: public wxObject
{
@@ -118,6 +149,7 @@ class wxFontNameDirectory: public wxObject
class wxHashTable *table;
int nextFontId;
};
*/
#endif // wxUSE_FONTNAMEDIRECTORY
#endif // __GTKFONTH__

127
include/wx/msw/font.h
View File

@@ -13,88 +13,85 @@
#define _WX_FONT_H_
#ifdef __GNUG__
#pragma interface "font.h"
#pragma interface "font.h"
#endif
#include "wx/gdiobj.h"
class WXDLLEXPORT wxFont;
class WXDLLEXPORT wxFontRefData: public wxGDIRefData
{
friend class WXDLLEXPORT wxFont;
public:
wxFontRefData(void);
wxFontRefData(const wxFontRefData& data);
~wxFontRefData(void);
protected:
bool m_temporary; // If TRUE, the pointer to the actual font
// is temporary and SHOULD NOT BE DELETED by
// destructor
int m_pointSize;
int m_family;
int m_fontId;
int m_style;
int m_weight;
bool m_underlined;
wxString m_faceName;
WXHFONT m_hFont;
};
#define M_FONTDATA ((wxFontRefData *)m_refData)
WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
// Font
class WXDLLEXPORT wxFont: public wxGDIObject
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxFont : public wxFontBase
{
DECLARE_DYNAMIC_CLASS(wxFont)
public:
wxFont(void);
wxFont(int PointSize, int Family, int Style, int Weight, bool underlined = FALSE, const wxString& Face = wxEmptyString);
inline wxFont(const wxFont& font) { Ref(font); }
// ctors and such
wxFont() { Init(); }
wxFont(const wxFont& font) { Init(); Ref(font); }
~wxFont(void);
wxFont(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Init();
bool Create(int PointSize, int Family, int Style, int Weight, bool underlined = FALSE, const wxString& Face = wxEmptyString);
(void)Create(size, family, style, weight, underlined, face, encoding);
}
// Internal
virtual bool RealizeResource(void);
virtual WXHANDLE GetResourceHandle(void) ;
virtual bool FreeResource(bool force = FALSE);
/*
virtual bool UseResource(void);
virtual bool ReleaseResource(void);
*/
bool Create(int size,
int family,
int style,
int weight,
bool underlined = FALSE,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
virtual bool IsFree() const;
virtual bool Ok(void) const { return (m_refData != NULL) ; }
virtual ~wxFont();
inline int GetPointSize(void) const { return M_FONTDATA->m_pointSize; }
inline int GetFamily(void) const { return M_FONTDATA->m_family; }
inline int GetFontId(void) const { return M_FONTDATA->m_fontId; } /* New font system */
inline int GetStyle(void) const { return M_FONTDATA->m_style; }
inline int GetWeight(void) const { return M_FONTDATA->m_weight; }
wxString GetFamilyString(void) const ;
wxString GetFaceName(void) const ;
wxString GetStyleString(void) const ;
wxString GetWeightString(void) const ;
inline bool GetUnderlined(void) const { return M_FONTDATA->m_underlined; }
// implement base class pure virtuals
virtual int GetPointSize() const;
virtual int GetFamily() const;
virtual int GetStyle() const;
virtual int GetWeight() const;
virtual bool GetUnderlined() const;
virtual wxString GetFaceName() const;
virtual wxFontEncoding GetEncoding() const;
void SetPointSize(int pointSize);
void SetFamily(int family);
void SetStyle(int style);
void SetWeight(int weight);
void SetFaceName(const wxString& faceName);
void SetUnderlined(bool underlined);
virtual void SetPointSize(int pointSize);
virtual void SetFamily(int family);
virtual void SetStyle(int style);
virtual void SetWeight(int weight);
virtual void SetFaceName(const wxString& faceName);
virtual void SetUnderlined(bool underlined);
virtual void SetEncoding(wxFontEncoding encoding);
wxFont& operator = (const wxFont& font) { if (*this == font) return (*this); Ref(font); return *this; }
bool operator == (const wxFont& font) const { return m_refData == font.m_refData; }
bool operator != (const wxFont& font) const { return m_refData != font.m_refData; }
// implementation only from now on
// -------------------------------
int GetFontId() const;
virtual bool IsFree() const;
virtual bool RealizeResource();
virtual WXHANDLE GetResourceHandle();
virtual bool FreeResource(bool force = FALSE);
/*
virtual bool UseResource();
virtual bool ReleaseResource();
*/
protected:
void Unshare();
// common part of all ctors
void Init();
void Unshare();
private:
DECLARE_DYNAMIC_CLASS(wxFont)
};
#endif

85
src/common/docview.cpp
View File

@@ -98,6 +98,12 @@
static inline wxString FindExtension(const wxChar *path);
// ----------------------------------------------------------------------------
// local constants
// ----------------------------------------------------------------------------
static const char *s_MRUEntryFormat = _T("&%d %s");
// ============================================================================
// implementation
// ============================================================================
@@ -1095,6 +1101,12 @@ void wxDocManager::AddFileToHistory(const wxString& file)
m_fileHistory->AddFileToHistory(file);
}
void wxDocManager::RemoveFileFromHistory(int i)
{
if (m_fileHistory)
m_fileHistory->RemoveFileFromHistory(i);
}
wxString wxDocManager::GetHistoryFile(int i) const
{
wxString histFile;
@@ -1482,9 +1494,27 @@ void wxDocParentFrame::OnExit(wxCommandEvent& WXUNUSED(event))
void wxDocParentFrame::OnMRUFile(wxCommandEvent& event)
{
wxString f(m_docManager->GetHistoryFile(event.GetSelection() - wxID_FILE1));
if (f != _T(""))
(void)m_docManager->CreateDocument(f, wxDOC_SILENT);
int n = event.GetSelection() - wxID_FILE1; // the index in MRU list
wxString filename(m_docManager->GetHistoryFile(n));
if ( !filename.IsEmpty() )
{
// verify that the file exists before doing anything else
if ( wxFile::Exists(filename) )
{
// try to open it
(void)m_docManager->CreateDocument(filename, wxDOC_SILENT);
}
else
{
// remove the bogus filename from the MRU list and notify the user
// about it
m_docManager->RemoveFileFromHistory(n);
wxLogError(_("The file '%s' doesn't exist and couldn't be opened.\n"
"It has been also removed from the MRU files list."),
filename.c_str());
}
}
}
// Extend event processing to search the view's event table
@@ -1855,7 +1885,7 @@ void wxFileHistory::AddFileToHistory(const wxString& file)
if (m_fileHistory[i])
{
wxString buf;
buf.Printf(_T("&%d %s"), i+1, m_fileHistory[i]);
buf.Printf(s_MRUEntryFormat, i+1, m_fileHistory[i]);
wxNode* node = m_fileMenus.First();
while (node)
{
@@ -1866,6 +1896,49 @@ void wxFileHistory::AddFileToHistory(const wxString& file)
}
}
void wxFileHistory::RemoveFileFromHistory(int i)
{
wxCHECK_RET( i < m_fileHistoryN,
_T("invalid index in wxFileHistory::RemoveFileFromHistory") );
wxNode* node = m_fileMenus.First();
while ( node )
{
wxMenu* menu = (wxMenu*) node->Data();
// wxMenu::Delete() is missing from wxGTK, so this can't be done :-(
#if 0
// delete the menu items
menu->Delete(wxID_FILE1 + i);
#endif
// delete the element from the array (could use memmove() too...)
delete [] m_fileHistory[i];
int j;
for ( j = i; j < m_fileHistoryN - 1; j++ )
{
m_fileHistory[j] = m_fileHistory[j + 1];
}
// shuffle filenames up
wxString buf;
for ( j = i; j < m_fileHistoryN - 1; j++ )
{
buf.Printf(s_MRUEntryFormat, j + 1, m_fileHistory[j]);
menu->SetLabel(wxID_FILE1 + j, buf);
}
// to be removed as soon as wxMenu::Delete() is implemented
#if 1
menu->SetLabel(wxID_FILE1 + m_fileHistoryN - 1, _T(""));
#endif
node = node->Next();
}
m_fileHistoryN--;
}
wxString wxFileHistory::GetHistoryFile(int i) const
{
if (i < m_fileHistoryN)
@@ -1929,7 +2002,7 @@ void wxFileHistory::AddFilesToMenu()
if (m_fileHistory[i])
{
wxString buf;
buf.Printf(_T("&%d %s"), i+1, m_fileHistory[i]);
buf.Printf(s_MRUEntryFormat, i+1, m_fileHistory[i]);
menu->Append(wxID_FILE1+i, buf);
}
}
@@ -1949,7 +2022,7 @@ void wxFileHistory::AddFilesToMenu(wxMenu* menu)
if (m_fileHistory[i])
{
wxString buf;
buf.Printf(_T("&%d %s"), i+1, m_fileHistory[i]);
buf.Printf(s_MRUEntryFormat, i+1, m_fileHistory[i]);
menu->Append(wxID_FILE1+i, buf);
}
}

112
src/common/fontcmn.cpp Normal file
View File

@@ -0,0 +1,112 @@
/////////////////////////////////////////////////////////////////////////////
// Name: common/fontcmn.cpp
// Purpose: implementation of wxFontBase methods
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.09.99
// RCS-ID: $Id$
// Copyright: (c) wxWindows team
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/font.h"
#endif // WX_PRECOMP
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxFontBase
// ----------------------------------------------------------------------------
wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM;
wxFont *wxFontBase::New(int size,
int family,
int style,
int weight,
bool underlined,
const wxString& face,
wxFontEncoding encoding)
{
return new wxFont(size, family, style, weight, underlined, face, encoding);
}
wxFont& wxFont::operator=(const wxFont& font)
{
if ( this != &font )
Ref(font);
return (wxFont &)*this;
}
// VZ: is it correct to compare pointers and not the contents? (FIXME)
bool wxFontBase::operator==(const wxFont& font) const
{
return m_refData == font.m_refData;
}
bool wxFontBase::operator!=(const wxFont& font) const
{
return m_refData != font.m_refData;
}
wxString wxFontBase::GetFamilyString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch ( GetFamily() )
{
case wxDECORATIVE: return _T("wxDECORATIVE");
case wxROMAN: return _T("wxROMAN");
case wxSCRIPT: return _T("wxSCRIPT");
case wxSWISS: return _T("wxSWISS");
case wxMODERN: return _T("wxMODERN");
case wxTELETYPE: return _T("wxTELETYPE");
default: return _T("wxDEFAULT");
}
}
wxString wxFontBase::GetStyleString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch ( GetStyle() )
{
case wxNORMAL: return _T("wxNORMAL");
case wxSLANT: return _T("wxSLANT");
case wxITALIC: return _T("wxITALIC");
default: return _T("wxDEFAULT");
}
}
wxString wxFontBase::GetWeightString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch ( GetWeight() )
{
case wxNORMAL: return _T("wxNORMAL");
case wxBOLD: return _T("wxBOLD");
case wxLIGHT: return _T("wxLIGHT");
default: return _T("wxDEFAULT");
}
}

8
src/common/string.cpp
View File

@@ -1279,6 +1279,10 @@ int wxString::PrintfV(const wxChar* pszFormat, va_list argptr)
// ----------------------------------------------------------------------------
// misc other operations
// ----------------------------------------------------------------------------
// returns TRUE if the string matches the pattern which may contain '*' and
// '?' metacharacters (as usual, '?' matches any character and '*' any number
// of them)
bool wxString::Matches(const wxChar *pszMask) const
{
// check char by char
@@ -1289,8 +1293,8 @@ bool wxString::Matches(const wxChar *pszMask) const
if ( *pszTxt == _T('\0') )
return FALSE;
pszTxt++;
pszMask++;
// pszText and pszMask will be incremented in the loop statement
break;
case _T('*'):

540
src/gtk/font.cpp
View File

@@ -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 <strings.h>
#include "gdk/gdk.h"
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// local data
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/*
extern wxFontNameDirectory *wxTheFontNameDirectory;
*/
#if wxUSE_FONTNAMEDIRECTORY
extern wxFontNameDirectory *wxTheFontNameDirectory;
#endif
//-----------------------------------------------------------------------------
// wxFont
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
class wxFontRefData: public wxObjectRefData
// returns TRUE if there are any fonts matching this font spec
static bool wxTestFontSpec(const wxString& fontspec);
static GdkFont *wxLoadQueryFont( int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString &facename,
wxFontEncoding encoding );
static GdkFont *wxLoadQueryNearestFont( int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString &facename,
wxFontEncoding encoding);
// ----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------
class wxFontRefData : public wxObjectRefData
{
public:
wxFontRefData(int size = wxDEFAULT,
int family = wxDEFAULT,
int style = wxDEFAULT,
int weight = wxDEFAULT,
bool underlined = FALSE,
const wxString& faceName = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
: m_scaled_xfonts(wxKEY_INTEGER)
{
Init(size, family, style, weight, underlined, faceName, encoding);
}
wxFontRefData();
wxFontRefData( const wxFontRefData& data );
~wxFontRefData();
virtual ~wxFontRefData();
protected:
// common part of all ctors
void Init(int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding);
private:
wxList m_scaled_xfonts;
int m_pointSize;
int m_family, m_style, m_weight;
int m_family,
m_style,
m_weight;
bool m_underlined;
wxString m_faceName;
wxFontEncoding m_encoding;
bool m_byXFontName;
GdkFont *m_font;
@@ -52,28 +110,59 @@ public:
friend wxFont;
};
wxFontRefData::wxFontRefData() : m_scaled_xfonts(wxKEY_INTEGER)
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------
void wxFontRefData::Init(int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding)
{
if (family == wxDEFAULT)
m_family = wxSWISS;
else
m_family = family;
m_faceName = faceName;
if (style == wxDEFAULT)
m_style = wxNORMAL;
else
m_style = style;
if (weight == wxDEFAULT)
m_weight = wxNORMAL;
else
m_weight = weight;
if (pointSize == wxDEFAULT)
m_pointSize = 12;
else
m_pointSize = pointSize;
m_underlined = underlined;
m_encoding = encoding;
m_byXFontName = FALSE;
m_pointSize = 12;
m_family = wxSWISS;
m_style = wxNORMAL;
m_weight = wxNORMAL;
m_underlined = FALSE;
m_font = (GdkFont *) NULL;
}
wxFontRefData::wxFontRefData( const wxFontRefData& data ) : m_scaled_xfonts(wxKEY_INTEGER)
wxFontRefData::wxFontRefData( const wxFontRefData& data )
: m_scaled_xfonts(wxKEY_INTEGER)
{
m_byXFontName = FALSE;
m_pointSize = data.m_pointSize;
m_family = data.m_family;
m_style = data.m_style;
m_weight = data.m_weight;
m_underlined = data.m_underlined;
m_faceName = data.m_faceName;
m_font = (GdkFont *) NULL;
if (data.m_font) m_font = gdk_font_ref( data.m_font );
Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
data.m_underlined, data.m_faceName, data.m_encoding);
if (data.m_font)
m_font = gdk_font_ref( data.m_font );
}
wxFontRefData::~wxFontRefData()
@@ -86,23 +175,31 @@ wxFontRefData::~wxFontRefData()
gdk_font_unref( font );
node = next;
}
if (m_font) gdk_font_unref( m_font );
if (m_font)
gdk_font_unref( m_font );
}
//-----------------------------------------------------------------------------
#define M_FONTDATA ((wxFontRefData *)m_refData)
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
wxFont::wxFont()
void wxFont::Init()
{
if (wxTheFontList) wxTheFontList->Append( this );
if (wxTheFontList)
wxTheFontList->Append( this );
}
wxFont::wxFont( GdkFont *font, char *xFontName )
{
if (!xFontName) return;
if (!xFontName)
return;
// VZ: this ctor ddidn't append the font to wxTheFontList before, but
// there is no reason to not do it, is there?
Init();
m_refData = new wxFontRefData();
@@ -145,71 +242,45 @@ wxFont::wxFont( GdkFont *font, char *xFontName )
else if (M_FONTDATA->m_faceName == _T("UTOPIA")) M_FONTDATA->m_family = wxSCRIPT;
}
wxFont::wxFont( int pointSize, int family, int style, int weight, bool underlined, const wxString& face )
bool wxFont::Create( int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString& face,
wxFontEncoding encoding )
{
m_refData = new wxFontRefData();
m_refData = new wxFontRefData(pointSize, family, style, weight,
underlined, face, encoding);
if (family == wxDEFAULT)
M_FONTDATA->m_family = wxSWISS;
else
M_FONTDATA->m_family = family;
if (!face.IsEmpty()) M_FONTDATA->m_faceName = face;
if (style == wxDEFAULT)
M_FONTDATA->m_style = wxNORMAL;
else
M_FONTDATA->m_style = style;
if (weight == wxDEFAULT)
M_FONTDATA->m_weight = wxNORMAL;
else
M_FONTDATA->m_weight = weight;
if (pointSize == wxDEFAULT)
M_FONTDATA->m_pointSize = 12;
else
M_FONTDATA->m_pointSize = pointSize;
M_FONTDATA->m_underlined = underlined;
if (wxTheFontList) wxTheFontList->Append( this );
Init();
return TRUE;
}
wxFont::wxFont( const wxFont& font )
void wxFont::Unshare()
{
Ref( font );
if (wxTheFontList) wxTheFontList->Append( this );
if (!m_refData)
{
m_refData = new wxFontRefData();
}
else
{
wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
UnRef();
m_refData = ref;
}
}
wxFont::~wxFont()
{
if (wxTheFontList) wxTheFontList->DeleteObject( this );
if (wxTheFontList)
wxTheFontList->DeleteObject( this );
}
wxFont& wxFont::operator = ( const wxFont& font )
{
if (*this == font) return (*this);
Ref( font );
return *this;
}
bool wxFont::operator == ( const wxFont& font ) const
{
return m_refData == font.m_refData;
}
bool wxFont::operator != ( const wxFont& font ) const
{
return m_refData != font.m_refData;
}
bool wxFont::Ok() const
{
return (m_refData != NULL);
}
// ----------------------------------------------------------------------------
// accessors
// ----------------------------------------------------------------------------
int wxFont::GetPointSize() const
{
@@ -232,24 +303,6 @@ int wxFont::GetFamily() const
return M_FONTDATA->m_family;
}
wxString wxFont::GetFamilyString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch (M_FONTDATA->m_family)
{
case wxDECORATIVE: return wxString(_T("wxDECORATIVE"));
case wxROMAN: return wxString(_T("wxROMAN"));
case wxSCRIPT: return wxString(_T("wxSCRIPT"));
case wxSWISS: return wxString(_T("wxSWISS"));
case wxMODERN: return wxString(_T("wxMODERN"));
case wxTELETYPE: return wxString(_T("wxTELETYPE"));
default: return _T("wxDEFAULT");
}
return "wxDEFAULT";
}
int wxFont::GetStyle() const
{
wxCHECK_MSG( Ok(), 0, _T("invalid font") );
@@ -257,21 +310,6 @@ int wxFont::GetStyle() const
return M_FONTDATA->m_style;
}
wxString wxFont::GetStyleString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch (M_FONTDATA->m_style)
{
case wxNORMAL: return wxString(_T("wxNORMAL"));
case wxSLANT: return wxString(_T("wxSLANT"));
case wxITALIC: return wxString(_T("wxITALIC"));
default: return wxString(_T("wxDEFAULT"));
}
return wxString(_T("wxDEFAULT"));
}
int wxFont::GetWeight() const
{
wxCHECK_MSG( Ok(), 0, _T("invalid font") );
@@ -279,21 +317,6 @@ int wxFont::GetWeight() const
return M_FONTDATA->m_weight;
}
wxString wxFont::GetWeightString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch (M_FONTDATA->m_weight)
{
case wxNORMAL: return wxString(_T("wxNORMAL"));
case wxBOLD: return wxString(_T("wxBOLD"));
case wxLIGHT: return wxString(_T("wxLIGHT"));
default: return wxString(_T("wxDEFAULT"));
}
return wxString(_T("wxDEFAULT"));
}
bool wxFont::GetUnderlined() const
{
wxCHECK_MSG( Ok(), FALSE, _T("invalid font") );
@@ -301,20 +324,18 @@ bool wxFont::GetUnderlined() const
return M_FONTDATA->m_underlined;
}
void wxFont::Unshare()
wxFontEncoding wxFont::GetEncoding() const
{
if (!m_refData)
{
m_refData = new wxFontRefData();
}
else
{
wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
UnRef();
m_refData = ref;
}
wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, _T("invalid font") );
return M_FONTDATA->m_encoding;
}
// ----------------------------------------------------------------------------
// change font attributes
// ----------------------------------------------------------------------------
void wxFont::SetPointSize(int pointSize)
{
Unshare();
@@ -357,23 +378,29 @@ void wxFont::SetUnderlined(bool underlined)
M_FONTDATA->m_underlined = underlined;
}
//-----------------------------------------------------------------------------
// get internal representation of font
//-----------------------------------------------------------------------------
void wxFont::SetEncoding(wxFontEncoding encoding)
{
Unshare();
static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight,
bool underlined, const wxString &facename );
M_FONTDATA->m_encoding = encoding;
}
// ----------------------------------------------------------------------------
// get internal representation of font
// ----------------------------------------------------------------------------
GdkFont *wxFont::GetInternalFont( float scale ) const
{
if (!Ok())
{
wxFAIL_MSG( _T("invalid font") );
return (GdkFont*) NULL;
}
/* short cut if the special X font constructor has been used */
if (M_FONTDATA->m_byXFontName) return M_FONTDATA->m_font;
if (M_FONTDATA->m_byXFontName)
return M_FONTDATA->m_font;
long int_scale = long(scale * 100.0 + 0.5); /* key for fontlist */
int point_scale = (M_FONTDATA->m_pointSize * 10 * int_scale) / 100;
@@ -386,7 +413,7 @@ GdkFont *wxFont::GetInternalFont( float scale ) const
}
else
{
/*
#if 0
if ((int_scale == 100) &&
(M_FONTDATA->m_family == wxSWISS) &&
(M_FONTDATA->m_style == wxNORMAL) &&
@@ -397,11 +424,17 @@ GdkFont *wxFont::GetInternalFont( float scale ) const
font = gdk_font_load( "-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*" );
}
else
*/
#endif // 0
{
font = wxLoadQueryNearestFont( point_scale, M_FONTDATA->m_family, M_FONTDATA->m_style,
M_FONTDATA->m_weight, M_FONTDATA->m_underlined, M_FONTDATA->m_faceName );
font = wxLoadQueryNearestFont( point_scale,
M_FONTDATA->m_family,
M_FONTDATA->m_style,
M_FONTDATA->m_weight,
M_FONTDATA->m_underlined,
M_FONTDATA->m_faceName,
M_FONTDATA->m_encoding );
}
M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font );
}
@@ -417,13 +450,31 @@ GdkFont *wxFont::GetInternalFont( float scale ) const
// local utilities to find a X font
//-----------------------------------------------------------------------------
static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight,
bool WXUNUSED(underlined), const wxString &facename )
// returns TRUE if there are any fonts matching this font spec
static bool wxTestFontSpec(const wxString& fontSpec)
{
wxChar *xfamily = (wxChar*) NULL;
wxChar *xstyle = (wxChar*) NULL;
wxChar *xweight = (wxChar*) NULL;
GdkFont *test = gdk_font_load( wxConvCurrent->cWX2MB(fontSpec) );
if ( test )
{
gdk_font_unref( test );
return TRUE;
}
else
{
return FALSE;
}
}
static GdkFont *wxLoadQueryFont( int pointSize,
int family,
int style,
int weight,
bool WXUNUSED(underlined),
const wxString &facename,
wxFontEncoding encoding )
{
wxString xfamily;
switch (family)
{
case wxDECORATIVE: xfamily = _T("lucida"); break;
@@ -435,17 +486,20 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight
default: xfamily = _T("*");
}
wxString fontSpec;
if (!facename.IsEmpty())
{
wxSprintf( wxBuffer, _T("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"), facename.c_str() );
GdkFont *test = gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) );
if (test)
fontSpec.Printf(_T("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"),
facename.c_str());
if ( wxTestFontSpec(fontSpec) )
{
gdk_font_unref( test );
xfamily = WXSTRINGCAST facename;
xfamily = facename;
}
//else: no such family, use default one instead
}
wxString xstyle;
switch (style)
{
case wxITALIC: xstyle = _T("i"); break;
@@ -453,6 +507,8 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight
case wxNORMAL: xstyle = _T("r"); break;
default: xstyle = _T("*"); break;
}
wxString xweight;
switch (weight)
{
case wxBOLD: xweight = _T("bold"); break;
@@ -461,46 +517,156 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight
default: xweight = _T("*"); break;
}
wxSprintf( wxBuffer, _T("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-*-*"),
xfamily, xweight, xstyle, pointSize);
wxString xregistry, xencoding;
if ( encoding == wxFONTENCODING_DEFAULT )
{
// use the apps default
encoding = wxFont::GetDefaultEncoding();
}
return gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) );
bool test = TRUE; // should we test for availability of encoding?
switch ( encoding )
{
case wxFONTENCODING_ISO8859_1:
case wxFONTENCODING_ISO8859_2:
case wxFONTENCODING_ISO8859_3:
case wxFONTENCODING_ISO8859_4:
case wxFONTENCODING_ISO8859_5:
case wxFONTENCODING_ISO8859_6:
case wxFONTENCODING_ISO8859_7:
case wxFONTENCODING_ISO8859_8:
case wxFONTENCODING_ISO8859_9:
case wxFONTENCODING_ISO8859_10:
case wxFONTENCODING_ISO8859_11:
case wxFONTENCODING_ISO8859_13:
case wxFONTENCODING_ISO8859_14:
case wxFONTENCODING_ISO8859_15:
{
int cp = encoding - wxFONTENCODING_ISO8859_1 + 1;
xregistry = _T("iso8859");
xencoding.Printf(_T("%d"), cp);
}
break;
case wxFONTENCODING_KOI8:
xregistry = _T("koi8");
if ( wxTestFontSpec(_T("-*-*-*-*-*-*-*-*-*-*-*-*-koi8-1")) )
{
xencoding = _T("1");
// test passed, no need to do it once more
test = FALSE;
}
else
{
xencoding = _T("*");
}
break;
case wxFONTENCODING_CP1250:
case wxFONTENCODING_CP1251:
case wxFONTENCODING_CP1252:
{
int cp = encoding - wxFONTENCODING_CP1250 + 1250;
fontSpec.Printf(_T("-*-*-*-*-*-*-*-*-*-*-*-*-microsoft-cp%d"),
cp);
if ( wxTestFontSpec(fontSpec) )
{
xregistry = _T("microsoft");
xencoding.Printf(_T("cp%d"), cp);
// test passed, no need to do it once more
test = FALSE;
}
else
{
// fall back to LatinX
xregistry = _T("iso8859");
xencoding.Printf(_T("%d"), cp - 1249);
}
}
break;
case wxFONTENCODING_SYSTEM:
default:
test = FALSE;
xregistry =
xencoding = _T("*");
}
if ( test )
{
fontSpec.Printf(_T("-*-*-*-*-*-*-*-*-*-*-*-*-%s-%s"),
xregistry.c_str(), xencoding.c_str());
if ( !wxTestFontSpec(fontSpec) )
{
// this encoding isn't available - what to do?
xregistry =
xencoding = _T("*");
}
}
// construct the X font spec from our data
fontSpec.Printf(_T("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-%s-%s"),
xfamily.c_str(), xweight.c_str(), xstyle.c_str(),
pointSize, xregistry.c_str(), xencoding.c_str());
return gdk_font_load( wxConvCurrent->cWX2MB(fontSpec) );
}
static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight,
bool underlined, const wxString &facename )
static GdkFont *wxLoadQueryNearestFont( int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString &facename,
wxFontEncoding encoding )
{
GdkFont *font = wxLoadQueryFont( point_size, family, style, weight, underlined, facename );
GdkFont *font = wxLoadQueryFont( pointSize, family, style, weight,
underlined, facename, encoding );
if (!font)
{
/* search up and down by stepsize 10 */
int max_size = point_size + 20 * (1 + (point_size/180));
int min_size = point_size - 20 * (1 + (point_size/180));
int max_size = pointSize + 20 * (1 + (pointSize/180));
int min_size = pointSize - 20 * (1 + (pointSize/180));
int i;
/* Search for smaller size (approx.) */
for (i=point_size-10; !font && i >= 10 && i >= min_size; i -= 10)
font = wxLoadQueryFont(i, family, style, weight, underlined, facename );
for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 )
{
font = wxLoadQueryFont(i, family, style, weight, underlined,
facename, encoding );
}
/* Search for larger size (approx.) */
for (i=point_size+10; !font && i <= max_size; i += 10)
font = wxLoadQueryFont( i, family, style, weight, underlined, facename );
for ( i = pointSize + 10; !font && i <= max_size; i += 10 )
{
font = wxLoadQueryFont( i, family, style, weight, underlined,
facename, encoding );
}
/* Try default family */
if (!font && family != wxDEFAULT)
font = wxLoadQueryFont( point_size, wxDEFAULT, style, weight, underlined, facename );
if ( !font && family != wxDEFAULT )
{
font = wxLoadQueryFont( pointSize, wxDEFAULT, style, weight,
underlined, facename, encoding );
}
/* Bogus font */
if (!font)
font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL, underlined, facename );
if ( !font )
{
font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
underlined, facename, encoding );
}
}
return font;
}
/*
// wow, what's this stuff? Is it used/useful? (VZ)
#if 0
//-----------------------------------------------------------------------------
// face names and index functions
@@ -1047,4 +1213,4 @@ int wxFontNameDirectory::GetFamily(int fontid)
return wxDEFAULT;
}
*/
#endif // 0

540
src/gtk1/font.cpp
View File

@@ -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 <strings.h>
#include "gdk/gdk.h"
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// local data
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/*
extern wxFontNameDirectory *wxTheFontNameDirectory;
*/
#if wxUSE_FONTNAMEDIRECTORY
extern wxFontNameDirectory *wxTheFontNameDirectory;
#endif
//-----------------------------------------------------------------------------
// wxFont
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
class wxFontRefData: public wxObjectRefData
// returns TRUE if there are any fonts matching this font spec
static bool wxTestFontSpec(const wxString& fontspec);
static GdkFont *wxLoadQueryFont( int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString &facename,
wxFontEncoding encoding );
static GdkFont *wxLoadQueryNearestFont( int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString &facename,
wxFontEncoding encoding);
// ----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------
class wxFontRefData : public wxObjectRefData
{
public:
wxFontRefData(int size = wxDEFAULT,
int family = wxDEFAULT,
int style = wxDEFAULT,
int weight = wxDEFAULT,
bool underlined = FALSE,
const wxString& faceName = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
: m_scaled_xfonts(wxKEY_INTEGER)
{
Init(size, family, style, weight, underlined, faceName, encoding);
}
wxFontRefData();
wxFontRefData( const wxFontRefData& data );
~wxFontRefData();
virtual ~wxFontRefData();
protected:
// common part of all ctors
void Init(int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding);
private:
wxList m_scaled_xfonts;
int m_pointSize;
int m_family, m_style, m_weight;
int m_family,
m_style,
m_weight;
bool m_underlined;
wxString m_faceName;
wxFontEncoding m_encoding;
bool m_byXFontName;
GdkFont *m_font;
@@ -52,28 +110,59 @@ public:
friend wxFont;
};
wxFontRefData::wxFontRefData() : m_scaled_xfonts(wxKEY_INTEGER)
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------
void wxFontRefData::Init(int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding)
{
if (family == wxDEFAULT)
m_family = wxSWISS;
else
m_family = family;
m_faceName = faceName;
if (style == wxDEFAULT)
m_style = wxNORMAL;
else
m_style = style;
if (weight == wxDEFAULT)
m_weight = wxNORMAL;
else
m_weight = weight;
if (pointSize == wxDEFAULT)
m_pointSize = 12;
else
m_pointSize = pointSize;
m_underlined = underlined;
m_encoding = encoding;
m_byXFontName = FALSE;
m_pointSize = 12;
m_family = wxSWISS;
m_style = wxNORMAL;
m_weight = wxNORMAL;
m_underlined = FALSE;
m_font = (GdkFont *) NULL;
}
wxFontRefData::wxFontRefData( const wxFontRefData& data ) : m_scaled_xfonts(wxKEY_INTEGER)
wxFontRefData::wxFontRefData( const wxFontRefData& data )
: m_scaled_xfonts(wxKEY_INTEGER)
{
m_byXFontName = FALSE;
m_pointSize = data.m_pointSize;
m_family = data.m_family;
m_style = data.m_style;
m_weight = data.m_weight;
m_underlined = data.m_underlined;
m_faceName = data.m_faceName;
m_font = (GdkFont *) NULL;
if (data.m_font) m_font = gdk_font_ref( data.m_font );
Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
data.m_underlined, data.m_faceName, data.m_encoding);
if (data.m_font)
m_font = gdk_font_ref( data.m_font );
}
wxFontRefData::~wxFontRefData()
@@ -86,23 +175,31 @@ wxFontRefData::~wxFontRefData()
gdk_font_unref( font );
node = next;
}
if (m_font) gdk_font_unref( m_font );
if (m_font)
gdk_font_unref( m_font );
}
//-----------------------------------------------------------------------------
#define M_FONTDATA ((wxFontRefData *)m_refData)
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
wxFont::wxFont()
void wxFont::Init()
{
if (wxTheFontList) wxTheFontList->Append( this );
if (wxTheFontList)
wxTheFontList->Append( this );
}
wxFont::wxFont( GdkFont *font, char *xFontName )
{
if (!xFontName) return;
if (!xFontName)
return;
// VZ: this ctor ddidn't append the font to wxTheFontList before, but
// there is no reason to not do it, is there?
Init();
m_refData = new wxFontRefData();
@@ -145,71 +242,45 @@ wxFont::wxFont( GdkFont *font, char *xFontName )
else if (M_FONTDATA->m_faceName == _T("UTOPIA")) M_FONTDATA->m_family = wxSCRIPT;
}
wxFont::wxFont( int pointSize, int family, int style, int weight, bool underlined, const wxString& face )
bool wxFont::Create( int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString& face,
wxFontEncoding encoding )
{
m_refData = new wxFontRefData();
m_refData = new wxFontRefData(pointSize, family, style, weight,
underlined, face, encoding);
if (family == wxDEFAULT)
M_FONTDATA->m_family = wxSWISS;
else
M_FONTDATA->m_family = family;
if (!face.IsEmpty()) M_FONTDATA->m_faceName = face;
if (style == wxDEFAULT)
M_FONTDATA->m_style = wxNORMAL;
else
M_FONTDATA->m_style = style;
if (weight == wxDEFAULT)
M_FONTDATA->m_weight = wxNORMAL;
else
M_FONTDATA->m_weight = weight;
if (pointSize == wxDEFAULT)
M_FONTDATA->m_pointSize = 12;
else
M_FONTDATA->m_pointSize = pointSize;
M_FONTDATA->m_underlined = underlined;
if (wxTheFontList) wxTheFontList->Append( this );
Init();
return TRUE;
}
wxFont::wxFont( const wxFont& font )
void wxFont::Unshare()
{
Ref( font );
if (wxTheFontList) wxTheFontList->Append( this );
if (!m_refData)
{
m_refData = new wxFontRefData();
}
else
{
wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
UnRef();
m_refData = ref;
}
}
wxFont::~wxFont()
{
if (wxTheFontList) wxTheFontList->DeleteObject( this );
if (wxTheFontList)
wxTheFontList->DeleteObject( this );
}
wxFont& wxFont::operator = ( const wxFont& font )
{
if (*this == font) return (*this);
Ref( font );
return *this;
}
bool wxFont::operator == ( const wxFont& font ) const
{
return m_refData == font.m_refData;
}
bool wxFont::operator != ( const wxFont& font ) const
{
return m_refData != font.m_refData;
}
bool wxFont::Ok() const
{
return (m_refData != NULL);
}
// ----------------------------------------------------------------------------
// accessors
// ----------------------------------------------------------------------------
int wxFont::GetPointSize() const
{
@@ -232,24 +303,6 @@ int wxFont::GetFamily() const
return M_FONTDATA->m_family;
}
wxString wxFont::GetFamilyString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch (M_FONTDATA->m_family)
{
case wxDECORATIVE: return wxString(_T("wxDECORATIVE"));
case wxROMAN: return wxString(_T("wxROMAN"));
case wxSCRIPT: return wxString(_T("wxSCRIPT"));
case wxSWISS: return wxString(_T("wxSWISS"));
case wxMODERN: return wxString(_T("wxMODERN"));
case wxTELETYPE: return wxString(_T("wxTELETYPE"));
default: return _T("wxDEFAULT");
}
return "wxDEFAULT";
}
int wxFont::GetStyle() const
{
wxCHECK_MSG( Ok(), 0, _T("invalid font") );
@@ -257,21 +310,6 @@ int wxFont::GetStyle() const
return M_FONTDATA->m_style;
}
wxString wxFont::GetStyleString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch (M_FONTDATA->m_style)
{
case wxNORMAL: return wxString(_T("wxNORMAL"));
case wxSLANT: return wxString(_T("wxSLANT"));
case wxITALIC: return wxString(_T("wxITALIC"));
default: return wxString(_T("wxDEFAULT"));
}
return wxString(_T("wxDEFAULT"));
}
int wxFont::GetWeight() const
{
wxCHECK_MSG( Ok(), 0, _T("invalid font") );
@@ -279,21 +317,6 @@ int wxFont::GetWeight() const
return M_FONTDATA->m_weight;
}
wxString wxFont::GetWeightString() const
{
wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
switch (M_FONTDATA->m_weight)
{
case wxNORMAL: return wxString(_T("wxNORMAL"));
case wxBOLD: return wxString(_T("wxBOLD"));
case wxLIGHT: return wxString(_T("wxLIGHT"));
default: return wxString(_T("wxDEFAULT"));
}
return wxString(_T("wxDEFAULT"));
}
bool wxFont::GetUnderlined() const
{
wxCHECK_MSG( Ok(), FALSE, _T("invalid font") );
@@ -301,20 +324,18 @@ bool wxFont::GetUnderlined() const
return M_FONTDATA->m_underlined;
}
void wxFont::Unshare()
wxFontEncoding wxFont::GetEncoding() const
{
if (!m_refData)
{
m_refData = new wxFontRefData();
}
else
{
wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
UnRef();
m_refData = ref;
}
wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, _T("invalid font") );
return M_FONTDATA->m_encoding;
}
// ----------------------------------------------------------------------------
// change font attributes
// ----------------------------------------------------------------------------
void wxFont::SetPointSize(int pointSize)
{
Unshare();
@@ -357,23 +378,29 @@ void wxFont::SetUnderlined(bool underlined)
M_FONTDATA->m_underlined = underlined;
}
//-----------------------------------------------------------------------------
// get internal representation of font
//-----------------------------------------------------------------------------
void wxFont::SetEncoding(wxFontEncoding encoding)
{
Unshare();
static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight,
bool underlined, const wxString &facename );
M_FONTDATA->m_encoding = encoding;
}
// ----------------------------------------------------------------------------
// get internal representation of font
// ----------------------------------------------------------------------------
GdkFont *wxFont::GetInternalFont( float scale ) const
{
if (!Ok())
{
wxFAIL_MSG( _T("invalid font") );
return (GdkFont*) NULL;
}
/* short cut if the special X font constructor has been used */
if (M_FONTDATA->m_byXFontName) return M_FONTDATA->m_font;
if (M_FONTDATA->m_byXFontName)
return M_FONTDATA->m_font;
long int_scale = long(scale * 100.0 + 0.5); /* key for fontlist */
int point_scale = (M_FONTDATA->m_pointSize * 10 * int_scale) / 100;
@@ -386,7 +413,7 @@ GdkFont *wxFont::GetInternalFont( float scale ) const
}
else
{
/*
#if 0
if ((int_scale == 100) &&
(M_FONTDATA->m_family == wxSWISS) &&
(M_FONTDATA->m_style == wxNORMAL) &&
@@ -397,11 +424,17 @@ GdkFont *wxFont::GetInternalFont( float scale ) const
font = gdk_font_load( "-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*" );
}
else
*/
#endif // 0
{
font = wxLoadQueryNearestFont( point_scale, M_FONTDATA->m_family, M_FONTDATA->m_style,
M_FONTDATA->m_weight, M_FONTDATA->m_underlined, M_FONTDATA->m_faceName );
font = wxLoadQueryNearestFont( point_scale,
M_FONTDATA->m_family,
M_FONTDATA->m_style,
M_FONTDATA->m_weight,
M_FONTDATA->m_underlined,
M_FONTDATA->m_faceName,
M_FONTDATA->m_encoding );
}
M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font );
}
@@ -417,13 +450,31 @@ GdkFont *wxFont::GetInternalFont( float scale ) const
// local utilities to find a X font
//-----------------------------------------------------------------------------
static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight,
bool WXUNUSED(underlined), const wxString &facename )
// returns TRUE if there are any fonts matching this font spec
static bool wxTestFontSpec(const wxString& fontSpec)
{
wxChar *xfamily = (wxChar*) NULL;
wxChar *xstyle = (wxChar*) NULL;
wxChar *xweight = (wxChar*) NULL;
GdkFont *test = gdk_font_load( wxConvCurrent->cWX2MB(fontSpec) );
if ( test )
{
gdk_font_unref( test );
return TRUE;
}
else
{
return FALSE;
}
}
static GdkFont *wxLoadQueryFont( int pointSize,
int family,
int style,
int weight,
bool WXUNUSED(underlined),
const wxString &facename,
wxFontEncoding encoding )
{
wxString xfamily;
switch (family)
{
case wxDECORATIVE: xfamily = _T("lucida"); break;
@@ -435,17 +486,20 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight
default: xfamily = _T("*");
}
wxString fontSpec;
if (!facename.IsEmpty())
{
wxSprintf( wxBuffer, _T("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"), facename.c_str() );
GdkFont *test = gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) );
if (test)
fontSpec.Printf(_T("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"),
facename.c_str());
if ( wxTestFontSpec(fontSpec) )
{
gdk_font_unref( test );
xfamily = WXSTRINGCAST facename;
xfamily = facename;
}
//else: no such family, use default one instead
}
wxString xstyle;
switch (style)
{
case wxITALIC: xstyle = _T("i"); break;
@@ -453,6 +507,8 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight
case wxNORMAL: xstyle = _T("r"); break;
default: xstyle = _T("*"); break;
}
wxString xweight;
switch (weight)
{
case wxBOLD: xweight = _T("bold"); break;
@@ -461,46 +517,156 @@ static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight
default: xweight = _T("*"); break;
}
wxSprintf( wxBuffer, _T("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-*-*"),
xfamily, xweight, xstyle, pointSize);
wxString xregistry, xencoding;
if ( encoding == wxFONTENCODING_DEFAULT )
{
// use the apps default
encoding = wxFont::GetDefaultEncoding();
}
return gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) );
bool test = TRUE; // should we test for availability of encoding?
switch ( encoding )
{
case wxFONTENCODING_ISO8859_1:
case wxFONTENCODING_ISO8859_2:
case wxFONTENCODING_ISO8859_3:
case wxFONTENCODING_ISO8859_4:
case wxFONTENCODING_ISO8859_5:
case wxFONTENCODING_ISO8859_6:
case wxFONTENCODING_ISO8859_7:
case wxFONTENCODING_ISO8859_8:
case wxFONTENCODING_ISO8859_9:
case wxFONTENCODING_ISO8859_10:
case wxFONTENCODING_ISO8859_11:
case wxFONTENCODING_ISO8859_13:
case wxFONTENCODING_ISO8859_14:
case wxFONTENCODING_ISO8859_15:
{
int cp = encoding - wxFONTENCODING_ISO8859_1 + 1;
xregistry = _T("iso8859");
xencoding.Printf(_T("%d"), cp);
}
break;
case wxFONTENCODING_KOI8:
xregistry = _T("koi8");
if ( wxTestFontSpec(_T("-*-*-*-*-*-*-*-*-*-*-*-*-koi8-1")) )
{
xencoding = _T("1");
// test passed, no need to do it once more
test = FALSE;
}
else
{
xencoding = _T("*");
}
break;
case wxFONTENCODING_CP1250:
case wxFONTENCODING_CP1251:
case wxFONTENCODING_CP1252:
{
int cp = encoding - wxFONTENCODING_CP1250 + 1250;
fontSpec.Printf(_T("-*-*-*-*-*-*-*-*-*-*-*-*-microsoft-cp%d"),
cp);
if ( wxTestFontSpec(fontSpec) )
{
xregistry = _T("microsoft");
xencoding.Printf(_T("cp%d"), cp);
// test passed, no need to do it once more
test = FALSE;
}
else
{
// fall back to LatinX
xregistry = _T("iso8859");
xencoding.Printf(_T("%d"), cp - 1249);
}
}
break;
case wxFONTENCODING_SYSTEM:
default:
test = FALSE;
xregistry =
xencoding = _T("*");
}
if ( test )
{
fontSpec.Printf(_T("-*-*-*-*-*-*-*-*-*-*-*-*-%s-%s"),
xregistry.c_str(), xencoding.c_str());
if ( !wxTestFontSpec(fontSpec) )
{
// this encoding isn't available - what to do?
xregistry =
xencoding = _T("*");
}
}
// construct the X font spec from our data
fontSpec.Printf(_T("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-%s-%s"),
xfamily.c_str(), xweight.c_str(), xstyle.c_str(),
pointSize, xregistry.c_str(), xencoding.c_str());
return gdk_font_load( wxConvCurrent->cWX2MB(fontSpec) );
}
static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight,
bool underlined, const wxString &facename )
static GdkFont *wxLoadQueryNearestFont( int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString &facename,
wxFontEncoding encoding )
{
GdkFont *font = wxLoadQueryFont( point_size, family, style, weight, underlined, facename );
GdkFont *font = wxLoadQueryFont( pointSize, family, style, weight,
underlined, facename, encoding );
if (!font)
{
/* search up and down by stepsize 10 */
int max_size = point_size + 20 * (1 + (point_size/180));
int min_size = point_size - 20 * (1 + (point_size/180));
int max_size = pointSize + 20 * (1 + (pointSize/180));
int min_size = pointSize - 20 * (1 + (pointSize/180));
int i;
/* Search for smaller size (approx.) */
for (i=point_size-10; !font && i >= 10 && i >= min_size; i -= 10)
font = wxLoadQueryFont(i, family, style, weight, underlined, facename );
for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 )
{
font = wxLoadQueryFont(i, family, style, weight, underlined,
facename, encoding );
}
/* Search for larger size (approx.) */
for (i=point_size+10; !font && i <= max_size; i += 10)
font = wxLoadQueryFont( i, family, style, weight, underlined, facename );
for ( i = pointSize + 10; !font && i <= max_size; i += 10 )
{
font = wxLoadQueryFont( i, family, style, weight, underlined,
facename, encoding );
}
/* Try default family */
if (!font && family != wxDEFAULT)
font = wxLoadQueryFont( point_size, wxDEFAULT, style, weight, underlined, facename );
if ( !font && family != wxDEFAULT )
{
font = wxLoadQueryFont( pointSize, wxDEFAULT, style, weight,
underlined, facename, encoding );
}
/* Bogus font */
if (!font)
font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL, underlined, facename );
if ( !font )
{
font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
underlined, facename, encoding );
}
}
return font;
}
/*
// wow, what's this stuff? Is it used/useful? (VZ)
#if 0
//-----------------------------------------------------------------------------
// face names and index functions
@@ -1047,4 +1213,4 @@ int wxFontNameDirectory::GetFamily(int fontid)
return wxDEFAULT;
}
*/
#endif // 0

4
src/html/helpdata.cpp
View File

@@ -82,8 +82,8 @@ static int IndexCompareFunc(const void *a, const void *b)
class HP_Parser : public wxHtmlParser
{
public:
void AddText(const char* text) {}
wxObject* GetProduct() {return NULL;}
void AddText(const char* WXUNUSED(text)) { }
wxObject* GetProduct() { return NULL; }
};

431
src/msw/font.cpp
View File

@@ -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 <stdio.h>
#include "wx/setup.h"
#include "wx/list.h"
#include "wx/utils.h"
#include "wx/app.h"
#include "wx/font.h"
#endif
#include <stdio.h>
#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 <assert.h>
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
#if wxUSE_PORTABLE_FONTS_IN_MSW
IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject)
#if wxUSE_PORTABLE_FONTS_IN_MSW
IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject)
#endif
#endif
#endif
// ----------------------------------------------------------------------------
// wxFontRefData - the internal description of the font
// ----------------------------------------------------------------------------
wxFontRefData::wxFontRefData(void)
class WXDLLEXPORT wxFontRefData: public wxGDIRefData
{
m_style = 0;
m_temporary = FALSE;
m_pointSize = 0;
m_family = 0;
friend class WXDLLEXPORT wxFont;
public:
wxFontRefData()
{
Init();
}
wxFontRefData(const wxFontRefData& data)
{
Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
data.m_underlined, data.m_faceName, data.m_encoding);
m_fontId = data.m_fontId;
}
wxFontRefData(int size,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding)
{
Init(size, family, style, weight, underlined, faceName, encoding);
}
virtual ~wxFontRefData();
protected:
// common part of all ctors
void Init(int size,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding);
// If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE
// DELETED by destructor
bool m_temporary;
int m_fontId;
// font characterstics
int m_pointSize;
int m_family;
int m_style;
int m_weight;
bool m_underlined;
wxString m_faceName;
wxFontEncoding m_encoding;
// Windows font handle
WXHFONT m_hFont;
};
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------
void wxFontRefData::Init(int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding)
{
m_style = style;
m_pointSize = pointSize;
m_family = family;
m_style = style;
m_weight = weight;
m_underlined = underlined;
m_faceName = faceName;
m_encoding = encoding;
m_fontId = 0;
m_style = 0;
m_weight = 0;
m_underlined = 0;
m_faceName = "";
m_hFont = 0;
}
wxFontRefData::wxFontRefData(const wxFontRefData& data)
{
m_style = data.m_style;
m_temporary = FALSE;
m_pointSize = data.m_pointSize;
m_family = data.m_family;
m_fontId = data.m_fontId;
m_style = data.m_style;
m_weight = data.m_weight;
m_underlined = data.m_underlined;
m_faceName = data.m_faceName;
m_hFont = 0;
}
wxFontRefData::~wxFontRefData(void)
wxFontRefData::~wxFontRefData()
{
if ( m_hFont )
::DeleteObject((HFONT) m_hFont);
{
if ( !::DeleteObject((HFONT) m_hFont) )
{
wxLogLastError("DeleteObject(font)");
}
}
}
wxFont::wxFont(void)
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
void wxFont::Init()
{
if ( wxTheFontList )
wxTheFontList->Append(this);
@@ -84,104 +166,107 @@ wxFont::wxFont(void)
/* Constructor for a font. Note that the real construction is done
* in wxDC::SetFont, when information is available about scaling etc.
*/
wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
bool wxFont::Create(int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding)
{
Create(pointSize, family, style, weight, underlined, faceName);
UnRef();
m_refData = new wxFontRefData(pointSize, family, style, weight,
underlined, faceName, encoding);
if ( wxTheFontList )
wxTheFontList->Append(this);
}
RealizeResource();
bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
{
UnRef();
m_refData = new wxFontRefData;
M_FONTDATA->m_family = family;
M_FONTDATA->m_style = style;
M_FONTDATA->m_weight = weight;
M_FONTDATA->m_pointSize = pointSize;
M_FONTDATA->m_underlined = underlined;
M_FONTDATA->m_faceName = faceName;
RealizeResource();
return TRUE;
return TRUE;
}
wxFont::~wxFont()
{
if (wxTheFontList)
wxTheFontList->DeleteObject(this);
if ( wxTheFontList )
wxTheFontList->DeleteObject(this);
}
bool wxFont::RealizeResource(void)
// ----------------------------------------------------------------------------
// real implementation
// ----------------------------------------------------------------------------
bool wxFont::RealizeResource()
{
if (M_FONTDATA && !M_FONTDATA->m_hFont)
{
if ( GetResourceHandle() )
{
// VZ: the old code returned FALSE in this case, but it doesn't seem
// to make sense because the font _was_ created
wxLogDebug(_T("Calling wxFont::RealizeResource() twice"));
return TRUE;
}
BYTE ff_italic;
int ff_weight = 0;
int ff_family = 0;
wxString ff_face(_T(""));
wxString ff_face;
switch (M_FONTDATA->m_family)
{
case wxSCRIPT: ff_family = FF_SCRIPT ;
ff_face = _T("Script") ;
break ;
case wxDECORATIVE: ff_family = FF_DECORATIVE;
break;
case wxROMAN: ff_family = FF_ROMAN;
ff_face = _T("Times New Roman") ;
break;
case wxTELETYPE:
case wxMODERN: ff_family = FF_MODERN;
ff_face = _T("Courier New") ;
break;
case wxSWISS: ff_family = FF_SWISS;
ff_face = _T("Arial") ;
break;
case wxDEFAULT:
default: ff_family = FF_SWISS;
ff_face = _T("Arial") ;
case wxSCRIPT: ff_family = FF_SCRIPT ;
ff_face = _T("Script") ;
break ;
case wxDECORATIVE: ff_family = FF_DECORATIVE;
break;
case wxROMAN: ff_family = FF_ROMAN;
ff_face = _T("Times New Roman") ;
break;
case wxTELETYPE:
case wxMODERN: ff_family = FF_MODERN;
ff_face = _T("Courier New") ;
break;
case wxSWISS: ff_family = FF_SWISS;
ff_face = _T("Arial") ;
break;
case wxDEFAULT:
default: ff_family = FF_SWISS;
ff_face = _T("Arial") ;
}
if (M_FONTDATA->m_style == wxITALIC || M_FONTDATA->m_style == wxSLANT)
ff_italic = 1;
ff_italic = 1;
else
ff_italic = 0;
ff_italic = 0;
if (M_FONTDATA->m_weight == wxNORMAL)
ff_weight = FW_NORMAL;
ff_weight = FW_NORMAL;
else if (M_FONTDATA->m_weight == wxLIGHT)
ff_weight = FW_LIGHT;
ff_weight = FW_LIGHT;
else if (M_FONTDATA->m_weight == wxBOLD)
ff_weight = FW_BOLD;
ff_weight = FW_BOLD;
const wxChar* pzFace = (const wxChar*) ff_face;
if (!M_FONTDATA->m_faceName.IsNull())
pzFace = (const wxChar*) M_FONTDATA->m_faceName ;
/* Always calculate fonts using the screen DC (is this the best strategy?)
* There may be confusion if a font is selected into a printer
* DC (say), because the height will be calculated very differently.
/* Always calculate fonts using the screen DC (is this the best strategy?)
* There may be confusion if a font is selected into a printer
* DC (say), because the height will be calculated very differently.
// What sort of display is it?
int technology = ::GetDeviceCaps(dc, TECHNOLOGY);
int nHeight;
if (technology != DT_RASDISPLAY && technology != DT_RASPRINTER)
{
// Have to get screen DC Caps, because a metafile will return 0.
HDC dc2 = ::GetDC(NULL);
nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc2, LOGPIXELSY)/72;
::ReleaseDC(NULL, dc2);
// Have to get screen DC Caps, because a metafile will return 0.
HDC dc2 = ::GetDC(NULL);
nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc2, LOGPIXELSY)/72;
::ReleaseDC(NULL, dc2);
}
else
{
nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc, LOGPIXELSY)/72;
nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc, LOGPIXELSY)/72;
}
*/
*/
// Have to get screen DC Caps, because a metafile will return 0.
HDC dc2 = ::GetDC(NULL);
int ppInch = ::GetDeviceCaps(dc2, LOGPIXELSY);
@@ -191,7 +276,7 @@ bool wxFont::RealizeResource(void)
// Large/Small Fonts setting in Windows. This messes
// up fonts. So, set ppInch to a constant 96 dpi.
ppInch = 96;
#if wxFONT_SIZE_COMPATIBILITY
// Incorrect, but compatible with old wxWindows behaviour
int nHeight = (M_FONTDATA->m_pointSize*ppInch/72);
@@ -203,55 +288,62 @@ bool wxFont::RealizeResource(void)
bool ff_underline = M_FONTDATA->m_underlined;
M_FONTDATA->m_hFont = (WXHFONT) CreateFont(nHeight, 0, 0, 0,ff_weight,ff_italic,(BYTE)ff_underline,
0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
PROOF_QUALITY, DEFAULT_PITCH | ff_family, pzFace);
0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
PROOF_QUALITY, DEFAULT_PITCH | ff_family, pzFace);
#ifdef WXDEBUG_CREATE
if (m_hFont==NULL) wxError(_T("Cannot create font"),_T("Internal Error")) ;
#endif
return (M_FONTDATA->m_hFont != (WXHFONT) NULL);
}
return FALSE;
}
bool wxFont::FreeResource(bool force)
{
if (M_FONTDATA && M_FONTDATA->m_hFont)
{
::DeleteObject((HFONT) M_FONTDATA->m_hFont);
M_FONTDATA->m_hFont = 0;
return TRUE;
}
return FALSE;
if ( GetResourceHandle() )
{
if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) )
{
wxLogLastError("DeleteObject(font)");
}
M_FONTDATA->m_hFont = 0;
return TRUE;
}
return FALSE;
}
WXHANDLE wxFont::GetResourceHandle()
{
if ( !M_FONTDATA )
return 0;
else
return (WXHANDLE)M_FONTDATA->m_hFont ;
if ( !M_FONTDATA )
return 0;
else
return (WXHANDLE)M_FONTDATA->m_hFont ;
}
bool wxFont::IsFree() const
{
return (M_FONTDATA && (M_FONTDATA->m_hFont == 0));
return (M_FONTDATA && (M_FONTDATA->m_hFont == 0));
}
void wxFont::Unshare()
{
// Don't change shared data
if (!m_refData)
if ( !m_refData )
{
m_refData = new wxFontRefData();
}
else
{
wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
wxFontRefData* ref = new wxFontRefData(*M_FONTDATA);
UnRef();
m_refData = ref;
}
}
// ----------------------------------------------------------------------------
// change font attribute: we recreate font when doing it
// ----------------------------------------------------------------------------
void wxFont::SetPointSize(int pointSize)
{
Unshare();
@@ -306,77 +398,58 @@ void wxFont::SetUnderlined(bool underlined)
RealizeResource();
}
wxString wxFont::GetFamilyString(void) const
void wxFont::SetEncoding(wxFontEncoding encoding)
{
wxString fam(_T(""));
switch (GetFamily())
{
case wxDECORATIVE:
fam = _T("wxDECORATIVE");
break;
case wxROMAN:
fam = _T("wxROMAN");
break;
case wxSCRIPT:
fam = _T("wxSCRIPT");
break;
case wxSWISS:
fam = _T("wxSWISS");
break;
case wxMODERN:
fam = _T("wxMODERN");
break;
case wxTELETYPE:
fam = _T("wxTELETYPE");
break;
default:
fam = _T("wxDEFAULT");
break;
}
return fam;
Unshare();
M_FONTDATA->m_encoding = encoding;
RealizeResource();
}
wxString wxFont::GetFaceName(void) const
// ----------------------------------------------------------------------------
// accessors
// ----------------------------------------------------------------------------
int wxFont::GetPointSize() const
{
wxString str(_T(""));
if (M_FONTDATA)
str = M_FONTDATA->m_faceName ;
return str;
return M_FONTDATA->m_pointSize;
}
wxString wxFont::GetStyleString(void) const
int wxFont::GetFamily() const
{
wxString styl(_T(""));
switch (GetStyle())
{
case wxITALIC:
styl = _T("wxITALIC");
break;
case wxSLANT:
styl = _T("wxSLANT");
break;
default:
styl = _T("wxNORMAL");
break;
}
return styl;
return M_FONTDATA->m_family;
}
wxString wxFont::GetWeightString(void) const
int wxFont::GetFontId() const
{
wxString w(_T(""));
switch (GetWeight())
{
case wxBOLD:
w = _T("wxBOLD");
break;
case wxLIGHT:
w = _T("wxLIGHT");
break;
default:
w = _T("wxNORMAL");
break;
}
return w;
return M_FONTDATA->m_fontId;
}
int wxFont::GetStyle() const
{
return M_FONTDATA->m_style;
}
int wxFont::GetWeight() const
{
return M_FONTDATA->m_weight;
}
bool wxFont::GetUnderlined() const
{
return M_FONTDATA->m_underlined;
}
wxString wxFont::GetFaceName() const
{
wxString str;
if ( M_FONTDATA )
str = M_FONTDATA->m_faceName ;
return str;
}
wxFontEncoding wxFont::GetEncoding() const
{
return M_FONTDATA->m_encoding;
}

5
src/msw/makefile.b32
View File

@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 16:55, 1999/09/29
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE B32.T!
#
@@ -130,6 +130,7 @@ COMMONOBJS = \
$(MSWDIR)\fileconf.obj \
$(MSWDIR)\filefn.obj \
$(MSWDIR)\filesys.obj \
$(MSWDIR)\fontcmn.obj \
$(MSWDIR)\framecmn.obj \
$(MSWDIR)\fs_inet.obj \
$(MSWDIR)\fs_zip.obj \
@@ -563,6 +564,8 @@ $(MSWDIR)\filefn.obj: $(COMMDIR)\filefn.$(SRCSUFF)
$(MSWDIR)\filesys.obj: $(COMMDIR)\filesys.$(SRCSUFF)
$(MSWDIR)\fontcmn.obj: $(COMMDIR)\fontcmn.$(SRCSUFF)
$(MSWDIR)\framecmn.obj: $(COMMDIR)\framecmn.$(SRCSUFF)
$(MSWDIR)\fs_inet.obj: $(COMMDIR)\fs_inet.$(SRCSUFF)

5
src/msw/makefile.bcc
View File

@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 16:55, 1999/09/29
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE BCC.T!
#
@@ -121,6 +121,7 @@ COMMONOBJS = \
$(MSWDIR)\fileconf.obj \
$(MSWDIR)\filefn.obj \
$(MSWDIR)\filesys.obj \
$(MSWDIR)\fontcmn.obj \
$(MSWDIR)\framecmn.obj \
$(MSWDIR)\fs_inet.obj \
$(MSWDIR)\fs_zip.obj \
@@ -471,6 +472,8 @@ $(MSWDIR)\filefn.obj: $(COMMDIR)\filefn.$(SRCSUFF)
$(MSWDIR)\filesys.obj: $(COMMDIR)\filesys.$(SRCSUFF)
$(MSWDIR)\fontcmn.obj: $(COMMDIR)\fontcmn.$(SRCSUFF)
$(MSWDIR)\framecmn.obj: $(COMMDIR)\framecmn.$(SRCSUFF)
$(MSWDIR)\fs_inet.obj: $(COMMDIR)\fs_inet.$(SRCSUFF)

8
src/msw/makefile.dos
View File

@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE DOS.T!
#
@@ -108,6 +108,7 @@ COMMONOBJS = \
$(COMMDIR)\fileconf.obj \
$(COMMDIR)\filefn.obj \
$(COMMDIR)\filesys.obj \
$(COMMDIR)\fontcmn.obj \
$(COMMDIR)\framecmn.obj \
$(COMMDIR)\fs_inet.obj \
$(COMMDIR)\fs_zip.obj \
@@ -774,6 +775,11 @@ $(COMMDIR)/filesys.obj: $*.$(SRCSUFF)
$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
<<
$(COMMDIR)/fontcmn.obj: $*.$(SRCSUFF)
cl @<<
$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)
<<
$(COMMDIR)/framecmn.obj: $*.$(SRCSUFF)
cl @<<
$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF)

3
src/msw/makefile.g95
View File

@@ -1,5 +1,5 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE G95.T!
#
@@ -81,6 +81,7 @@ COMMONOBJS = \
$(COMMDIR)/fileconf.$(OBJSUFF) \
$(COMMDIR)/filefn.$(OBJSUFF) \
$(COMMDIR)/filesys.$(OBJSUFF) \
$(COMMDIR)/fontcmn.$(OBJSUFF) \
$(COMMDIR)/framecmn.$(OBJSUFF) \
$(COMMDIR)/fs_inet.$(OBJSUFF) \
$(COMMDIR)/fs_zip.$(OBJSUFF) \

3
src/msw/makefile.sc
View File

@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE SC.T!
# Symantec C++ makefile for the msw objects
@@ -69,6 +69,7 @@ COMMONOBJS = \
$(COMMDIR)\fileconf.obj \
$(COMMDIR)\filefn.obj \
$(COMMDIR)\filesys.obj \
$(COMMDIR)\fontcmn.obj \
$(COMMDIR)\framecmn.obj \
$(COMMDIR)\fs_inet.obj \
$(COMMDIR)\fs_zip.obj \

3
src/msw/makefile.vc
View File

@@ -1,4 +1,4 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE VC.T!
# File: makefile.vc
@@ -146,6 +146,7 @@ COMMONOBJS = \
..\common\$D\fileconf.obj \
..\common\$D\filefn.obj \
..\common\$D\filesys.obj \
..\common\$D\fontcmn.obj \
..\common\$D\framecmn.obj \
..\common\$D\fs_inet.obj \
..\common\$D\fs_zip.obj \

6
src/msw/makefile.wat
View File

@@ -1,6 +1,6 @@
# This file was automatically generated by tmake at 17:51, 1999/09/20
# This file was automatically generated by tmake at 20:03, 1999/09/29
# DO NOT CHANGE THIS FILE, YOUR CHANGES WILL BE LOST! CHANGE WAT.T!
#!/binb/wmake.exe
@@ -95,6 +95,7 @@ COMMONOBJS = &
fileconf.obj &
filefn.obj &
filesys.obj &
fontcmn.obj &
framecmn.obj &
fs_inet.obj &
fs_zip.obj &
@@ -613,6 +614,9 @@ filefn.obj: $(COMMDIR)\filefn.cpp
filesys.obj: $(COMMDIR)\filesys.cpp
*$(CCC) $(CPPFLAGS) $(IFLAGS) $<
fontcmn.obj: $(COMMDIR)\fontcmn.cpp
*$(CCC) $(CPPFLAGS) $(IFLAGS) $<
framecmn.obj: $(COMMDIR)\framecmn.cpp
*$(CCC) $(CPPFLAGS) $(IFLAGS) $<