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

*** empty log message ***

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3861 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster
1999-10-07 04:44:22 +00:00
parent 134d79dca7
commit 21802234df
11 changed files with 1435 additions and 536 deletions
Download Patch File Download Diff File Expand all files Collapse all files

591
src/os2/font.cpp
View File

@@ -1,85 +1,176 @@
/////////////////////////////////////////////////////////////////////////////
// Name: font.cpp
// Purpose: wxFont class
// Author: AUTHOR
// Author: David Webster
// Modified by:
// Created: ??/??/98
// Created: 10/06/99
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
// Copyright: (c) David Webster
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "font.h"
#endif
// ============================================================================
// declarations
// ============================================================================
#include "wx/defs.h"
#include "wx/string.h"
#include "wx/font.h"
#include "wx/gdicmn.h"
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#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 // WX_PRECOMP
#include "wx/os2/private.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)
#endif
#endif
wxFontRefData::wxFontRefData()
{
m_style = 0;
m_pointSize = 0;
m_family = 0;
m_style = 0;
m_weight = 0;
m_underlined = 0;
m_faceName = "";
/* TODO
m_hFont = 0;
*/
}
// ----------------------------------------------------------------------------
// wxFontRefData - the internal description of the font
// ----------------------------------------------------------------------------
wxFontRefData::wxFontRefData(const wxFontRefData& data)
class WXDLLEXPORT wxFontRefData: public wxGDIRefData
{
m_style = data.m_style;
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;
/* TODO
m_hFont = 0;
*/
friend class WXDLLEXPORT wxFont;
public:
wxFontRefData()
{
Init(12, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE,
"", wxFONTENCODING_DEFAULT);
}
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_temporary = FALSE;
m_hFont = 0;
}
wxFontRefData::~wxFontRefData()
{
// TODO: delete font data
// TODO:
// if ( m_hFont )
// {
// if ( !::DeleteObject((HFONT) m_hFont) )
// {
// wxLogLastError("DeleteObject(font)");
// }
// }
}
wxFont::wxFont()
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
void wxFont::Init()
{
if ( wxTheFontList )
wxTheFontList->Append(this);
}
wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
{
Create(pointSize, family, style, weight, underlined, faceName);
if ( wxTheFontList )
wxTheFontList->Append(this);
}
bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
/* Constructor for a font. Note that the real construction is done
* in wxDC::SetFont, when information is available about scaling etc.
*/
bool wxFont::Create(int pointSize,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding)
{
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;
m_refData = new wxFontRefData(pointSize, family, style, weight,
underlined, faceName, encoding);
RealizeResource();
@@ -88,31 +179,292 @@ bool wxFont::Create(int pointSize, int family, int style, int weight, bool under
wxFont::~wxFont()
{
if (wxTheFontList)
if ( wxTheFontList )
wxTheFontList->DeleteObject(this);
}
// ----------------------------------------------------------------------------
// real implementation
// ----------------------------------------------------------------------------
bool wxFont::RealizeResource()
{
// TODO: create the font (if there is a native font object)
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;
}
int ff_family = 0;
wxString ff_face;
// OS/2 combines the family with styles to give a facename
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") ;
}
BYTE ff_italic;
switch ( M_FONTDATA->m_style )
{
case wxITALIC:
case wxSLANT:
ff_italic = 1;
break;
default:
wxFAIL_MSG(T("unknown font slant"));
// fall through
case wxNORMAL:
ff_italic = 0;
}
int ff_weight = 0;
switch ( M_FONTDATA->m_weight )
{
default:
wxFAIL_MSG(T("unknown font weight"));
// fall through
case wxNORMAL:
// ff_weight = FW_NORMAL;
break;
case wxLIGHT:
// ff_weight = FW_LIGHT;
break;
case wxBOLD:
// ff_weight = FW_BOLD;
break;
}
const wxChar* pzFace;
if ( M_FONTDATA->m_faceName.IsEmpty() )
pzFace = ff_face;
else
pzFace = M_FONTDATA->m_faceName ;
#if 0
/* 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);
}
else
{
nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc, LOGPIXELSY)/72;
}
#endif // 0
#if 0
// Have to get screen DC Caps, because a metafile will return 0.
HDC dc2 = ::GetDC(NULL);
ppInch = ::GetDeviceCaps(dc2, LOGPIXELSY);
::ReleaseDC(NULL, dc2);
#endif // 0
// New behaviour: apparently ppInch varies according to Large/Small Fonts
// setting in Windows. This messes up fonts. So, set ppInch to a constant
// 96 dpi.
static const int ppInch = 96;
#if wxFONT_SIZE_COMPATIBILITY
// Incorrect, but compatible with old wxWindows behaviour
int nHeight = (M_FONTDATA->m_pointSize*ppInch/72);
#else
// Correct for Windows compatibility
int nHeight = - (M_FONTDATA->m_pointSize*ppInch/72);
#endif
BYTE ff_underline = M_FONTDATA->m_underlined;
wxFontEncoding encoding = M_FONTDATA->m_encoding;
if ( encoding == wxFONTENCODING_DEFAULT )
{
encoding = wxFont::GetDefaultEncoding();
}
DWORD charset;
switch ( encoding )
{
case wxFONTENCODING_ISO8859_1:
case wxFONTENCODING_ISO8859_15:
case wxFONTENCODING_CP1250:
// charset = ANSI_CHARSET;
break;
case wxFONTENCODING_ISO8859_2:
case wxFONTENCODING_CP1252:
// charset = EASTEUROPE_CHARSET;
break;
case wxFONTENCODING_ISO8859_4:
case wxFONTENCODING_ISO8859_10:
// charset = BALTIC_CHARSET;
break;
case wxFONTENCODING_ISO8859_5:
case wxFONTENCODING_CP1251:
// charset = RUSSIAN_CHARSET;
break;
case wxFONTENCODING_ISO8859_6:
// charset = ARABIC_CHARSET;
break;
case wxFONTENCODING_ISO8859_7:
// charset = GREEK_CHARSET;
break;
case wxFONTENCODING_ISO8859_8:
// charset = HEBREW_CHARSET;
break;
case wxFONTENCODING_ISO8859_9:
// charset = TURKISH_CHARSET;
break;
case wxFONTENCODING_ISO8859_11:
// charset = THAI_CHARSET;
break;
case wxFONTENCODING_CP437:
// charset = OEM_CHARSET;
break;
default:
wxFAIL_MSG(T("unsupported encoding"));
// fall through
case wxFONTENCODING_SYSTEM:
// charset = ANSI_CHARSET;
break;
}
// TODO:
WXHFONT hFont;
// HFONT hFont = ::CreateFont
// (
// nHeight, // height
// 0, // width (choose best)
// 0, // escapement
// 0, // orientation
// ff_weight, // weight
// ff_italic, // italic?
// ff_underline, // underlined?
// 0, // strikeout?
// charset, // charset
// OUT_DEFAULT_PRECIS, // precision
// CLIP_DEFAULT_PRECIS, // clip precision
// PROOF_QUALITY, // quality of match
// DEFAULT_PITCH | // fixed or variable
// ff_family, // family id
// pzFace // face name
// );
M_FONTDATA->m_hFont = (WXHFONT)hFont;
if ( !hFont )
{
wxLogLastError("CreateFont");
}
return hFont != 0;
}
bool wxFont::FreeResource(bool force)
{
if ( GetResourceHandle() )
{
// TODO:
// 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 ;
}
bool wxFont::IsFree() const
{
return (M_FONTDATA && (M_FONTDATA->m_hFont == 0));
}
void wxFont::Unshare()
{
// Don't change shared data
if (!m_refData)
// Don't change shared data
if ( !m_refData )
{
m_refData = new wxFontRefData();
}
m_refData = new wxFontRefData();
}
else
{
wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
UnRef();
m_refData = ref;
}
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();
@@ -167,78 +519,59 @@ void wxFont::SetUnderlined(bool underlined)
RealizeResource();
}
wxString wxFont::GetFamilyString() const
void wxFont::SetEncoding(wxFontEncoding encoding)
{
wxString fam("");
switch (GetFamily())
{
case wxDECORATIVE:
fam = "wxDECORATIVE";
break;
case wxROMAN:
fam = "wxROMAN";
break;
case wxSCRIPT:
fam = "wxSCRIPT";
break;
case wxSWISS:
fam = "wxSWISS";
break;
case wxMODERN:
fam = "wxMODERN";
break;
case wxTELETYPE:
fam = "wxTELETYPE";
break;
default:
fam = "wxDEFAULT";
break;
}
return fam;
Unshare();
M_FONTDATA->m_encoding = encoding;
RealizeResource();
}
// ----------------------------------------------------------------------------
// accessors
// ----------------------------------------------------------------------------
int wxFont::GetPointSize() const
{
return M_FONTDATA->m_pointSize;
}
int wxFont::GetFamily() const
{
return M_FONTDATA->m_family;
}
int wxFont::GetFontId() const
{
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;
}
/* New font system */
wxString wxFont::GetFaceName() const
{
wxString str("");
if (M_FONTDATA)
str = M_FONTDATA->m_faceName ;
wxString str;
if ( M_FONTDATA )
str = M_FONTDATA->m_faceName ;
return str;
}
wxString wxFont::GetStyleString() const
wxFontEncoding wxFont::GetEncoding() const
{
wxString styl("");
switch (GetStyle())
{
case wxITALIC:
styl = "wxITALIC";
break;
case wxSLANT:
styl = "wxSLANT";
break;
default:
styl = "wxNORMAL";
break;
}
return styl;
}
wxString wxFont::GetWeightString() const
{
wxString w("");
switch (GetWeight())
{
case wxBOLD:
w = "wxBOLD";
break;
case wxLIGHT:
w = "wxLIGHT";
break;
default:
w = "wxNORMAL";
break;
}
return w;
return M_FONTDATA->m_encoding;
}