/*
* tkMacFont.c --
*
* Contains the Macintosh implementation of the platform-independant
* font package interface.
*
* Copyright (c) 1990-1994 The Regents of the University of California.
* Copyright (c) 1994-1997 Sun Microsystems, Inc.
*
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
* SCCS:@(#) tkMacFont.c 1.52 97/11/20 18:29:51
*/
#include <Windows.h>
#include <Strings.h>
#include <Fonts.h>
#include <Resources.h>
#include "tkMacInt.h"
#include "tkFont.h"
#include "tkPort.h"
/*
* The following structure represents the Macintosh's' implementation of a
* font.
*/
typedef struct MacFont {
TkFont font; /* Stuff used by generic font package. Must
* be first in structure. */
short family;
short size;
short style;
} MacFont;
static GWorldPtr gWorld = NULL;
static TkFont * AllocMacFont _ANSI_ARGS_((TkFont *tkfont,
Tk_Window tkwin, int family, int size, int style));
/*
*---------------------------------------------------------------------------
*
* TkpGetNativeFont --
*
* Map a platform-specific native font name to a TkFont.
*
* Results:
* The return value is a pointer to a TkFont that represents the
* native font. If a native font by the given name could not be
* found, the return value is NULL.
*
* Every call to this procedure returns a new TkFont structure,
* even if the name has already been seen before. The caller should
* call TkpDeleteFont() when the font is no longer needed.
*
* The caller is responsible for initializing the memory associated
* with the generic TkFont when this function returns and releasing
* the contents of the generics TkFont before calling TkpDeleteFont().
*
* Side effects:
* None.
*
*---------------------------------------------------------------------------
*/
TkFont *
TkpGetNativeFont(
Tk_Window tkwin, /* For display where font will be used. */
CONST char *name) /* Platform-specific font name. */
{
short family;
if (strcmp(name, "system") == 0) {
family = GetSysFont();
} else if (strcmp(name, "application") == 0) {
family = GetAppFont();
} else {
return NULL;
}
return AllocMacFont(NULL, tkwin, family, 0, 0);
}
/*
*---------------------------------------------------------------------------
*
* TkpGetFontFromAttributes --
*
* Given a desired set of attributes for a font, find a font with
* the closest matching attributes.
*
* Results:
* The return value is a pointer to a TkFont that represents the
* font with the desired attributes. If a font with the desired
* attributes could not be constructed, some other font will be
* substituted automatically.
*
* Every call to this procedure returns a new TkFont structure,
* even if the specified attributes have already been seen before.
* The caller should call TkpDeleteFont() to free the platform-
* specific data when the font is no longer needed.
*
* The caller is responsible for initializing the memory associated
* with the generic TkFont when this function returns and releasing
* the contents of the generic TkFont before calling TkpDeleteFont().
*
* Side effects:
* None.
*
*---------------------------------------------------------------------------
*/
TkFont *
TkpGetFontFromAttributes(
TkFont *tkFontPtr, /* If non-NULL, store the information in
* this existing TkFont structure, rather than
* allocating a new structure to hold the
* font; the existing contents of the font
* will be released. If NULL, a new TkFont
* structure is allocated. */
Tk_Window tkwin, /* For display where font will be used. */
CONST TkFontAttributes *faPtr) /* Set of attributes to match. */
{
char buf[257];
size_t len;
short family, size, style;
if (faPtr->family == NULL) {
family = 0;
} else {
CONST char *familyName;
familyName = faPtr->family;
if (strcasecmp(familyName, "Times New Roman") == 0) {
familyName = "Times";
} else if (strcasecmp(familyName, "Courier New") == 0) {
familyName = "Courier";
} else if (strcasecmp(familyName, "Arial") == 0) {
familyName = "Helvetica";
}
len = strlen(familyName);
if (len > 255) {
len = 255;
}
buf[0] = (char) len;
memcpy(buf + 1, familyName, len);
buf[len + 1] = '\0';
GetFNum((StringPtr) buf, &family);
}
size = faPtr->pointsize;
if (size <= 0) {
size = GetDefFontSize();
}
style = 0;
if (faPtr->weight != TK_FW_NORMAL) {
style |= bold;
}
if (faPtr->slant != TK_FS_ROMAN) {
style |= italic;
}
if (faPtr->underline) {
style |= underline;
}
return AllocMacFont(tkFontPtr, tkwin, family, size, style);
}
/*
*---------------------------------------------------------------------------
*
* TkpDeleteFont --
*
* Called to release a font allocated by TkpGetNativeFont() or
* TkpGetFontFromAttributes(). The caller should have already
* released the fields of the TkFont that are used exclusively by
* the generic TkFont code.
*
* Results:
* None.
*
* Side effects:
* TkFont is deallocated.
*
*---------------------------------------------------------------------------
*/
void
TkpDeleteFont(
TkFont *tkFontPtr) /* Token of font to be deleted. */
{
ckfree((char *) tkFontPtr);
}
/*
*---------------------------------------------------------------------------
*
* TkpGetFontFamilies --
*
* Return information about the font families that are available
* on the display of the given window.
*
* Results:
* interp->result is modified to hold a list of all the available
* font families.
*
* Side effects:
* None.
*
*---------------------------------------------------------------------------
*/
void
TkpGetFontFamilies(
Tcl_Interp *interp, /* Interp to hold result. */
Tk_Window tkwin) /* For display to query. */
{
MenuHandle fontMenu;
int i;
char itemText[257];
fontMenu = NewMenu(1, "\px");
AddResMenu(fontMenu, 'FONT');
for (i = 1; i < CountMItems(fontMenu); i++) {
/*
* Each item is a pascal string. Convert it to C and append.
*/
GetMenuItemText(fontMenu, i, (unsigned char *) itemText);
itemText[itemText[0] + 1] = '\0';
Tcl_AppendElement(interp, &itemText[1]);
}
DisposeMenu(fontMenu);
}
/*
*---------------------------------------------------------------------------
*
* TkMacIsCharacterMissing --
*
* Given a tkFont and a character determines whether the character has
* a glyph defined in the font or not. Note that this is potentially
* not compatible with Mac OS 8 as it looks at the font handle
* structure directly. Looks into the character array of the font
* handle to determine whether the glyph is defined or not.
*
* Results:
* Returns a 1 if the character is missing, a 0 if it is not.
*
* Side effects:
* None.
*
*---------------------------------------------------------------------------
*/
int
TkMacIsCharacterMissing(
Tk_Font tkfont, /* The font we are looking in. */
unsigned int searchChar) /* The character we are looking for. */
{
MacFont *fontPtr = (MacFont *) tkfont;
FMInput fm;
FontRec **fontRecHandle;
fm.family = fontPtr->family;
fm.size = fontPtr->size;
fm.face = fontPtr->style;
fm.needBits = 0;
fm.device = 0;
fm.numer.h = fm.numer.v = fm.denom.h = fm.denom.v = 1;
/*
* This element of the FMOutput structure was changed between the 2.0 & 3.0
* versions of the Universal Headers.
*/
#if !defined(UNIVERSAL_INTERFACES_VERSION) || (UNIVERSAL_INTERFACES_VERSION < 0x0300)
fontRecHandle = (FontRec **) FMSwapFont(&fm)->fontResult;
#else
fontRecHandle = (FontRec **) FMSwapFont(&fm)->fontHandle;
#endif
return *(short *) ((long) &(*fontRecHandle)->owTLoc
+ ((long)((*fontRecHandle)->owTLoc + searchChar
- (*fontRecHandle)->firstChar) * sizeof(short))) == -1;
}
/*
*---------------------------------------------------------------------------
*
* Tk_MeasureChars --
*
* Determine the number of characters from the string that will fit
* in the given horizontal span. The measurement is done under the
* assumption that Tk_DrawChars() will be used to actually display
* the characters.
*
* Results:
* The return value is the number of characters from source that
* fit into the span that extends from 0 to maxLength. *lengthPtr is
* filled with the x-coordinate of the right edge of the last
* character that did fit.
*
* Side effects:
* None.
*
*---------------------------------------------------------------------------
*/
int
Tk_MeasureChars(
Tk_Font tkfont, /* Font in which characters will be drawn. */
CONST char *source, /* Characters to be displayed. Need not be
* '\0' terminated. */
int numChars, /* Maximum number of characters to consider
* from source string. */
int maxLength, /* If > 0, maxLength specifies the longest
* permissible line length; don't consider any
* character that would cross this
* x-position. If <= 0, then line length is
* unbounded and the flags argument is
* ignored. */
int flags, /* Various flag bits OR-ed together:
* TK_PARTIAL_OK means include the last char
* which only partially fit on this line.
* TK_WHOLE_WORDS means stop on a word
* boundary, if possible.
* TK_AT_LEAST_ONE means return at least one
* character even if no characters fit. */
int *lengthPtr) /* Filled with x-location just after the
* terminating character. */
{
short staticWidths[128];
short *widths;
CONST char *p, *term;
int curX, termX, curIdx, sawNonSpace;
MacFont *fontPtr;
CGrafPtr saveWorld;
GDHandle saveDevice;
if (numChars == 0) {
*lengthPtr = 0;
return 0;
}
if (gWorld == NULL) {
Rect rect = {0, 0, 1, 1};
if (NewGWorld(&gWorld, 0, &rect, NULL, NULL, 0) != noErr) {
panic("NewGWorld failed in Tk_MeasureChars");
}
}
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(gWorld, NULL);
fontPtr = (MacFont *) tkfont;
TextFont(fontPtr->family);
TextSize(fontPtr->size);
TextFace(fontPtr->style);
if (maxLength <= 0) {
*lengthPtr = TextWidth(source, 0, numChars);
SetGWorld(saveWorld, saveDevice);
return numChars;
}
if (numChars > maxLength) {
/*
* Assume that all chars are at least 1 pixel wide, so there's no
* need to measure more characters than there are pixels. This
* assumption could be refined to an iterative approach that would
* use that as a starting point and try more chars if necessary (if
* there actually were some zero-width chars).
*/
numChars = maxLength;
}
if (numChars > SHRT_MAX) {
/*
* If they are trying to measure more than 32767 chars at one time,
* it would require several separate measurements.
*/
numChars = SHRT_MAX;
}
widths = staticWidths;
if (numChars >= sizeof(staticWidths) / sizeof(staticWidths[0])) {
widths = (short *) ckalloc((numChars + 1) * sizeof(short));
}
MeasureText((short) numChars, source, widths);
if (widths[numChars] <= maxLength) {
curX = widths[numChars];
curIdx = numChars;
} else {
p = term = source;
curX = termX = 0;
sawNonSpace = !isspace(UCHAR(*p));
for (curIdx = 1; ; curIdx++) {
if (isspace(UCHAR(*p))) {
if (sawNonSpace) {
term = p;
termX = widths[curIdx - 1];
sawNonSpace = 0;
}
} else {
sawNonSpace = 1;
}
if (widths[curIdx] > maxLength) {
curIdx--;
curX = widths[curIdx];
break;
}
p++;
}
if (flags & TK_PARTIAL_OK) {
curIdx++;
curX = widths[curIdx];
}
if ((curIdx == 0) && (flags & TK_AT_LEAST_ONE)) {
/*
* The space was too small to hold even one character. Since at
* least one character must always fit on a line, return the width
* of the first character.
*/
curX = TextWidth(source, 0, 1);
curIdx = 1;
} else if (flags & TK_WHOLE_WORDS) {
/*
* Break at last word that fits on the line.
*/
if ((flags & TK_AT_LEAST_ONE) && (term == source)) {
/*
* The space was too small to hold an entire word. This
* is the only word on the line, so just return the part of th
* word that fit.
*/
;
} else {
curIdx = term - source;
curX = termX;
}
}
}
if (widths != staticWidths) {
ckfree((char *) widths);
}
*lengthPtr = curX;
SetGWorld(saveWorld, saveDevice);
return curIdx;
}
/*
*---------------------------------------------------------------------------
*
* Tk_DrawChars --
*
* Draw a string of characters on the screen.
*
* Results:
* None.
*
* Side effects:
* Information gets drawn on the screen.
*
*---------------------------------------------------------------------------
*/
void
Tk_DrawChars(
Display *display, /* Display on which to draw. */
Drawable drawable, /* Window or pixmap in which to draw. */
GC gc, /* Graphics context for drawing characters. */
Tk_Font tkfont, /* Font in which characters will be drawn;
* must be the same as font used in GC. */
CONST char *source, /* Characters to be displayed. Need not be
* '\0' terminated. All Tk meta-characters
* (tabs, control characters, and newlines)
* should be stripped out of the string that
* is passed to this function. If they are
* not stripped out, they will be displayed as
* regular printing characters. */
int numChars, /* Number of characters in string. */
int x, int y) /* Coordinates at which to place origin of
* string when drawing. */
{
MacFont *fontPtr;
MacDrawable *macWin;
RGBColor macColor, origColor;
GWorldPtr destPort;
CGrafPtr saveWorld;
GDHandle saveDevice;
short txFont, txFace, txSize;
BitMapPtr stippleMap;
fontPtr = (MacFont *) tkfont;
macWin = (MacDrawable *) drawable;
destPort = TkMacGetDrawablePort(drawable);
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(drawable);
TkMacSetUpGraphicsPort(gc);
txFont = tcl_macQdPtr->thePort->txFont;
txFace = tcl_macQdPtr->thePort->txFace;
txSize = tcl_macQdPtr->thePort->txSize;
GetForeColor(&origColor);
if ((gc->fill_style == FillStippled
|| gc->fill_style == FillOpaqueStippled)
&& gc->stipple != None) {
Pixmap pixmap;
GWorldPtr bufferPort;
stippleMap = TkMacMakeStippleMap(drawable, gc->stipple);
pixmap = Tk_GetPixmap(display, drawable,
stippleMap->bounds.right, stippleMap->bounds.bottom, 0);
bufferPort = TkMacGetDrawablePort(pixmap);
SetGWorld(bufferPort, NULL);
TextFont(fontPtr->family);
TextSize(fontPtr->size);
TextFace(fontPtr->style);
if (TkSetMacColor(gc->foreground, &macColor) == true) {
RGBForeColor(&macColor);
}
ShowPen();
MoveTo((short) 0, (short) 0);
FillRect(&stippleMap->bounds, &tcl_macQdPtr->white);
MoveTo((short) x, (short) y);
DrawText(source, 0, (short) numChars);
SetGWorld(destPort, NULL);
CopyDeepMask(&((GrafPtr) bufferPort)->portBits, stippleMap,
&((GrafPtr) destPort)->portBits, &stippleMap->bounds,
&stippleMap->bounds, &((GrafPtr) destPort)->portRect,
srcOr, NULL);
/* TODO: this doesn't work quite right - it does a blend. you can't
* draw white text when you have a stipple.
*/
Tk_FreePixmap(display, pixmap);
ckfree(stippleMap->baseAddr);
ckfree((char *)stippleMap);
} else {
TextFont(fontPtr->family);
TextSize(fontPtr->size);
TextFace(fontPtr->style);
if (TkSetMacColor(gc->foreground, &macColor) == true) {
RGBForeColor(&macColor);
}
ShowPen();
MoveTo((short) (macWin->xOff + x), (short) (macWin->yOff + y));
DrawText(source, 0, (short) numChars);
}
TextFont(txFont);
TextSize(txSize);
TextFace(txFace);
RGBForeColor(&origColor);
SetGWorld(saveWorld, saveDevice);
}
/*
*---------------------------------------------------------------------------
*
* AllocMacFont --
*
* Helper for TkpGetNativeFont() and TkpGetFontFromAttributes().
* Allocates and intializes the memory for a new TkFont that
* wraps the platform-specific data.
*
* Results:
* Returns pointer to newly constructed TkFont.
*
* The caller is responsible for initializing the fields of the
* TkFont that are used exclusively by the generic TkFont code, and
* for releasing those fields before calling TkpDeleteFont().
*
* Side effects:
* Memory allocated.
*
*---------------------------------------------------------------------------
*/
static TkFont *
AllocMacFont(
TkFont *tkFontPtr, /* If non-NULL, store the information in
* this existing TkFont structure, rather than
* allocating a new structure to hold the
* font; the existing contents of the font
* will be released. If NULL, a new TkFont
* structure is allocated. */
Tk_Window tkwin, /* For display where font will be used. */
int family, /* Macintosh font family. */
int size, /* Point size for Macintosh font. */
int style) /* Macintosh style bits. */
{
char buf[257];
FontInfo fi;
MacFont *fontPtr;
TkFontAttributes *faPtr;
TkFontMetrics *fmPtr;
CGrafPtr saveWorld;
GDHandle saveDevice;
if (gWorld == NULL) {
Rect rect = {0, 0, 1, 1};
if (NewGWorld(&gWorld, 0, &rect, NULL, NULL, 0) != noErr) {
panic("NewGWorld failed in AllocMacFont");
}
}
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(gWorld, NULL);
if (tkFontPtr == NULL) {
fontPtr = (MacFont *) ckalloc(sizeof(MacFont));
} else {
fontPtr = (MacFont *) tkFontPtr;
}
fontPtr->font.fid = (Font) fontPtr;
faPtr = &fontPtr->font.fa;
GetFontName(family, (StringPtr) buf);
buf[UCHAR(buf[0]) + 1] = '\0';
faPtr->family = Tk_GetUid(buf + 1);
faPtr->pointsize = size;
faPtr->weight = (style & bold) ? TK_FW_BOLD : TK_FW_NORMAL;
faPtr->slant = (style & italic) ? TK_FS_ITALIC : TK_FS_ROMAN;
faPtr->underline = ((style & underline) != 0);
faPtr->overstrike = 0;
fmPtr = &fontPtr->font.fm;
TextFont(family);
TextSize(size);
TextFace(style);
GetFontInfo(&fi);
fmPtr->ascent = fi.ascent;
fmPtr->descent = fi.descent;
fmPtr->maxWidth = fi.widMax;
fmPtr->fixed = (CharWidth('i') == CharWidth('w'));
fontPtr->family = (short) family;
fontPtr->size = (short) size;
fontPtr->style = (short) style;
SetGWorld(saveWorld, saveDevice);
return (TkFont *) fontPtr;
}
