// 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"
#include "wx/utils.h"
#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
+// ----------------------------------------------------------------------------
+
+static GdkFont *wxLoadQueryFont( int pointSize,
+ int family,
+ int style,
+ int weight,
+ bool underlined,
+ const wxString &facename,
+ wxFontEncoding encoding );
-class wxFontRefData: public wxObjectRefData
+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;
- int m_fontId;
wxString m_faceName;
+ wxFontEncoding m_encoding;
bool m_byXFontName;
GdkFont *m_font;
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_fontId = 0;
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_fontId = data.m_fontId;
- 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()
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( char *xFontName )
+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();
- M_FONTDATA->m_byXFontName = TRUE;
- M_FONTDATA->m_font = gdk_font_load( xFontName );
-}
+// M_FONTDATA->m_byXFontName = TRUE;
+ M_FONTDATA->m_font = font;
-wxFont::wxFont( int pointSize, int family, int style, int weight, bool underlined = FALSE,
- const wxString& face = wxEmptyString )
-{
- m_refData = new wxFontRefData();
+ wxString tmp;
- if (family == wxDEFAULT) family = wxSWISS;
- M_FONTDATA->m_family = family;
-
- if (!face.IsEmpty())
- {
- M_FONTDATA->m_faceName = face;
- M_FONTDATA->m_fontId = wxTheFontNameDirectory->FindOrCreateFontId( face, family );
- M_FONTDATA->m_family = wxTheFontNameDirectory->GetFamily( family );
- }
- else
- {
- M_FONTDATA->m_fontId = family;
- M_FONTDATA->m_family = wxTheFontNameDirectory->GetFamily( family );
- }
+ wxString fontname( xFontName );
+ wxStringTokenizer tn( fontname, _T("-") );
- if (style == wxDEFAULT) style = wxNORMAL;
- M_FONTDATA->m_style = style;
- if (weight == wxDEFAULT) weight = wxNORMAL;
- M_FONTDATA->m_weight = weight;
- if (pointSize == wxDEFAULT) pointSize = 12;
- M_FONTDATA->m_pointSize = pointSize;
- M_FONTDATA->m_underlined = underlined;
+ tn.GetNextToken(); // foundry
- if (wxTheFontList) wxTheFontList->Append( this );
-
-}
+ M_FONTDATA->m_faceName = tn.GetNextToken(); // courier
-wxFont::wxFont( const wxFont& font )
-{
- Ref( font );
+ tmp = tn.GetNextToken().MakeUpper();
+ if (tmp == _T("BOLD")) M_FONTDATA->m_weight = wxBOLD;
- if (wxTheFontList) wxTheFontList->Append( this );
-}
+ tmp = tn.GetNextToken().MakeUpper();
+ if (tmp == _T("I")) M_FONTDATA->m_style = wxITALIC;
+ if (tmp == _T("O")) M_FONTDATA->m_style = wxITALIC;
-wxFont::~wxFont()
-{
- if (wxTheFontList) wxTheFontList->DeleteObject( this );
-}
+ tn.GetNextToken(); // set width
+ tn.GetNextToken(); // ?
+ tn.GetNextToken(); // pixel size
-wxFont& wxFont::operator = ( const wxFont& font )
-{
- if (*this == font) return (*this);
- Ref( font );
- return *this;
+ tmp = tn.GetNextToken(); // pointsize
+ int num = wxStrtol (tmp.c_str(), (wxChar **) NULL, 10);
+ M_FONTDATA->m_pointSize = num / 10;
+
+ tn.GetNextToken(); // x-res
+ tn.GetNextToken(); // y-res
+
+ tmp = tn.GetNextToken().MakeUpper();
+ if (tmp == _T("M")) M_FONTDATA->m_family = wxMODERN;
+ else if (M_FONTDATA->m_faceName == _T("TIMES")) M_FONTDATA->m_family = wxROMAN;
+ else if (M_FONTDATA->m_faceName == _T("HELVETICA")) M_FONTDATA->m_family = wxSWISS;
+ else if (M_FONTDATA->m_faceName == _T("LUCIDATYPEWRITER")) M_FONTDATA->m_family = wxTELETYPE;
+ else if (M_FONTDATA->m_faceName == _T("LUCIDA")) M_FONTDATA->m_family = wxDECORATIVE;
+ else if (M_FONTDATA->m_faceName == _T("UTOPIA")) M_FONTDATA->m_family = wxSCRIPT;
}
-bool wxFont::operator == ( const wxFont& font )
+bool wxFont::Create( int pointSize,
+ int family,
+ int style,
+ int weight,
+ bool underlined,
+ const wxString& face,
+ wxFontEncoding encoding )
{
- return m_refData == font.m_refData;
+ m_refData = new wxFontRefData(pointSize, family, style, weight,
+ underlined, face, encoding);
+
+ Init();
+
+ return TRUE;
}
-bool wxFont::operator != ( const wxFont& font )
+void wxFont::Unshare()
{
- return m_refData != font.m_refData;
+ if (!m_refData)
+ {
+ m_refData = new wxFontRefData();
+ }
+ else
+ {
+ wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
+ UnRef();
+ m_refData = ref;
+ }
}
-bool wxFont::Ok() const
+wxFont::~wxFont()
{
- return (m_refData != NULL);
+ if (wxTheFontList)
+ wxTheFontList->DeleteObject( this );
}
+// ----------------------------------------------------------------------------
+// accessors
+// ----------------------------------------------------------------------------
+
int wxFont::GetPointSize() const
{
- wxCHECK_MSG( Ok(), 0, "invalid font" );
+ wxCHECK_MSG( Ok(), 0, _T("invalid font") );
return M_FONTDATA->m_pointSize;
}
wxString wxFont::GetFaceName() const
{
- wxCHECK_MSG( Ok(), "", "invalid font" );
+ wxCHECK_MSG( Ok(), _T(""), _T("invalid font") );
- wxString s = wxTheFontNameDirectory->GetFontName( M_FONTDATA->m_fontId );
- return s;
+ return M_FONTDATA->m_faceName;
}
int wxFont::GetFamily() const
{
- wxCHECK_MSG( Ok(), 0, "invalid font" );
+ wxCHECK_MSG( Ok(), 0, _T("invalid font") );
return M_FONTDATA->m_family;
}
-wxString wxFont::GetFamilyString() const
-{
- wxCHECK_MSG( Ok(), "wxDEFAULT", "invalid font" );
-
- switch (M_FONTDATA->m_family)
- {
- case wxDECORATIVE: return wxString("wxDECORATIVE");
- case wxROMAN: return wxString("wxROMAN");
- case wxSCRIPT: return wxString("wxSCRIPT");
- case wxSWISS: return wxString("wxSWISS");
- case wxMODERN: return wxString("wxMODERN");
- case wxTELETYPE: return wxString("wxTELETYPE");
- default: return "wxDEFAULT";
- }
-
- return "wxDEFAULT";
-}
-
-int wxFont::GetFontId() const
-{
- wxCHECK_MSG( Ok(), 0, "invalid font" );
-
- return M_FONTDATA->m_fontId; // stub
-}
-
int wxFont::GetStyle() const
{
- wxCHECK_MSG( Ok(), 0, "invalid font" );
+ wxCHECK_MSG( Ok(), 0, _T("invalid font") );
return M_FONTDATA->m_style;
}
-wxString wxFont::GetStyleString() const
-{
- wxCHECK_MSG( Ok(), "wxDEFAULT", "invalid font" );
-
- switch (M_FONTDATA->m_style)
- {
- case wxNORMAL: return wxString("wxNORMAL");
- case wxSLANT: return wxString("wxSLANT");
- case wxITALIC: return wxString("wxITALIC");
- default: return wxString("wxDEFAULT");
- }
-
- return wxString("wxDEFAULT");
-}
-
int wxFont::GetWeight() const
{
- wxCHECK_MSG( Ok(), 0, "invalid font" );
+ wxCHECK_MSG( Ok(), 0, _T("invalid font") );
return M_FONTDATA->m_weight;
}
-wxString wxFont::GetWeightString() const
-{
- wxCHECK_MSG( Ok(), "wxDEFAULT", "invalid font" );
-
- switch (M_FONTDATA->m_weight)
- {
- case wxNORMAL: return wxString("wxNORMAL");
- case wxBOLD: return wxString("wxBOLD");
- case wxLIGHT: return wxString("wxLIGHT");
- default: return wxString("wxDEFAULT");
- }
-
- return wxString("wxDEFAULT");
-}
-
bool wxFont::GetUnderlined() const
{
- wxCHECK_MSG( Ok(), FALSE, "invalid font" );
+ wxCHECK_MSG( Ok(), FALSE, _T("invalid font") );
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();
M_FONTDATA->m_underlined = underlined;
}
-//-----------------------------------------------------------------------------
-// get internal representation of font
-//-----------------------------------------------------------------------------
+void wxFont::SetEncoding(wxFontEncoding encoding)
+{
+ Unshare();
-// local help function
-static GdkFont *wxLoadQueryNearestFont(int point_size, int fontid,
- int style, int weight,
- bool underlined);
+ M_FONTDATA->m_encoding = encoding;
+}
-GdkFont *wxFont::GetInternalFont(float scale) const
+// ----------------------------------------------------------------------------
+// get internal representation of font
+// ----------------------------------------------------------------------------
+
+GdkFont *wxFont::GetInternalFont( float scale ) const
{
if (!Ok())
{
- wxFAIL_MSG( "invalid font" );
+ wxFAIL_MSG( _T("invalid font") );
+
return (GdkFont*) NULL;
}
- if (M_FONTDATA->m_byXFontName) return M_FONTDATA->m_font;
+ /* short cut if the special X font constructor has been used */
+ if (M_FONTDATA->m_byXFontName)
+ return M_FONTDATA->m_font;
- long int_scale = long(scale * 100.0 + 0.5); // key for fontlist
+ long int_scale = long(scale * 100.0 + 0.5); /* key for fontlist */
int point_scale = (M_FONTDATA->m_pointSize * 10 * int_scale) / 100;
GdkFont *font = (GdkFont *) NULL;
}
else
{
+#if 0
if ((int_scale == 100) &&
(M_FONTDATA->m_family == wxSWISS) &&
(M_FONTDATA->m_style == wxNORMAL) &&
font = gdk_font_load( "-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*" );
}
else
+#endif // 0
{
- font = wxLoadQueryNearestFont( point_scale, M_FONTDATA->m_fontId, M_FONTDATA->m_style,
- M_FONTDATA->m_weight, M_FONTDATA->m_underlined );
+ 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 );
}
+
if (!font)
- wxLogError("could not load any font");
-
+ {
+ wxLogError(_T("could not load any font"));
+ }
+
return font;
}
// local utilities to find a X font
//-----------------------------------------------------------------------------
-static GdkFont *wxLoadQueryFont(int point_size, int fontid, int style,
- int weight, bool WXUNUSED(underlined))
-{
- char buffer[512];
- char *name = wxTheFontNameDirectory->GetScreenName( fontid, weight, style );
-
- if (!name)
- name = "-*-*-*-*-*-*-*-%d-*-*-*-*-*-*";
- sprintf(buffer, name, point_size);
-
- return gdk_font_load( buffer );
-}
-
-static GdkFont *wxLoadQueryNearestFont(int point_size, int fontid,
- int style, int weight,
- bool underlined)
-{
- GdkFont *font;
-
- font = wxLoadQueryFont( point_size, fontid, style, weight, underlined );
-
- 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 i;
-
- // Search for smaller size (approx.)
- for (i=point_size-10; !font && i >= 10 && i >= min_size; i -= 10)
- font = wxLoadQueryFont(i, fontid, style, weight, underlined);
- // Search for larger size (approx.)
- for (i=point_size+10; !font && i <= max_size; i += 10)
- font = wxLoadQueryFont(i, fontid, style, weight, underlined);
- // Try default family
- if (!font && fontid != wxDEFAULT)
- font = wxLoadQueryFont(point_size, wxDEFAULT, style,
- weight, underlined);
- // Bogus font
- if (!font)
- font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
- underlined);
- }
- return font;
-}
+// wow, what's this stuff? Is it used/useful? (VZ)
+#if 0
//-----------------------------------------------------------------------------
// face names and index functions
"ScreenItalic", "i",
"ScreenSlant", "o",
- "ScreenDefaultBase", "misc-fixed",
+ "ScreenDefaultBase", "*-times",
+
"ScreenRomanBase", "*-times",
"ScreenDecorativeBase", "*-helvetica",
"ScreenModernBase", "*-courier",
static int WCoordinate(int w)
{
- switch (w)
+ switch (w)
{
case wxBOLD: return wxWEIGHT_BOLD;
case wxLIGHT: return wxWEIGHT_LIGHT;
static int SCoordinate(int s)
{
- switch (s)
+ switch (s)
{
case wxITALIC: return wxSTYLE_ITALIC;
case wxSLANT: return wxSTYLE_SLANT;
// wxSuffixMap
//-----------------------------------------------------------------------------
-class wxSuffixMap
+class wxSuffixMap
{
public:
~wxSuffixMap();
*v = (char *) NULL;
internal = (char *) NULL;
- for (i = 0; i < k; i++)
+ for (i = 0; i < k; i++)
{
strcpy(resource, prefix);
- for (j = 0; j < count; j++)
- {
- /* upon failure to find a matching fontname
- in the default fonts above, we substitute more
- and more values by _ so that at last ScreenMyFontBoldNormal
- would turn into Screen___ and this will then get
- converted to -${ScreenDefaultBase}${ScreenStdSuffix}
- */
-
+ for (j = 0; j < count; j++)
+ {
+ // upon failure to find a matching fontname
+ // in the default fonts above, we substitute more
+ // and more values by _ so that at last ScreenMyFontBoldNormal
+ // would turn into Screen___ and this will then get
+ // converted to -${ScreenDefaultBase}${ScreenStdSuffix}
+
if (!(i & (1 << j)))
strcat(resource, names[j]);
else
strcat(resource, "_");
}
-
- /* we previously search the Xt-resources here */
- if (!internal)
- {
+ // we previously search the Xt-resources here
+
+ if (!internal)
+ {
defaults = font_defaults;
- while (*defaults)
- {
- if (!strcmp(*defaults, resource))
- {
+ while (*defaults)
+ {
+ if (!strcmp(*defaults, resource))
+ {
internal = defaults[1];
break;
}
}
}
}
-
+
if (internal)
{
- if (strcmp(internal,"-${ScreenDefaultBase}${ScreenStdSuffix}") == 0)
- {
- /* we did not find any font name in the standard list.
- this can (hopefully does) mean that someone supplied
- the facename in the wxFont constructor so we insert
- it here */
-
- strcpy( resource,"-*-" ); /* any producer */
- strcat( resource, names[0] ); /* facename */
- strcat( resource, "${ScreenStdSuffix}" ); /* add size params later on */
- *v = copystring(resource);
- }
- else
- {
+ if ((strcmp(internal,"-${ScreenDefaultBase}${ScreenStdSuffix}") == 0) &&
+ (strcmp(names[0], "Default") != 0))
+ {
+ // we did not find any font name in the standard list.
+ // this can (hopefully does) mean that someone supplied
+ // the facename in the wxFont constructor so we insert
+ // it here
+
+ strcpy( resource,"-*-" ); // any producer
+ strcat( resource, names[0] ); // facename
+ strcat( resource, "${ScreenStdSuffix}" ); // add size params later on
+ *v = copystring(resource);
+ }
+ else
+ {
*v = copystring(internal);
- }
+ }
}
}
for (k = 0; k < wxNUM_WEIGHTS; ++k)
for (j = 0; j < wxNUM_STYLES; ++j)
- if (map[k][j])
- {
+ if (map[k][j])
+ {
delete[] map[k][j];
map[k][j] = (char *) NULL;
}
int i, j, k;
const char *names[3];
- for (k = 0; k < wxNUM_WEIGHTS; k++)
+ for (k = 0; k < wxNUM_WEIGHTS; k++)
{
- switch (k)
- {
+ switch (k)
+ {
case wxWEIGHT_NORMAL: weight = "Medium"; break;
case wxWEIGHT_LIGHT: weight = "Light"; break;
case wxWEIGHT_BOLD:
default: weight = "Bold";
}
- for (j = 0; j < wxNUM_STYLES; j++)
- {
- switch (j)
- {
+ for (j = 0; j < wxNUM_STYLES; j++)
+ {
+ switch (j)
+ {
case wxSTYLE_NORMAL: style = "Straight"; break;
case wxSTYLE_ITALIC: style = "Italic"; break;
case wxSTYLE_SLANT:
names[2] = style;
SearchResource(devresname, names, 3, &v);
-
- /* Expand macros in the found string: */
+
+ // Expand macros in the found string:
found:
int len, closer = 0, startpos = 0;
len = (v ? strlen(v) : 0);
- for (i = 0; i < len; i++)
- {
- if (v[i] == '$' && ((v[i+1] == '[') || (v[i+1] == '{')))
- {
+ for (i = 0; i < len; i++)
+ {
+ if (v[i] == '$' && ((v[i+1] == '[') || (v[i+1] == '{')))
+ {
startpos = i;
closer = (v[i+1] == '[') ? ']' : '}';
++i;
- }
- else if (v[i] == closer)
- {
+ }
+ else if (v[i] == closer)
+ {
int newstrlen;
const char *r = (char *) NULL; bool delete_r = FALSE;
char *name;
name = v + startpos + 2;
v[i] = 0;
- if (closer == '}')
- {
+ if (closer == '}')
+ {
int i, count, len;
char **names;
names = new char*[count];
names[0] = name;
for (i = 0, count = 1; i < len; i++)
- if (name[i] == ',')
- {
+ if (name[i] == ',')
+ {
names[count++] = name + i + 1;
name[i] = 0;
}
delete_r = (r != 0);
delete[] names;
- if (!r)
- {
+ if (!r)
+ {
for (i = 0; i < len; i++)
if (!name[i])
name[i] = ',';
goto found;
}
}
- /* We have a final value: */
+ // We have a final value:
map[k][j] = v;
}
}
// wxFontNameItem
//-----------------------------------------------------------------------------
-class wxFontNameItem : public wxObject
+class wxFontNameItem : public wxObject
{
DECLARE_DYNAMIC_CLASS(wxFontNameItem)
public:
// Cleanup wxFontNameItems allocated
table->BeginFind();
wxNode *node = table->Next();
- while (node)
+ while (node)
{
wxFontNameItem *item = (wxFontNameItem*)node->Data();
delete item;
sprintf(resource, "Family%s", resname);
SearchResource((const char *)resource, (const char **) NULL, 0, (char **)&fam);
-
- if (fam)
+
+ if (fam)
{
if (!strcmp(fam, "Default")) family = wxDEFAULT;
else if (!strcmp(fam, "Roman")) family = wxROMAN;
int wxFontNameDirectory::FindOrCreateFontId(const char *name, int family)
{
int id;
-
+
// font exists -> return id
if ( (id = GetFontId(name)) ) return id;
-
+
// create new font
Initialize(id=GetNewFontId(), family, name);
return id;
wxFontNameItem *item = (wxFontNameItem*)table->Get(fontid); // find font
if (item)
return item->GetScreenName(weight, style);
-
+
// font does not exist
return (char *) NULL;
}
wxFontNameItem *item = (wxFontNameItem*)table->Get(fontid); // find font
if (item)
return item->GetPostScriptName(weight, style);
-
+
// font does not exist
return (char *) NULL;
}
wxFontNameItem *item = (wxFontNameItem *)table->Get(fontid); // find font
if (item)
return item->GetName();
-
+
// font does not exist
return (char *) NULL;
}
table->BeginFind();
- while ( (node = table->Next()) )
+ while ( (node = table->Next()) )
{
wxFontNameItem *item = (wxFontNameItem*)node->Data();
if (!strcmp(name, item->name))
return item->id;
}
-
+
// font does not exist
return 0;
}
if (item)
return item->family;
-
+
// font does not exist
return wxDEFAULT;
}
+
+#endif // 0
projects / wxWidgets.git / blobdiff