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

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) $<