Tk Source Code

    int rightX;			/* Right edge of chunkPtr. */
    int rightX2;		/* Right edge of chunkPtr2. */
    int matchLeft;		/* Does the style of this line match that of
				 * its neighbor just to the left of the
				 * current x coordinate? */
    int matchRight;		/* Does line's style match its neighbor just
				 * to the right of the current x-coord? */
    int minX, maxX, xOffset, bw;
    StyleValues *sValuePtr;
    Display *display;
#ifndef TK_NO_DOUBLE_BUFFERING
    const int y = 0;
#else
    const int y = dlPtr->y;
#endif /* TK_NO_DOUBLE_BUFFERING */

	    if ((leftX + xOffset) < -(sValuePtr->borderWidth)) {
		leftX = -sValuePtr->borderWidth - xOffset;
	    }
	    if ((rightX - leftX) > 32767) {
		rightX = leftX + 32767;
	    }

            /*
             * Prevent the borders from leaking on adjacent characters,
             * which would happen for too large border width.
             */

            bw = sValuePtr->borderWidth;
            if (leftX + sValuePtr->borderWidth > rightX) {
                bw = rightX - leftX;
            }

	    XFillRectangle(display, pixmap, chunkPtr->stylePtr->bgGC,
		    leftX + xOffset, y, (unsigned int) (rightX - leftX),
		    (unsigned int) dlPtr->height);
	    if (sValuePtr->relief != TK_RELIEF_FLAT) {
		Tk_3DVerticalBevel(textPtr->tkwin, pixmap, sValuePtr->border,
			leftX + xOffset, y, bw, dlPtr->height, 1,
			sValuePtr->relief);
		Tk_3DVerticalBevel(textPtr->tkwin, pixmap, sValuePtr->border,

			rightX - bw + xOffset, y, bw, dlPtr->height, 0,
			sValuePtr->relief);
	    }
	}
	leftX = rightX;
    }

    /*

	 * matches the current line on one side of the change but not on the
	 * other, we have to draw an L-shaped piece of bevel.
	 */

	matchRight = (nextPtr2 != NULL)
		&& SAME_BACKGROUND(nextPtr2->stylePtr, chunkPtr->stylePtr);
	if (matchLeft && !matchRight) {
            bw = sValuePtr->borderWidth;
            if (rightX2 - sValuePtr->borderWidth < leftX) {
                bw = rightX2 - leftX;
            }
	    if (sValuePtr->relief != TK_RELIEF_FLAT) {
		Tk_3DVerticalBevel(textPtr->tkwin, pixmap, sValuePtr->border,
			rightX2 - bw + xOffset, y, bw,
			sValuePtr->borderWidth, 0, sValuePtr->relief);

	    }
            leftX = rightX2 - bw;
	    leftXIn = 0;
	} else if (!matchLeft && matchRight
		&& (sValuePtr->relief != TK_RELIEF_FLAT)) {
            bw = sValuePtr->borderWidth;
            if (rightX2 + sValuePtr->borderWidth > rightX) {
                bw = rightX - rightX2;
            }
	    Tk_3DVerticalBevel(textPtr->tkwin, pixmap, sValuePtr->border,
		    rightX2 + xOffset, y, bw, sValuePtr->borderWidth,
		    1, sValuePtr->relief);
	    Tk_3DHorizontalBevel(textPtr->tkwin, pixmap, sValuePtr->border,
		    leftX + xOffset, y, rightX2 + bw - leftX,
		    sValuePtr->borderWidth, leftXIn, 0, 1,
		    sValuePtr->relief);
	}

    nextChunk2:
	chunkPtr2 = nextPtr2;
	if (chunkPtr2 == NULL) {
	    rightX2 = INT_MAX;

    rightX = chunkPtr->x + chunkPtr->width;
    if ((chunkPtr->nextPtr == NULL) && (rightX < maxX)) {
	rightX = maxX;
    }
    chunkPtr2 = NULL;
    if (dlPtr->nextPtr != NULL && dlPtr->nextPtr->chunkPtr != NULL) {
	/*
	 * Find the chunk in the next line that covers leftX.
	 */

	nextPtr2 = dlPtr->nextPtr->chunkPtr;
	rightX2 = 0;			/* See Note A above. */
	while (rightX2 <= leftX) {
	    chunkPtr2 = nextPtr2;
	    if (chunkPtr2 == NULL) {

	    }
	    continue;
	}

	matchRight = (nextPtr2 != NULL)
		&& SAME_BACKGROUND(nextPtr2->stylePtr, chunkPtr->stylePtr);
	if (matchLeft && !matchRight) {
            bw = sValuePtr->borderWidth;
            if (rightX2 - sValuePtr->borderWidth < leftX) {
                bw = rightX2 - leftX;
            }
	    if (sValuePtr->relief != TK_RELIEF_FLAT) {
		Tk_3DVerticalBevel(textPtr->tkwin, pixmap, sValuePtr->border,
			rightX2 - bw + xOffset,
			y + dlPtr->height - sValuePtr->borderWidth,
			bw, sValuePtr->borderWidth, 0, sValuePtr->relief);

	    }
	    leftX = rightX2 - bw;
	    leftXIn = 1;
	} else if (!matchLeft && matchRight
		&& (sValuePtr->relief != TK_RELIEF_FLAT)) {
            bw = sValuePtr->borderWidth;
            if (rightX2 + sValuePtr->borderWidth > rightX) {
                bw = rightX - rightX2;
            }
	    Tk_3DVerticalBevel(textPtr->tkwin, pixmap, sValuePtr->border,
		    rightX2 + xOffset,
		    y + dlPtr->height - sValuePtr->borderWidth, bw,
		    sValuePtr->borderWidth, 1, sValuePtr->relief);
	    Tk_3DHorizontalBevel(textPtr->tkwin, pixmap, sValuePtr->border,
		    leftX + xOffset,
		    y + dlPtr->height - sValuePtr->borderWidth,
		    rightX2 + bw - leftX, sValuePtr->borderWidth, leftXIn,
		    1, 0, sValuePtr->relief);
	}

    nextChunk2b:
	chunkPtr2 = nextPtr2;
	if (chunkPtr2 == NULL) {
	    rightX2 = INT_MAX;
	} else {

};
enum colorOptions {
    COLOR_INITIAL, COLOR_PARENT, COLOR_TITLE
};

static const char *const openOptionStrings[] = {
    "-defaultextension", "-filetypes", "-initialdir", "-initialfile",
    "-message", "-multiple", "-parent", "-title", "-typevariable",
    "-command", NULL
};
enum openOptions {
    OPEN_DEFAULT, OPEN_FILETYPES, OPEN_INITDIR, OPEN_INITFILE,
    OPEN_MESSAGE, OPEN_MULTIPLE, OPEN_PARENT, OPEN_TITLE,
    OPEN_TYPEVARIABLE, OPEN_COMMAND,
};
static const char *const saveOptionStrings[] = {
    "-defaultextension", "-filetypes", "-initialdir", "-initialfile",
    "-message", "-parent", "-title", "-typevariable", "-command",
    "-confirmoverwrite", NULL
};
enum saveOptions {
    SAVE_DEFAULT, SAVE_FILETYPES, SAVE_INITDIR, SAVE_INITFILE,
    SAVE_MESSAGE, SAVE_PARENT, SAVE_TITLE, SAVE_TYPEVARIABLE, SAVE_COMMAND,
    SAVE_CONFIRMOW
};
static const char *const chooseOptionStrings[] = {
    "-initialdir", "-message", "-mustexist", "-parent", "-title", "-command",
    NULL
};
enum chooseOptions {
    CHOOSE_INITDIR, CHOOSE_MESSAGE, CHOOSE_MUSTEXIST, CHOOSE_PARENT,
    CHOOSE_TITLE, CHOOSE_COMMAND,
};
typedef struct {
    Tcl_Interp *interp;
    Tcl_Obj *cmdObj;
    int multiple;
} FilePanelCallbackInfo;

    Tcl_Interp *interp,		/* Current interpreter. */
    int objc,			/* Number of arguments. */
    Tcl_Obj *const objv[])	/* Argument objects. */
{
    Tk_Window tkwin = clientData;
    char *str;
    int i, result = TCL_ERROR, haveParentOption = 0;
    int index, len, multiple = 0;
    FileFilterList fl;
    Tcl_Obj *cmdObj = NULL, *typeVariablePtr = NULL;
    FilePanelCallbackInfo callbackInfoStruct;
    FilePanelCallbackInfo *callbackInfo = &callbackInfoStruct;
    NSString *directory = nil, *filename = nil;
    NSString *message, *title, *type;
    NSWindow *parent;

	    [message release];
	    break;
	case OPEN_MULTIPLE:
	    if (Tcl_GetBooleanFromObj(interp, objv[i + 1],
		    &multiple) != TCL_OK) {
		goto end;
	    }






	    break;
	case OPEN_PARENT:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    tkwin = Tk_NameToWindow(interp, str, tkwin);
	    if (!tkwin) {
		goto end;
	    }

    Tcl_Interp *interp,		/* Current interpreter. */
    int objc,			/* Number of arguments. */
    Tcl_Obj *const objv[])	/* Argument objects. */
{
    Tk_Window tkwin = clientData;
    char *str;
    int i, result = TCL_ERROR, haveParentOption = 0;
    int confirmOverwrite = 1;
    int index, len;
    FileFilterList fl;
    Tcl_Obj *cmdObj = NULL;
    FilePanelCallbackInfo callbackInfoStruct;
    FilePanelCallbackInfo *callbackInfo = &callbackInfoStruct;
    NSString *directory = nil, *filename = nil, *defaultType = nil;
    NSString *message, *title, *type;

	    }
	    break;
	case SAVE_MESSAGE:
	    message = [[NSString alloc] initWithUTF8String:
		    Tcl_GetString(objv[i + 1])];
	    [panel setMessage:message];
	    [message release];






	    break;
	case SAVE_PARENT:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    tkwin = Tk_NameToWindow(interp, str, tkwin);
	    if (!tkwin) {
		goto end;
	    }

    Tcl_Interp *interp,		/* Current interpreter. */
    int objc,			/* Number of arguments. */
    Tcl_Obj *const objv[])	/* Argument objects. */
{
    Tk_Window tkwin = clientData;
    char *str;
    int i, result = TCL_ERROR, haveParentOption = 0;
    int index, len, mustexist = 0;
    Tcl_Obj *cmdObj = NULL;
    FilePanelCallbackInfo callbackInfoStruct;
    FilePanelCallbackInfo *callbackInfo = &callbackInfoStruct;
    NSString *directory = nil, *filename = nil;
    NSString *message, *title;
    NSWindow *parent;
    NSOpenPanel *panel = [NSOpenPanel openPanel];

	    [message release];
	    break;
	case CHOOSE_MUSTEXIST:
	    if (Tcl_GetBooleanFromObj(interp, objv[i + 1],
		    &mustexist) != TCL_OK) {
		goto end;
	    }






	    break;
	case CHOOSE_PARENT:
	    str = Tcl_GetStringFromObj(objv[i + 1], &len);
	    tkwin = Tk_NameToWindow(interp, str, tkwin);
	    if (!tkwin) {
		goto end;
	    }

static const char *
XftGetInt(const char *ptr, int *val)
{
    if (*ptr == '*') {
	*val = -1;
	ptr++;
    } else {
	*val = '\0';
	while ((*ptr >= '0') && (*ptr <= '9')) {
	    *val = *val * 10 + *ptr++ - '0';
	}
    }
    if (*ptr == '-') {
	return ptr;
    }
    return (char *) 0;

    Tcl_DStringInit(&ds);
    Tcl_MutexLock(&fnt_mutex);
    hPtr = Tcl_FirstHashEntry(&file_face_hash, &search);
    while (hPtr != NULL) {
        GlyphIndexHash *ghash;
        
	ghash = (GlyphIndexHash *) Tcl_GetHashValue(hPtr);
	if ((name[0] == '*') || (strcasecmp(ghash->familyName, name) == 0)) {
	    Tcl_DStringAppend(&ds, "-unknown-", -1);
	    Tcl_DStringAppend(&ds, ghash->familyName, -1);
	    if (ghash->styleFlags & FT_STYLE_FLAG_BOLD) {
	        Tcl_DStringAppend(&ds, "-bold", -1);
	    } else {
	        Tcl_DStringAppend(&ds, "-normal", -1);
	    }

	    nmatch++;
	}
	hPtr = Tcl_NextHashEntry(&search);
    }
    Tcl_MutexUnlock(&fnt_mutex);
    *count = 0;
    /* fallback for "fixed" */
    if ((nmatch == 0) && (strcmp(name, "fixed") == 0)) {
	const char *fbfont =
	    "-unknown-dejavu sans mono-bold-r-normal-*-14-*-*-*-*-*-ucs-4";

	Tcl_DStringAppend(&ds, fbfont, -1);
	Tcl_DStringAppend(&ds, "\0", 1);
	nmatch++;
    }

    }
    if (!(p = strchr(++p, '-'))) {
        return TCL_ERROR;
    }
    if (!(p = strchr (++p, '-'))) {
        return TCL_ERROR;
    }
    if (!(p = XftGetInt (++p, &size)) || (size < 0)) {
        return TCL_ERROR;
    }
    hPtr = Tcl_FirstHashEntry(&file_face_hash, &search);
    while (hPtr != NULL) {
	ghash = (GlyphIndexHash *) Tcl_GetHashValue(hPtr);
	if (Tcl_StringCaseMatch(xlfd, ghash->xlfdPattern, 1)) {
	    ffKey = (FileFaceKey *) Tcl_GetHashKey(&file_face_hash, hPtr);

	if (aliases != NULL) {
	    int i;

	    for (i = 0; aliases[i] != NULL; i++) {
		Tcl_DStringSetLength(&ds, 0);
		Tcl_DStringAppend(&ds, "-unknown-", -1);
		Tcl_DStringAppend(&ds, aliases[i], -1);
		if ((weight[0] == 'b') || (weight[0] == 'B')) {
		    Tcl_DStringAppend(&ds, "-bold", -1);
		} else {
		    Tcl_DStringAppend(&ds, "-normal", -1);
		}
		if ((slant[0] == 'i') || (slant[0] == 'I') ||
		    (slant[0] == 'o') || (slant[0] == 'O')) {
		    Tcl_DStringAppend(&ds, "-o", -1);
		} else {
		    Tcl_DStringAppend(&ds, "-r", -1);
		}
		Tcl_DStringAppend(&ds, "-normal-*-*-*-*-*-*-*-ucs-4", -1);
		hPtr = Tcl_FirstHashEntry(&file_face_hash, &search);
		while (hPtr != NULL) {

static unsigned long
SdlTkReadFTStream(FT_Stream ftstr, unsigned long offs, unsigned char *buf,
		  unsigned long count)
{
    unsigned long ret = 0;

    if (ftstr->descriptor.pointer == NULL) {
	Tcl_Channel chan;

	chan = Tcl_OpenFileChannel(NULL, (char *) ftstr->pathname.pointer,
				   "r", 0);
	if (chan) {
	    Tcl_SetChannelOption(NULL, chan, "-encoding", "binary");
	    Tcl_SetChannelOption(NULL, chan, "-translation", "binary");
	    ftstr->descriptor.pointer = (void *) chan;
	}
    }
    if ((ftstr->descriptor.pointer != NULL) && count) {
        Tcl_WideInt wOffs;
	int n;

	wOffs = offs;
	wOffs = Tcl_Seek((Tcl_Channel) ftstr->descriptor.pointer, wOffs,
			 SEEK_SET);
	if (wOffs == -1) {

static void
SdlTkCloseFTStream(FT_Stream ftstr)
{
    if (!ftstr) {
	return;
    }
    if (ftstr->descriptor.pointer != NULL) {
        Tcl_Close(NULL, (Tcl_Channel) ftstr->descriptor.pointer);
	ftstr->descriptor.pointer = NULL;
    }
    ftstr->pathname.pointer = NULL;
    ckfree((char *) ftstr); 
}

void *
SdlTkGetFTStream(const char *pathname, int size)
{
    FT_Stream ftstr = (FT_Stream) ckalloc(sizeof (*ftstr));

    Tcl_DStringFree(&ds);
    if (ret == TCL_OK) {
	fileName = (char *) XInternAtom(SdlTkX.display, fstorage.file, False);
    }
    if (nameRet != NULL) {
	*nameRet = fileName;
    }
    if ((filesizeRet != NULL) && (fileName != NULL)) {
	struct stat stbuf;

	*filesizeRet = 0;

	if (Tcl_Stat(fileName, &stbuf) == 0) {
	    *filesizeRet = stbuf.st_size;
	}
    }
    if ((fileName != NULL) && (fstorage.file != fileName)) {
	ckfree(fstorage.file);
    }
    if (fstorage.xlfd != NULL) {
	ckfree(fstorage.xlfd);
    }
    return ret == TCL_OK;
}

int
SdlTkFontInit(Tcl_Interp *interp)
{

	    fterr = FT_Open_Face(ftlib, &ftarg, k, &face);
	    if (fterr != 0) {
	        continue;
	    }
	    if (!(face->face_flags & FT_FACE_FLAG_SCALABLE)) {
	        goto nextface;
	    }
	    if ((face->num_charmaps < 1) || !face->charmap ||
		(face->charmap->encoding != FT_ENCODING_UNICODE)) {
		goto nextface;
	    }
	    memset(&ffKey, '\0', sizeof (ffKey));
	    ffKey.file = XInternAtom(SdlTkX.display, argv[i], False);
	    ffKey.index = k;
	    hPtr = Tcl_CreateHashEntry(&file_face_hash, (char *) &ffKey,
				       &isNew);
	    if (isNew) {
	        GlyphIndexHash *ghash;
		Tcl_DString ds, ds2;
		char *style, *weight;

		ghash = (GlyphIndexHash *) ckalloc(sizeof (GlyphIndexHash));
		Tcl_InitHashTable(&ghash->hash, TCL_ONE_WORD_KEYS);
		ghash->refCnt = 1;
		ghash->familyName = ckalloc(strlen(face->family_name) + 24);
		strcpy(ghash->familyName, face->family_name);
		ghash->faceFlags = face->face_flags;
		ghash->styleFlags = face->style_flags;
		Tcl_DStringInit(&ds);
		Tcl_DStringInit(&ds2);
		if (face->style_name != NULL) {
		    Tcl_DStringAppend(&ds2, face->style_name, -1);
		    style = Tcl_DStringValue(&ds2);
		    while (*style) {
			*style = tolower((UCHAR(*style)));
			++style;
		    }
		}
		weight = "-normal";
		style = Tcl_DStringValue(&ds2);


		if (strstr(style, "black")) {

		    strcat(ghash->familyName, " Black");
		} else if (strstr(style, "light")) {

		    strcat(ghash->familyName, " Light");
		} else if (strstr(style, "thin")) {

		    strcat(ghash->familyName, " Thin");
		} else if (strstr(style, "medium")) {
		    strcat(ghash->familyName, " Medium");
		}
		if (ghash->styleFlags & FT_STYLE_FLAG_BOLD) {
		    weight = "-bold";
		}
		Tcl_DStringAppend(&ds, "-*-", -1);

		Tcl_DStringAppend(&ds, ghash->familyName, -1);
		Tcl_DStringAppend(&ds, weight, -1);

		if (ghash->styleFlags & FT_STYLE_FLAG_ITALIC) {
		    Tcl_DStringAppend(&ds, "-o", -1);
		} else {
		    Tcl_DStringAppend(&ds, "-r", -1);
		}
		Tcl_DStringAppend(&ds, "-*-*-*-*-*-*-*-*-ucs-4", -1);
		ghash->xlfdPattern = ckalloc(Tcl_DStringLength(&ds) + 1);

	fterr = FT_Open_Face(ftlib, &ftarg, k, &face);
	if (fterr != 0) {
	    continue;
	}
	if (!(face->face_flags & FT_FACE_FLAG_SCALABLE)) {
	    goto nextface;
	}
	if ((face->num_charmaps < 1) || !face->charmap ||
	    (face->charmap->encoding != FT_ENCODING_UNICODE)) {
	    goto nextface;
	}
	memset(&ffKey, '\0', sizeof (ffKey));
	ffKey.file = XInternAtom(SdlTkX.display, fileName, False);
	ffKey.index = k;
	hPtr = Tcl_CreateHashEntry(&file_face_hash, (char *) &ffKey, &isNew);
	if (isNew) {

regions to exercise the bevel-drawing facilities of
DisplayLineBackground.  The letters have the following
significance:

r - should appear raised
u - should appear raised and also slightly offset vertically
s - should appear sunken
S - should appear solid
n - preceding relief should extend right to end of line.
* - should appear "normal"
x - extra long lines to allow horizontal scrolling.

Try scrolling the text both vertically and horizontally to
be sure that the bevels are still drawn correctly.

    .t.t insert end rrrrr r1
}
.t.t insert end \n
.t.t insert end rrr r1
.t.t insert end *****
.t.t insert end rrr r1

font configure TkFixedFont -size 20
.t.t tag configure sol100 -relief solid -borderwidth 100 \
                          -foreground red -font TkFixedFont
.t.t tag configure sol12 -relief solid -borderwidth 12 \
                          -foreground red -font TkFixedFont
.t.t tag configure big -font TkFixedFont
set ind [.t.t index end]

.t.t insert end "\n\nBorders do not leak on the neighbour chars"
.t.t insert end "\nOnly \"S\" is on dark background"
.t.t insert end {
 xxx
 x} {} S sol100 {x
 xxx}

.t.t insert end "\n\nA very thick border grows toward the inside of the tagged area only"
.t.t insert end "\nOnly \"S\" is on dark background"
.t.t insert end {
 xxxx} {} SSSSS sol100 {xxxx
 x} {} SSSSSSSSSSSSSSSSSS sol100 {x
 xxx} {} SSSSSSSSS sol100 xxxx {}
}

.t.t insert end "\n\nA thinner border is continuous"
.t.t insert end {
 xxxx} {} SSSSS sol12 {xxxx
 x} {} SSSSSSSSSSSSSSSSSS sol12 {x
 xxx} {} SSSSSSSSS sol12 xxxx {}
}

.t.t tag add big $ind end

    if test "${SHARED_BUILD}" = 1 -a "${SHLIB_SUFFIX}" != ""; then

        LIB_SUFFIX=${SHARED_LIB_SUFFIX}
        MAKE_LIB='${SHLIB_LD} -o $@ ${OBJS} ${SHLIB_LD_LIBS} ${TCL_SHLIB_LD_EXTRAS} ${TK_SHLIB_LD_EXTRAS} ${LD_SEARCH_FLAGS}'
        if test "${SHLIB_SUFFIX}" = ".dll"; then

            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) "$(BIN_INSTALL_DIR)/$(LIB_FILE)";if test -f $(LIB_FILE).a; then $(INSTALL_DATA) $(LIB_FILE).a "$(LIB_INSTALL_DIR)"; fi;'
            DLL_INSTALL_DIR="\$(BIN_INSTALL_DIR)"

else

            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) "$(LIB_INSTALL_DIR)/$(LIB_FILE)"'

fi

	UNSHARED_LIB_SUFFIX='${VERSION}.a'])
    DLL_INSTALL_DIR="\$(LIB_INSTALL_DIR)"

    AS_IF([test "${SHARED_BUILD}" = 1 -a "${SHLIB_SUFFIX}" != ""], [
        LIB_SUFFIX=${SHARED_LIB_SUFFIX}
        MAKE_LIB='${SHLIB_LD} -o [$]@ ${OBJS} ${SHLIB_LD_LIBS} ${TCL_SHLIB_LD_EXTRAS} ${TK_SHLIB_LD_EXTRAS} ${LD_SEARCH_FLAGS}'
        AS_IF([test "${SHLIB_SUFFIX}" = ".dll"], [
            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) "$(BIN_INSTALL_DIR)/$(LIB_FILE)";if test -f $(LIB_FILE).a; then $(INSTALL_DATA) $(LIB_FILE).a "$(LIB_INSTALL_DIR)"; fi;'
            DLL_INSTALL_DIR="\$(BIN_INSTALL_DIR)"
        ], [
            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) "$(LIB_INSTALL_DIR)/$(LIB_FILE)"'
        ])
    ], [
        LIB_SUFFIX=${UNSHARED_LIB_SUFFIX}