730 lines
17 KiB
C
730 lines
17 KiB
C
/*
|
||
* tkWinFont.c --
|
||
*
|
||
* This file contains the Xlib emulation routines relating to
|
||
* creating and manipulating fonts.
|
||
*
|
||
* Copyright (c) 1995 Sun Microsystems, Inc.
|
||
* Copyright (c) 1994 Software Research Associates, Inc.
|
||
*
|
||
* See the file "license.terms" for information on usage and redistribution
|
||
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||
*
|
||
* SCCS: @(#) tkWinFont.c 1.8 96/04/05 15:21:22
|
||
*/
|
||
|
||
#include "tkWinInt.h"
|
||
|
||
/*
|
||
* Forward declarations for functions used in this file.
|
||
*/
|
||
|
||
static int NameToFont _ANSI_ARGS_((_Xconst char *name,
|
||
LOGFONT *logfont));
|
||
static int XNameToFont _ANSI_ARGS_((_Xconst char *name,
|
||
LOGFONT *logfont));
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* NameToFont --
|
||
*
|
||
* Converts a three part font name into a logical font
|
||
* description. Font name is of the form:
|
||
* "Family point_size style_list"
|
||
* Style_list contains a list of one or more attributes:
|
||
* normal, bold, italic, underline, strikeout
|
||
*
|
||
* Results:
|
||
* Returns false if the font name was syntactically invalid,
|
||
* else true. Sets the fields of the passed in LOGFONT.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
static int
|
||
NameToFont(name, logfont)
|
||
_Xconst char *name;
|
||
LOGFONT *logfont;
|
||
{
|
||
int argc, argc2;
|
||
char **argv, **argv2;
|
||
int nameLen, i, pointSize = 0;
|
||
Tcl_Interp *dummy = Tcl_CreateInterp();
|
||
|
||
if (Tcl_SplitList(dummy, (char *) name, &argc, &argv) != TCL_OK) {
|
||
goto nomatch;
|
||
}
|
||
if (argc != 3) {
|
||
ckfree((char *) argv);
|
||
goto nomatch;
|
||
}
|
||
|
||
memset(logfont, '\0', sizeof(LOGFONT));
|
||
|
||
/*
|
||
* Determine the font family name.
|
||
*/
|
||
|
||
nameLen = strlen(argv[0]);
|
||
if (nameLen > LF_FACESIZE) {
|
||
nameLen = LF_FACESIZE;
|
||
}
|
||
strncpy(logfont->lfFaceName, argv[0], nameLen);
|
||
|
||
/*
|
||
* Check the character set.
|
||
*/
|
||
|
||
logfont->lfCharSet = ANSI_CHARSET;
|
||
if (stricmp(logfont->lfFaceName, "Symbol") == 0) {
|
||
logfont->lfCharSet = SYMBOL_CHARSET;
|
||
} else if (stricmp(logfont->lfFaceName, "WingDings") == 0) {
|
||
logfont->lfCharSet = SYMBOL_CHARSET;
|
||
}
|
||
|
||
/*
|
||
* Determine the font size.
|
||
*/
|
||
|
||
if (Tcl_GetInt(dummy, argv[1], &pointSize) != TCL_OK) {
|
||
ckfree((char *) argv);
|
||
goto nomatch;
|
||
}
|
||
logfont->lfHeight = -pointSize;
|
||
|
||
/*
|
||
* Apply any style modifiers.
|
||
*/
|
||
|
||
if (Tcl_SplitList(dummy, (char *) argv[2], &argc2, &argv2) != TCL_OK) {
|
||
ckfree((char*) argv);
|
||
goto nomatch;
|
||
}
|
||
for (i = 0; i < argc2; i++) {
|
||
if (stricmp(argv2[i], "normal") == 0) {
|
||
logfont->lfWeight = FW_NORMAL;
|
||
} else if (stricmp(argv2[i], "bold") == 0) {
|
||
logfont->lfWeight = FW_BOLD;
|
||
} else if (stricmp(argv2[i], "medium") == 0) {
|
||
logfont->lfWeight = FW_MEDIUM;
|
||
} else if (stricmp(argv2[i], "heavy") == 0) {
|
||
logfont->lfWeight = FW_HEAVY;
|
||
} else if (stricmp(argv2[i], "thin") == 0) {
|
||
logfont->lfWeight = FW_THIN;
|
||
} else if (stricmp(argv2[i], "extralight") == 0) {
|
||
logfont->lfWeight = FW_EXTRALIGHT;
|
||
} else if (stricmp(argv2[i], "light") == 0) {
|
||
logfont->lfWeight = FW_LIGHT;
|
||
} else if (stricmp(argv2[i], "semibold") == 0) {
|
||
logfont->lfWeight = FW_SEMIBOLD;
|
||
} else if (stricmp(argv2[i], "extrabold") == 0) {
|
||
logfont->lfWeight = FW_EXTRABOLD;
|
||
} else if (stricmp(argv2[i], "italic") == 0) {
|
||
logfont->lfItalic = TRUE;
|
||
} else if (stricmp(argv2[i], "oblique") == 0) {
|
||
logfont->lfOrientation = 3600 - 150; /* 15 degree forward slant */
|
||
} else if (stricmp(argv2[i], "underline") == 0) {
|
||
logfont->lfUnderline = TRUE;
|
||
} else if (stricmp(argv2[i], "strikeout") == 0) {
|
||
logfont->lfStrikeOut = TRUE;
|
||
} else {
|
||
/* ignore for now */
|
||
}
|
||
}
|
||
|
||
ckfree((char *) argv);
|
||
ckfree((char *) argv2);
|
||
return True;
|
||
|
||
nomatch:
|
||
Tcl_DeleteInterp(dummy);
|
||
return False;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* XNameToFont --
|
||
*
|
||
* This function constructs a logical font description from an
|
||
* X font name. This code only handles font names with all 13
|
||
* parts, although a part can be '*'.
|
||
*
|
||
* Results:
|
||
* Returns false if the font name was syntactically invalid,
|
||
* else true. Sets the fields of the passed in LOGFONT.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
static int
|
||
XNameToFont(name, logfont)
|
||
_Xconst char *name;
|
||
LOGFONT *logfont;
|
||
{
|
||
const char *head, *tail;
|
||
const char *field[13];
|
||
int flen[13];
|
||
int i, len, parsefields;
|
||
|
||
/*
|
||
* Valid font name patterns must have a leading '-' or '*'.
|
||
*/
|
||
|
||
head = tail = name;
|
||
if (*tail == '-') {
|
||
head++; tail++;
|
||
} else if (*tail != '*') {
|
||
return FALSE;
|
||
}
|
||
|
||
/*
|
||
* Identify field boundaries. Stores a pointer to the beginning
|
||
* of each field in field[i], and the length of the field in flen[i].
|
||
* Fields are separated by dashes. Each '*' becomes a field by itself.
|
||
*/
|
||
|
||
i = 0;
|
||
while (*tail != '\0' && i < 12) {
|
||
if (*tail == '-') {
|
||
flen[i] = tail - head;
|
||
field[i] = head;
|
||
tail++;
|
||
head = tail;
|
||
i++;
|
||
} else if (*tail == '*') {
|
||
len = tail - head;
|
||
if (len > 0) {
|
||
flen[i] = tail - head;
|
||
field[i] = head;
|
||
} else {
|
||
flen[i] = 1;
|
||
field[i] = head;
|
||
tail++;
|
||
if (*tail == '-') {
|
||
tail++;
|
||
}
|
||
}
|
||
head = tail;
|
||
i++;
|
||
} else {
|
||
tail++;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* We handle the last field as a special case, since it may contain
|
||
* an emedded hyphen.
|
||
*/
|
||
|
||
flen[i] = strlen(head);
|
||
field[i] = head;
|
||
|
||
/*
|
||
* Bail if we don't have all of the fields.
|
||
*/
|
||
|
||
if (i != 12) {
|
||
return FALSE;
|
||
}
|
||
|
||
/*
|
||
* Now fill in the logical font description from the fields we have
|
||
* identified.
|
||
*/
|
||
|
||
memset(logfont, '\0', sizeof(LOGFONT));
|
||
|
||
/*
|
||
* Field 1: Foundry. Skip.
|
||
*/
|
||
|
||
/*
|
||
* Field 2: Font Family.
|
||
*/
|
||
|
||
i = 1;
|
||
if (!(flen[i] == 0 ||
|
||
(flen[i] == 1 && (field[i][0] == '*' || field[i][0] == '?'))))
|
||
{
|
||
len = (flen[i] < LF_FACESIZE) ? flen[i] : LF_FACESIZE - 1;
|
||
strncpy(logfont->lfFaceName, field[i], len);
|
||
|
||
/*
|
||
* Need to handle Symbol and WingDings specially.
|
||
*/
|
||
|
||
if (stricmp(logfont->lfFaceName, "Symbol") == 0) {
|
||
logfont->lfCharSet = SYMBOL_CHARSET;
|
||
} else if (stricmp(logfont->lfFaceName, "WingDings") == 0) {
|
||
logfont->lfCharSet = SYMBOL_CHARSET;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Field 3: Weight. Default is medium.
|
||
*/
|
||
|
||
i = 2;
|
||
if ((flen[i] > 0) && (strnicmp(field[i], "bold", flen[i]) == 0)) {
|
||
logfont->lfWeight = FW_BOLD;
|
||
} else {
|
||
logfont->lfWeight = FW_MEDIUM;
|
||
}
|
||
|
||
/*
|
||
* Field 4: Slant. Default is Roman.
|
||
*/
|
||
|
||
i = 3;
|
||
if (!(flen[i] == 0 ||
|
||
(flen[i] == 1 && (field[i][0] == '*' || field[i][0] == '?'))))
|
||
{
|
||
if (strnicmp(field[i], "r", flen[i]) == 0) {
|
||
/* Roman. Don't do anything */
|
||
} else if (strnicmp(field[i], "i", flen[i]) == 0) {
|
||
/* Italic */
|
||
logfont->lfItalic = TRUE;
|
||
} else if (strnicmp(field[i], "o", flen[i]) == 0) {
|
||
/* Oblique */
|
||
logfont->lfOrientation = 3600 - 150; /* 15 degree slant forward */
|
||
} else if (strnicmp(field[i], "ri", flen[i]) == 0) {
|
||
/* Reverse Italic */
|
||
logfont->lfOrientation = 300; /* 30 degree slant backward */
|
||
} else if (strnicmp(field[i], "ro", flen[i]) == 0) {
|
||
/* Reverse Oblique */
|
||
logfont->lfOrientation = 150; /* 30 degree slant backward */
|
||
} else if (strnicmp(field[i], "ot", flen[i]) == 0) {
|
||
/* Other */
|
||
} else {
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Field 5 & 6: Set Width & Blank. Skip.
|
||
*/
|
||
|
||
/*
|
||
* Field 7: Pixels. Use this as the points if no points set.
|
||
*/
|
||
|
||
i = 6;
|
||
if (!(flen[i] == 0 ||
|
||
(flen[i] == 1 && (field[i][0] == '*' || field[i][0] == '?'))))
|
||
{
|
||
logfont->lfHeight = -atoi(field[i]);
|
||
}
|
||
|
||
/*
|
||
* Field 8: Points in tenths of a point.
|
||
*/
|
||
|
||
i = 7;
|
||
if (!(flen[i] == 0 ||
|
||
(flen[i] == 1 && (field[i][0] == '*' || field[i][0] == '?'))))
|
||
{
|
||
logfont->lfHeight = -(atoi(field[i]) / 10);
|
||
}
|
||
|
||
/*
|
||
* Field 9: Horizontal Resolution in DPI. Skip.
|
||
* Field 10: Vertical Resolution in DPI. Skip.
|
||
*/
|
||
|
||
/*
|
||
* Field 11: Spacing.
|
||
*/
|
||
|
||
i = 10;
|
||
if (!(flen[i] == 0 ||
|
||
(flen[i] == 1 && (field[i][0] == '*' || field[i][0] == '?'))))
|
||
{
|
||
if (flen[i] != 1) {
|
||
return FALSE;
|
||
}
|
||
if (field[i][0] == 'p' || field[i][0] == 'P') {
|
||
logfont->lfPitchAndFamily |= VARIABLE_PITCH;
|
||
} else if (field[i][0] == 'm' || field[i][0] == 'm' ||
|
||
field[i][0] == 'c' || field[i][0] == 'c')
|
||
{
|
||
logfont->lfPitchAndFamily |= FIXED_PITCH;
|
||
} else {
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Field 12: Average Width.
|
||
*/
|
||
|
||
i = 11;
|
||
if (!(flen[i] == 0 ||
|
||
(flen[i] == 1 && (field[i][0] == '*' || field[i][0] == '?'))))
|
||
{
|
||
logfont->lfWidth = (atoi(field[i]) / 10);
|
||
}
|
||
|
||
/*
|
||
* Field 13: Character Set. Skip.
|
||
*/
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* XLoadFont --
|
||
*
|
||
* Get the font handle for the specified font.
|
||
*
|
||
* Results:
|
||
* Returns the font handle.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
Font
|
||
XLoadFont(display, name)
|
||
Display* display;
|
||
_Xconst char* name;
|
||
{
|
||
HFONT font;
|
||
LOGFONT logfont;
|
||
|
||
if (((name[0] == '-') || (name[0] == '*'))
|
||
&& XNameToFont(name, &logfont)) {
|
||
font = CreateFontIndirect(&logfont);
|
||
} else if (NameToFont(name, &logfont)) {
|
||
font = CreateFontIndirect(&logfont);
|
||
} else {
|
||
int object = SYSTEM_FONT;
|
||
|
||
if (stricmp(name, "system") == 0) {
|
||
object = SYSTEM_FONT;
|
||
} else if (stricmp(name, "systemfixed") == 0) {
|
||
object = SYSTEM_FIXED_FONT;
|
||
} else if (stricmp(name, "ansi") == 0) {
|
||
object = ANSI_VAR_FONT;
|
||
} else if (stricmp(name, "ansifixed") == 0) {
|
||
object = ANSI_FIXED_FONT;
|
||
} else if (stricmp(name, "device") == 0) {
|
||
object = DEVICE_DEFAULT_FONT;
|
||
} else if (stricmp(name, "oemfixed") == 0) {
|
||
object = OEM_FIXED_FONT;
|
||
}
|
||
font = GetStockObject(object);
|
||
}
|
||
if (font == NULL) {
|
||
font = GetStockObject(SYSTEM_FONT);
|
||
}
|
||
return (Font) font;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* XQueryFont --
|
||
*
|
||
* Retrieve information about the specified font.
|
||
*
|
||
* Results:
|
||
* Returns a newly allocated XFontStruct.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
XFontStruct *
|
||
XQueryFont(display, font_ID)
|
||
Display* display;
|
||
XID font_ID;
|
||
{
|
||
XFontStruct *fontPtr = (XFontStruct *) ckalloc(sizeof(XFontStruct));
|
||
HFONT oldFont;
|
||
HDC dc;
|
||
TEXTMETRIC tm;
|
||
XCharStruct bounds;
|
||
|
||
if (!fontPtr) {
|
||
return NULL;
|
||
}
|
||
|
||
fontPtr->fid = font_ID;
|
||
|
||
dc = GetDC(NULL);
|
||
oldFont = SelectObject(dc, (HFONT) fontPtr->fid);
|
||
|
||
/*
|
||
* Determine the font metrics and store the values into the appropriate
|
||
* X data structures.
|
||
*/
|
||
|
||
if (GetTextMetrics(dc, &tm)) {
|
||
fontPtr->direction = FontLeftToRight;
|
||
fontPtr->min_byte1 = 0;
|
||
fontPtr->max_byte1 = 0;
|
||
fontPtr->min_char_or_byte2 = tm.tmFirstChar;
|
||
fontPtr->max_char_or_byte2 = tm.tmLastChar;
|
||
fontPtr->all_chars_exist = True;
|
||
fontPtr->default_char = tm.tmDefaultChar;
|
||
fontPtr->n_properties = 0;
|
||
fontPtr->properties = NULL;
|
||
bounds.lbearing = 0;
|
||
bounds.rbearing = tm.tmMaxCharWidth;
|
||
bounds.width = tm.tmMaxCharWidth;
|
||
bounds.ascent = tm.tmAscent;
|
||
bounds.descent = tm.tmDescent;
|
||
bounds.attributes = 0;
|
||
fontPtr->min_bounds = bounds;
|
||
fontPtr->max_bounds = bounds;
|
||
fontPtr->ascent = tm.tmAscent;
|
||
fontPtr->descent = tm.tmDescent;
|
||
|
||
/*
|
||
* If the font is not fixed pitch, then we need to construct
|
||
* the per_char array.
|
||
*/
|
||
|
||
if (tm.tmAveCharWidth != tm.tmMaxCharWidth) {
|
||
int i;
|
||
int nchars = tm.tmLastChar - tm.tmFirstChar + 1;
|
||
int minWidth = 30000;
|
||
|
||
fontPtr->per_char =
|
||
(XCharStruct *)ckalloc(sizeof(XCharStruct) * nchars);
|
||
|
||
if (tm.tmPitchAndFamily & TMPF_TRUETYPE) {
|
||
ABC *chars = (ABC*)ckalloc(sizeof(ABC) * nchars);
|
||
|
||
GetCharABCWidths(dc, tm.tmFirstChar, tm.tmLastChar, chars);
|
||
for (i = 0; i < nchars; i++) {
|
||
fontPtr->per_char[i].ascent = tm.tmAscent;
|
||
fontPtr->per_char[i].descent = tm.tmDescent;
|
||
fontPtr->per_char[i].attributes = 0;
|
||
fontPtr->per_char[i].lbearing = chars[i].abcA;
|
||
fontPtr->per_char[i].rbearing = chars[i].abcA
|
||
+ chars[i].abcB;
|
||
fontPtr->per_char[i].width = chars[i].abcA + chars[i].abcB
|
||
+ chars[i].abcC;
|
||
}
|
||
ckfree((char *)chars);
|
||
} else {
|
||
int *chars = (int *)ckalloc(sizeof(int) * nchars);
|
||
|
||
GetCharWidth(dc, tm.tmFirstChar, tm.tmLastChar, chars);
|
||
|
||
for (i = 0; i < nchars ; i++ ) {
|
||
fontPtr->per_char[i] = bounds;
|
||
fontPtr->per_char[i].width = chars[i];
|
||
if (minWidth > chars[i]) {
|
||
minWidth = chars[i];
|
||
}
|
||
}
|
||
ckfree((char *)chars);
|
||
}
|
||
fontPtr->min_bounds.width = minWidth;
|
||
} else {
|
||
fontPtr->per_char = NULL;
|
||
}
|
||
} else {
|
||
ckfree((char *)fontPtr);
|
||
fontPtr = NULL;
|
||
}
|
||
|
||
SelectObject(dc, oldFont);
|
||
ReleaseDC(NULL, dc);
|
||
|
||
return fontPtr;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* XLoadQueryFont --
|
||
*
|
||
* Finds the closest available Windows font for the specified
|
||
* font name.
|
||
*
|
||
* Results:
|
||
* Allocates and returns an XFontStruct containing a description
|
||
* of the matching font.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
XFontStruct *
|
||
XLoadQueryFont(display, name)
|
||
Display* display;
|
||
_Xconst char* name;
|
||
{
|
||
Font font;
|
||
font = XLoadFont(display, name);
|
||
return XQueryFont(display, font);
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* XFreeFont --
|
||
*
|
||
* Releases resources associated with the specified font.
|
||
*
|
||
* Results:
|
||
* None.
|
||
*
|
||
* Side effects:
|
||
* Frees the memory referenced by font_struct.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
XFreeFont(display, font_struct)
|
||
Display* display;
|
||
XFontStruct* font_struct;
|
||
{
|
||
DeleteObject((HFONT)font_struct->fid);
|
||
if (font_struct->per_char != NULL) {
|
||
ckfree((char *) font_struct->per_char);
|
||
}
|
||
ckfree((char *) font_struct);
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* XTextExtents --
|
||
*
|
||
* Compute the width of an 8-bit character string.
|
||
*
|
||
* Results:
|
||
* Returns the computed width of the specified string.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
int
|
||
XTextWidth(font_struct, string, count)
|
||
XFontStruct* font_struct;
|
||
_Xconst char* string;
|
||
int count;
|
||
{
|
||
TEXTMETRIC tm;
|
||
int width;
|
||
SIZE size;
|
||
HFONT oldFont;
|
||
HDC dc;
|
||
|
||
dc = GetDC(NULL);
|
||
oldFont = SelectObject(dc, (HFONT)font_struct->fid);
|
||
|
||
GetTextExtentPoint(dc, string, count, &size);
|
||
GetTextMetrics(dc, &tm);
|
||
size.cx -= tm.tmOverhang;
|
||
|
||
SelectObject(dc, oldFont);
|
||
ReleaseDC(NULL, dc);
|
||
|
||
return size.cx;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* XTextExtents --
|
||
*
|
||
* Compute the bounding box for a string.
|
||
*
|
||
* Results:
|
||
* Sets the direction_return, ascent_return, descent_return, and
|
||
* overall_return values as defined by Xlib.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
XTextExtents(font_struct, string, nchars, direction_return,
|
||
font_ascent_return, font_descent_return, overall_return)
|
||
XFontStruct* font_struct;
|
||
_Xconst char* string;
|
||
int nchars;
|
||
int* direction_return;
|
||
int* font_ascent_return;
|
||
int* font_descent_return;
|
||
XCharStruct* overall_return;
|
||
{
|
||
HDC dc;
|
||
HFONT oldFont;
|
||
TEXTMETRIC tm;
|
||
SIZE size;
|
||
|
||
*direction_return = font_struct->direction;
|
||
*font_ascent_return = font_struct->ascent;
|
||
*font_descent_return = font_struct->descent;
|
||
|
||
dc = GetDC(NULL);
|
||
oldFont = SelectObject(dc, (HFONT)font_struct->fid);
|
||
|
||
GetTextMetrics(dc, &tm);
|
||
overall_return->ascent = tm.tmAscent;
|
||
overall_return->descent = tm.tmDescent;
|
||
GetTextExtentPoint(dc, string, nchars, &size);
|
||
overall_return->width = size.cx;
|
||
overall_return->lbearing = 0;
|
||
overall_return->rbearing = overall_return->width - tm.tmOverhang;
|
||
|
||
SelectObject(dc, oldFont);
|
||
ReleaseDC(NULL, dc);
|
||
}
|
||
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* XGetFontProperty --
|
||
*
|
||
* Called to get font properties. Since font properties are not
|
||
* supported under Windows, this function is a no-op.
|
||
*
|
||
* Results:
|
||
* Always returns false
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
Bool
|
||
XGetFontProperty(font_struct, atom, value_return)
|
||
XFontStruct* font_struct;
|
||
Atom atom;
|
||
unsigned long* value_return;
|
||
{
|
||
return False;
|
||
}
|
||
|