Tk Source Code

		    0.0, &x, NULL);
		if (x > bb[0] - 2 * SdlTkX.dec_frame_width) {
		    break;
		}
		p += sizeof (unsigned int);
	    }


	    Tcl_FreeEncoding(encoding);

	    Tcl_DStringFree(&ds);
	}
    }

    /* Close box */
    {
#ifdef ANDROID

    return 0;
}

static int
ProcessTextInput(XEvent *event, int no_rel, int sdl_mod,
		 const char *text, int len)
{
    int i, n, n2, ulen = Tcl_NumUtfChars(text, len);
    char buf[TCL_UTF_MAX];















    if (ulen <= 0) {
	SdlTkX.keyuc = 0;
	return 0;
    }
    if (sdl_mod & KMOD_RALT) {
	event->xkey.state &= ~Mod4Mask;
    }
    for (i = 0; i < ulen; i++) {
	Tcl_UniChar ch;

	n = Tcl_UtfToUniChar(text, &ch);
	n2 = 0;

	/* Deal with surrogate pairs */
#if TCL_UTF_MAX > 4
	if ((ch >= 0xd800) && (ch <= 0xdbff)) {
	    Tcl_UniChar ch2;

	    if (i + 1 < ulen) {
		n2 = Tcl_UtfToUniChar(text + n, &ch2);
		if ((ch2 >= 0xdc00) && (ch2 <= 0xdfff)) {
		    ch = ((ch & 0x3ff) << 10) | (ch2 & 0x3ff);
		    ch += 0x10000;
		    ++i;
		} else {
		    ch = 0xfffd;
		    n2 = 0;
		}
	    } else {
		SdlTkX.keyuc = ch;
		return -1;
	    }
	} else if ((ch >= 0xdc00) && (ch <= 0xdfff)) {
	    if (SdlTkX.keyuc) {
		ch = ((SdlTkX.keyuc & 0x3ff) << 10) | (ch & 0x3ff);
		ch += 0x10000;
	    } else {
		ch = 0xfffd;
	    }
	    SdlTkX.keyuc = 0;
	} else if ((ch == 0xfffe) || (ch == 0xffff)) {
	    ch = 0xfffd;
	    SdlTkX.keyuc = 0;
	} else {
	    SdlTkX.keyuc = 0;
	}
#else
	if ((ch >= 0xd800) && (ch <= 0xdbff)) {
	    Tcl_UniChar ch2;

	    if (i + 1 < ulen) {
		n2 = Tcl_UtfToUniChar(text + n, &ch2);
		if ((ch2 >= 0xdc00) && (ch2 <= 0xdfff)) {
		    ++i;
		} else {
		    n2 = 0;
		}
	    }
	    ch = 0xfffd;
	} else if ((ch >= 0xdc00) && (ch <= 0xdfff)) {
	    ch = 0xfffd;
	} else if ((ch == 0xfffe) || (ch == 0xffff)) {
	    ch = 0xfffd;
	}
	SdlTkX.keyuc = 0;
#endif
	event->xkey.nbytes = Tcl_UniCharToUtf(ch, buf);
	event->xkey.time = SdlTkX.time_count;
	if (event->xkey.nbytes > sizeof (event->xkey.trans_chars)) {
	    event->xkey.nbytes = sizeof (event->xkey.trans_chars);
	}
	memcpy(event->xkey.trans_chars, buf, event->xkey.nbytes);
	if (len == 1) {
	    event->xkey.keycode = FixKeyCode(event->xkey.trans_chars[0]);
	} else {
	    event->xkey.keycode = -1;
	}
	text += n + n2;

	/* Queue the KeyPress */
	EVLOG("   KEYPRESS:  CODE=0x%02X  UC=0x%X", event->xkey.keycode, ch);
	event->type = KeyPress;
	if (!no_rel || (i < ulen - 1)) {
	    SdlTkQueueEvent(event);
	    /* Queue the KeyRelease except for the last */
	    event->type = KeyRelease;
	    if (i < ulen - 1) {
		EVLOG(" KEYRELEASE:  CODE=0x%02X", event->xkey.keycode);
		SdlTkQueueEvent(event);
	    }
	}
    }




    return 1;
}

