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

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;
}