Initial revision

1 files changed, 678 insertions, 0 deletions

diff --git a/mac/tkMacFont.c b/mac/tkMacFont.c
new file mode 100644
index 0000000..8619880
--- /dev/null
+++ b/mac/tkMacFont.c
@@ -0,0 +1,678 @@
+/* 
+ * 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;
+}
+