/*
 *----------------------------------------------------------------------
 *
 * SdlTkTranslateEvent --
 *

    int nearby_pixels;
    TkWindow *capture_window;
    _Window *mouse_window;
    _Window *keyboard_window;
    int mouse_x;
    int mouse_y;
    int sdlfocus;
    int keyuc;
    int cursor_change;
#ifndef ANDROID
    Tcl_HashTable sdlcursors;
#endif

    /* Screen refresh, life-cycle */
    Region screen_dirty_region;

    wSrcStart = (unsigned int *) src;
    wSrcEnd = (unsigned int *) (src + srcLen);

    dstStart = dst;
    dstEnd = dst + dstLen - TCL_UTF_MAX;

    for (numChars = 0; wSrc < wSrcEnd; numChars++) {

        Tcl_UniChar ch;

	if (dst > dstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
	}
	ch = *wSrc++;













	dst += Tcl_UniCharToUtf(ch, dst);
    }

    *srcReadPtr = (char *) wSrc - (char *) wSrcStart;
    *dstWrotePtr = dst - dstStart;
    *dstCharsPtr = numChars;
    return result;

    wDst = (unsigned int *) dst;
    wDstStart = (unsigned int *) dst;
    wDstEnd = (unsigned int *) (dst + dstLen - sizeof (unsigned int));

    result = TCL_OK;
    for (numChars = 0; src < srcEnd; numChars++) {

	Tcl_UniChar ucs2;

	if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
	    /*
	     * If there is more string to follow, this will ensure that the
	     * last UTF-8 character in the source buffer hasn't been cut off.
	     */

	    result = TCL_CONVERT_MULTIBYTE;
	    break;
	}
	if (wDst > wDstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
        }
	src += Tcl_UtfToUniChar(src, &ucs2);










#ifdef USE_SYMBOLA_CTRL
	if ((ucs2 >= 0x00) && (ucs2 < 0x20)) {
	    ucs2 += 0x2400;
	} else if (ucs2 == 0x7F) {
	    ucs2 = 0x2421;
	}
#endif
	*wDst++ = ucs2;
    }
    *srcReadPtr = src - srcStart;
    *dstWrotePtr = (char *) wDst - (char *) wDstStart;
    *dstCharsPtr = numChars;
    return result;
}

 * character existence metrics, used to determine if a screen font can display
 * a given Unicode character.
 *
 * Under Unix, there are three attributes that uniquely identify a "font
 * family": the foundry, face name, and charset.
 */

#if TCL_UTF_MAX > 3
#define FONTMAP_SHIFT		12
#define FONTMAP_PAGES		(1 << (21 - FONTMAP_SHIFT))
#else
#define FONTMAP_SHIFT		10
#define FONTMAP_PAGES		(1 << (sizeof(Tcl_UniChar)*8 - FONTMAP_SHIFT))
#endif
#define FONTMAP_BITSPERPAGE	(1 << FONTMAP_SHIFT)

typedef struct FontFamily {
    struct FontFamily *nextPtr;	/* Next in list of all known font families. */
    int refCount;		/* How many SubFonts are referring to this
				 * FontFamily. When the refCount drops to
				 * zero, this FontFamily may be freed. */

} SubFont;

/*
 * The following structure represents Unix's implementation of a font object.
 */

#define SUBFONT_SPACE		3
#if TCL_UTF_MAX > 3
#define BASE_CHARS		4096
#else
#define BASE_CHARS		2048
#endif

typedef struct UnixFont {
    TkFont font;		/* Stuff used by generic font package. Must be
				 * first in structure. */
    SubFont staticSubFonts[SUBFONT_SPACE];
				/* Builtin space for a limited number of
				 * SubFonts. */

    int *dstCharsPtr)		/* Filled with the number of characters that
				 * correspond to the bytes stored in the
				 * output buffer. */
{
    const char *srcStart, *srcEnd;
    char *dstStart, *dstEnd;
    unsigned int *wDst;
    Tcl_UniChar ch;
    int result;
    static char hexChars[] = "0123456789abcdef";
    static char mapChars[] = {
	0, 0, 0, 0, 0, 0, 0,
	'a', 'b', 't', 'n', 'v', 'f', 'r'
    };

    result = TCL_OK;

    srcStart = src;
    srcEnd = src + srcLen;

    dstStart = dst;
#if TCL_UTF_MAX > 3
    dstEnd = dst + dstLen - 10 * sizeof(unsigned int);
#else
    dstEnd = dst + dstLen - 6 * sizeof(unsigned int);
#endif
    wDst = (unsigned int *) dst;

    for ( ; src < srcEnd; ) {
	if ((char *) wDst > dstEnd) {
	    result = TCL_CONVERT_NOSPACE;
	    break;
	}
	src += Tcl_UtfToUniChar(src, &ch);
	wDst[0] = '\\';
	if ((ch < sizeof(mapChars)) && (mapChars[ch] != 0)) {
	    wDst[1] = mapChars[ch];
	    wDst += 2;
	} else if (ch < 256) {
	    wDst[1] = 'x';
	    wDst[2] = hexChars[(ch >> 4) & 0xf];
	    wDst[3] = hexChars[ch & 0xf];
	    wDst += 4;
#if TCL_UTF_MAX > 3
	} else if (ch < 0x10000)  {
	    wDst[1] = 'u';
	    wDst[2] = hexChars[(ch >> 12) & 0xf];
	    wDst[3] = hexChars[(ch >> 8) & 0xf];
	    wDst[4] = hexChars[(ch >> 4) & 0xf];
	    wDst[5] = hexChars[ch & 0xf];
	    wDst += 6;

	    wDst[4] = hexChars[(ch >> 20) & 0xf];
	    wDst[5] = hexChars[(ch >> 16) & 0xf];
	    wDst[6] = hexChars[(ch >> 12) & 0xf];
	    wDst[7] = hexChars[(ch >> 8) & 0xf];
	    wDst[8] = hexChars[(ch >> 4) & 0xf];
	    wDst[9] = hexChars[ch & 0xf];
	    wDst += 10;
#else
	} else {
	    wDst[1] = 'u';
	    wDst[2] = hexChars[(ch >> 12) & 0xf];
	    wDst[3] = hexChars[(ch >> 8) & 0xf];
	    wDst[4] = hexChars[(ch >> 4) & 0xf];
	    wDst[5] = hexChars[ch & 0xf];
	    wDst += 6;
#endif
	}
    }
    *srcReadPtr = src - srcStart;
    *dstWrotePtr = (char *) wDst - dstStart;
    *dstCharsPtr = *dstWrotePtr / sizeof(unsigned int);
    return result;
}

    lastSubFontPtr = &fontPtr->subFontArray[0];

    if (numBytes == 0) {
	curX = 0;
	curByte = 0;
    } else if (maxLength < 0) {
	const char *p, *end, *next;
	Tcl_UniChar ch;
	SubFont *thisSubFontPtr;
	FontFamily *familyPtr;
	Tcl_DString runString;

	/*
	 * A three step process:
	 * 1. Find a contiguous range of characters that can all be
	 *    represented by a single screen font.
	 * 2. Convert those chars to the encoding of that font.
	 * 3. Measure converted chars.
	 */

	curX = 0;
	end = source + numBytes;
	for (p = source; p < end; ) {
	    next = p + Tcl_UtfToUniChar(p, &ch);
	    thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
	    if (thisSubFontPtr != lastSubFontPtr) {
		familyPtr = lastSubFontPtr->familyPtr;
		Tcl_UtfToExternalDString(familyPtr->encoding, source,
			p - source, &runString);
		if (lastSubFontPtr == &fontPtr->controlSubFont) {
		    fontSize =

	if (lastSubFontPtr == &fontPtr->controlSubFont) {
	    SdlTkFontRestore(lastSubFontPtr->fontStructPtr, fontSize);
	}
	Tcl_DStringFree(&runString);
	curByte = numBytes;
    } else {
	const char *p, *end, *next, *term;
	int newX, termX, sawNonSpace, dstWrote;
	Tcl_UniChar ch;
	FontFamily *familyPtr;
	char buf[64];

	/*
	 * How many chars will fit in the space allotted? This first version
	 * may be inefficient because it measures every character
	 * individually.
	 */

	next = source + Tcl_UtfToUniChar(source, &ch);
	newX = curX = termX = 0;

	term = source;
	end = source + numBytes;

	sawNonSpace = (ch > 255) || !isspace(ch);
	familyPtr = lastSubFontPtr->familyPtr;

	    p = next;
	    if (p >= end) {
		term = end;
		termX = curX;
		break;
	    }

	    next += Tcl_UtfToUniChar(next, &ch);
	    if ((ch < 256) && isspace(ch)) {
		if (sawNonSpace) {
		    term = p;
		    termX = curX;
		    sawNonSpace = 0;
		}
	    } else {

	    /*
	     * Include the first character that didn't quite fit in the
	     * desired span. The width returned will include the width of that
	     * extra character.
	     */

	    curX = newX;
	    p += Tcl_UtfToUniChar(p, &ch);
	}
	if ((flags & TK_AT_LEAST_ONE) && (term == source) && (p < end)) {
	    term = p;
	    termX = curX;
	    if (term == source) {
		term += Tcl_UtfToUniChar(term, &ch);
		termX = newX;
	    }
	} else if ((p >= end) || !(flags & TK_WHOLE_WORDS)) {
	    term = p;
	    termX = curX;
	}

    int x, int y)		/* Coordinates at which to place origin of
				 * string when drawing. */
{
    UnixFont *fontPtr = (UnixFont *) tkfont;
    SubFont *thisSubFontPtr, *lastSubFontPtr;
    Tcl_DString runString;
    const char *p, *end, *next;
    int xStart, window_width;
    Tcl_UniChar ch;
    FontFamily *familyPtr;
    int rx, ry, fontSize = 0;
    unsigned width, height, border_width, depth;
    Drawable root;

    lastSubFontPtr = &fontPtr->subFontArray[0];
    xStart = x;

    } else {
	window_width = width;
    }

    end = source + numBytes;
    for (p = source; p <= end; ) {
	if (p < end) {
	    next = p + Tcl_UtfToUniChar(p, &ch);
	    thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
	} else {
	    next = p + 1;
	    thisSubFontPtr = lastSubFontPtr;
	}
	if ((thisSubFontPtr != lastSubFontPtr)
		|| (p == end) || (p-source > 200)) {

    encoding = Tcl_GetEncoding(NULL, GetEncodingAlias(fa.xa.charset));

    familyPtr = tsdPtr->fontFamilyList;
    for (; familyPtr != NULL; familyPtr = familyPtr->nextPtr) {
	if ((familyPtr->faceName == fa.fa.family)
		&& (familyPtr->foundry == fa.xa.foundry)
		&& (familyPtr->encoding == encoding)) {

	    Tcl_FreeEncoding(encoding);

	    familyPtr->refCount++;
	    return familyPtr;
	}
    }

    familyPtr = ckalloc(sizeof(FontFamily));
    memset(familyPtr, 0, sizeof(FontFamily));

    if (familyPtr == NULL) {
	return;
    }
    familyPtr->refCount--;
    if (familyPtr->refCount > 0) {
	return;
    }

    Tcl_FreeEncoding(familyPtr->encoding);

    for (i = 0; i < FONTMAP_PAGES; i++) {
	if (familyPtr->fontMap[i] != NULL) {
	    ckfree(familyPtr->fontMap[i]);
	}
    }

    /*

    }

    end = (row + 1) << FONTMAP_SHIFT;
    for (i = row << FONTMAP_SHIFT; i < end; i++) {
	if ((i >= 0xD800) && (i <= 0xDFFF)) {
	    continue;
	}
	if (Tcl_UtfToExternal(NULL, encoding, src, Tcl_UniCharToUtf(i, src),
		TCL_ENCODING_STOPONERROR, NULL, buf, sizeof(buf), NULL,
		NULL, NULL) != TCL_OK) {
	    continue;
	}
	if (SdlTkFontHasChar(subFontPtr->fontStructPtr, buf)) {
	    bitOffset = i & (FONTMAP_BITSPERPAGE - 1);
	    subFontPtr->fontMap[row][bitOffset >> 3] |= 1 << (bitOffset & 7);

 *---------------------------------------------------------------------------
 */

static SubFont *
CanUseFallbackWithAliases(
    UnixFont *fontPtr,		/* The font object that will own the new
				 * screen font. */
    const char *faceName,		/* Desired face name for new screen font. */
    int ch,			/* The Unicode character that the new screen
				 * font must be able to display. */
    Tcl_DString *nameTriedPtr,	/* Records face names that have already been
				 * tried. It is possible for the same face
				 * name to be queried multiple times when
				 * trying to find a suitable screen font. */
    SubFont **fixSubFontPtrPtr)	/* Subfont reference to fix up if we

    if (angle == 0.0) {
	Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y);
    } else {
	UnixFont *fontPtr = (UnixFont *) tkfont;
	SubFont *thisSubFontPtr, *lastSubFontPtr;
	Tcl_DString runString;
	const char *p, *end, *next;
	int xStart, yStart, fontSize = 0;
	Tcl_UniChar ch;
	FontFamily *familyPtr;
        double sinA = sin(angle*PI/180), cosA = cos(angle*PI/180), dy;
        XPoint points[5];

	lastSubFontPtr = &fontPtr->subFontArray[0];
	xStart = x;
	yStart = y;

	end = source + numBytes;
	for (p = source; p <= end; ) {
	    if (p < end) {
		next = p + Tcl_UtfToUniChar(p, &ch);
		thisSubFontPtr = FindSubFontForChar(fontPtr, ch, &lastSubFontPtr);
	    } else {
		next = p + 1;
		thisSubFontPtr = lastSubFontPtr;
	    }
	    if ((thisSubFontPtr != lastSubFontPtr)
		    || (p == end) || (p-source > 200)) {

	Tcl_GetUnicodeFromObj(mePtr->labelPtr, &len);
	if (mePtr->underline < len) {
	    int activeBorderWidth, leftEdge;
	    const char *label, *start, *end;

	    label = Tcl_GetString(mePtr->labelPtr);
	    start = Tcl_UtfAtIndex(label, mePtr->underline);
	    end = Tcl_UtfNext(start);

	    Tk_GetPixelsFromObj(NULL, menuPtr->tkwin,
		    menuPtr->activeBorderWidthPtr, &activeBorderWidth);
	    leftEdge = x + mePtr->indicatorSpace + activeBorderWidth;
	    if (menuPtr->menuType == MENUBAR) {
		leftEdge += 5;
	    }