shared_source/c_tk_base_7_5_w_mods/tkwin3d.c

/* $Header$ */

/* 
 * tkWin3d.c --
 *
 *      This file contains the platform specific routines for
 *      drawing 3d borders in the Windows 95 style.
 *
 * Copyright (c) 1996 by Sun Microsystems, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tkwin3d.c,v 1.1.1.1 2001/06/13 05:11:49 dtashley Exp $
 */

#include "tkWinInt.h"
#include "tk3d.h"

/*
 * This structure is used to keep track of the extra colors used by
 * Windows 3d borders.
 */

typedef struct {
    TkBorder info;
    XColor *light2ColorPtr; /* System3dLight */
    XColor *dark2ColorPtr;  /* System3dDarkShadow */
} WinBorder;


/*
 *----------------------------------------------------------------------
 *
 * TkpGetBorder --
 *
 *      This function allocates a new TkBorder structure.
 *
 * Results:
 *      Returns a newly allocated TkBorder.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

TkBorder *
TkpGetBorder()
{
    WinBorder *borderPtr = (WinBorder *) ckalloc(sizeof(WinBorder));
    borderPtr->light2ColorPtr = NULL;
    borderPtr->dark2ColorPtr = NULL;
    return (TkBorder *) borderPtr;
}

/*
 *----------------------------------------------------------------------
 *
 * TkpFreeBorder --
 *
 *      This function frees any colors allocated by the platform
 *      specific part of this module.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      May deallocate some colors.
 *
 *----------------------------------------------------------------------
 */

void
TkpFreeBorder(borderPtr)
    TkBorder *borderPtr;
{
    WinBorder *winBorderPtr = (WinBorder *) borderPtr;
    if (winBorderPtr->light2ColorPtr) {
        Tk_FreeColor(winBorderPtr->light2ColorPtr);
    }
    if (winBorderPtr->dark2ColorPtr) {
        Tk_FreeColor(winBorderPtr->dark2ColorPtr);
    }
}

/*
 *--------------------------------------------------------------
 *
 * Tk_3DVerticalBevel --
 *
 *      This procedure draws a vertical bevel along one side of
 *      an object.  The bevel is always rectangular in shape:
 *                      |||
 *                      |||
 *                      |||
 *                      |||
 *                      |||
 *                      |||
 *      An appropriate shadow color is chosen for the bevel based
 *      on the leftBevel and relief arguments.  Normally this
 *      procedure is called first, then Tk_3DHorizontalBevel is
 *      called next to draw neat corners.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Graphics are drawn in drawable.
 *
 *--------------------------------------------------------------
 */

void
Tk_3DVerticalBevel(tkwin, drawable, border, x, y, width, height,
        leftBevel, relief)
    Tk_Window tkwin;            /* Window for which border was allocated. */
    Drawable drawable;          /* X window or pixmap in which to draw. */
    Tk_3DBorder border;         /* Token for border to draw. */
    int x, y, width, height;    /* Area of vertical bevel. */
    int leftBevel;              /* Non-zero means this bevel forms the
                                 * left side of the object;  0 means it
                                 * forms the right side. */
    int relief;                 /* Kind of bevel to draw.  For example,
                                 * TK_RELIEF_RAISED means interior of
                                 * object should appear higher than
                                 * exterior. */
{
    TkBorder *borderPtr = (TkBorder *) border;
    int left, right;
    Display *display = Tk_Display(tkwin);
    TkWinDCState state;
    HDC dc = TkWinGetDrawableDC(display, drawable, &state);
    int half;

    if ((borderPtr->lightGC == None) && (relief != TK_RELIEF_FLAT)) {
        TkpGetShadows(borderPtr, tkwin);
    }

    switch (relief) {
        case TK_RELIEF_RAISED:
            left = (leftBevel)
                ? borderPtr->lightGC->foreground
                : borderPtr->darkGC->foreground;
            right = (leftBevel)
                ? ((WinBorder *)borderPtr)->light2ColorPtr->pixel
                : ((WinBorder *)borderPtr)->dark2ColorPtr->pixel;
            break;
        case TK_RELIEF_SUNKEN:
            left = (leftBevel)
                ? ((WinBorder *)borderPtr)->dark2ColorPtr->pixel
                : ((WinBorder *)borderPtr)->light2ColorPtr->pixel;
            right = (leftBevel)
                ? borderPtr->darkGC->foreground
                : borderPtr->lightGC->foreground;
            break;
        case TK_RELIEF_RIDGE:
            left = borderPtr->lightGC->foreground;
            right = borderPtr->darkGC->foreground;
            break;
        case TK_RELIEF_GROOVE:
            left = borderPtr->darkGC->foreground;
            right = borderPtr->lightGC->foreground;
            break;
        case TK_RELIEF_FLAT:
            left = right = borderPtr->bgGC->foreground;
            break;
        case TK_RELIEF_SOLID:
            left = right = RGB(0,0,0);
            break;
    }
    half = width/2;
    if (leftBevel && (width & 1)) {
        half++;
    }
    TkWinFillRect(dc, x, y, half, height, left);
    TkWinFillRect(dc, x+half, y, width-half, height, right);
    TkWinReleaseDrawableDC(drawable, dc, &state);
}

/*
 *--------------------------------------------------------------
 *
 * Tk_3DHorizontalBevel --
 *
 *      This procedure draws a horizontal bevel along one side of
 *      an object.  The bevel has mitered corners (depending on
 *      leftIn and rightIn arguments).
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *--------------------------------------------------------------
 */

void
Tk_3DHorizontalBevel(tkwin, drawable, border, x, y, width, height,
        leftIn, rightIn, topBevel, relief)
    Tk_Window tkwin;            /* Window for which border was allocated. */
    Drawable drawable;          /* X window or pixmap in which to draw. */
    Tk_3DBorder border;         /* Token for border to draw. */
    int x, y, width, height;    /* Bounding box of area of bevel.  Height
                                 * gives width of border. */
    int leftIn, rightIn;        /* Describes whether the left and right
                                 * edges of the bevel angle in or out as
                                 * they go down.  For example, if "leftIn"
                                 * is true, the left side of the bevel
                                 * looks like this:
                                 *      ___________
                                 *       __________
                                 *        _________
                                 *         ________
                                 */
    int topBevel;               /* Non-zero means this bevel forms the
                                 * top side of the object;  0 means it
                                 * forms the bottom side. */
    int relief;                 /* Kind of bevel to draw.  For example,
                                 * TK_RELIEF_RAISED means interior of
                                 * object should appear higher than
                                 * exterior. */
{
    TkBorder *borderPtr = (TkBorder *) border;
    Display *display = Tk_Display(tkwin);
    int bottom, halfway, x1, x2, x1Delta, x2Delta;
    TkWinDCState state;
    HDC dc = TkWinGetDrawableDC(display, drawable, &state);
    int topColor, bottomColor;

    if ((borderPtr->lightGC == None) && (relief != TK_RELIEF_FLAT)) {
        TkpGetShadows(borderPtr, tkwin);
    }

    /*
     * Compute a GC for the top half of the bevel and a GC for the
     * bottom half (they're the same in many cases).
     */

    switch (relief) {
        case TK_RELIEF_RAISED:
            topColor = (topBevel)
                ? borderPtr->lightGC->foreground
                : borderPtr->darkGC->foreground;
            bottomColor = (topBevel)
                ? ((WinBorder *)borderPtr)->light2ColorPtr->pixel
                : ((WinBorder *)borderPtr)->dark2ColorPtr->pixel;
            break;
        case TK_RELIEF_SUNKEN:
            topColor = (topBevel)
                ? ((WinBorder *)borderPtr)->dark2ColorPtr->pixel
                : ((WinBorder *)borderPtr)->light2ColorPtr->pixel;
            bottomColor = (topBevel)
                ? borderPtr->darkGC->foreground
                : borderPtr->lightGC->foreground;
            break;
        case TK_RELIEF_RIDGE:
            topColor = borderPtr->lightGC->foreground;
            bottomColor = borderPtr->darkGC->foreground;
            break;
        case TK_RELIEF_GROOVE:
            topColor = borderPtr->darkGC->foreground;
            bottomColor = borderPtr->lightGC->foreground;
            break;
        case TK_RELIEF_FLAT:
            topColor = bottomColor = borderPtr->bgGC->foreground;
            break;
        case TK_RELIEF_SOLID:
            topColor = bottomColor = RGB(0,0,0);
    }

    /*
     * Compute various other geometry-related stuff.
     */

    if (leftIn) {
        x1 = x+1;
    } else {
        x1 = x+height-1;
    }
    x2 = x+width;
    if (rightIn) {
        x2--;
    } else {
        x2 -= height;
    }
    x1Delta = (leftIn) ? 1 : -1;
    x2Delta = (rightIn) ? -1 : 1;
    halfway = y + height/2;
    if (topBevel && (height & 1)) {
        halfway++;
    }
    bottom = y + height;

    /*
     * Draw one line for each y-coordinate covered by the bevel.
     */

    for ( ; y < bottom; y++) {
        /*
         * In some weird cases (such as large border widths for skinny
         * rectangles) x1 can be >= x2.  Don't draw the lines
         * in these cases.
         */

        if (x1 < x2) {
            TkWinFillRect(dc, x1, y, x2-x1, 1,
                (y < halfway) ? topColor : bottomColor);
        }
        x1 += x1Delta;
        x2 += x2Delta;
    }
    TkWinReleaseDrawableDC(drawable, dc, &state);
}

/*
 *----------------------------------------------------------------------
 *
 * TkpGetShadows --
 *
 *      This procedure computes the shadow colors for a 3-D border
 *      and fills in the corresponding fields of the Border structure.
 *      It's called lazily, so that the colors aren't allocated until
 *      something is actually drawn with them.  That way, if a border
 *      is only used for flat backgrounds the shadow colors will
 *      never be allocated.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The lightGC and darkGC fields in borderPtr get filled in,
 *      if they weren't already.
 *
 *----------------------------------------------------------------------
 */

void
TkpGetShadows(borderPtr, tkwin)
    TkBorder *borderPtr;        /* Information about border. */
    Tk_Window tkwin;            /* Window where border will be used for
                                 * drawing. */
{
    XColor lightColor, darkColor;
    int tmp1, tmp2;
    int r, g, b;
    XGCValues gcValues;

    if (borderPtr->lightGC != None) {
        return;
    }

    /*
     * Handle the special case of the default system colors.
     */

    if ((TkWinIndexOfColor(borderPtr->bgColorPtr) == COLOR_3DFACE)
        || (TkWinIndexOfColor(borderPtr->bgColorPtr) == COLOR_WINDOW)) {
        borderPtr->darkColorPtr = Tk_GetColor(NULL, tkwin,
            Tk_GetUid("SystemButtonShadow"));
        gcValues.foreground = borderPtr->darkColorPtr->pixel;
        borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
        borderPtr->lightColorPtr = Tk_GetColor(NULL, tkwin,
            Tk_GetUid("SystemButtonHighlight"));
        gcValues.foreground = borderPtr->lightColorPtr->pixel;
        borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
        ((WinBorder*)borderPtr)->dark2ColorPtr = Tk_GetColor(NULL, tkwin,
                Tk_GetUid("System3dDarkShadow"));
        ((WinBorder*)borderPtr)->light2ColorPtr = Tk_GetColor(NULL, tkwin,
                Tk_GetUid("System3dLight"));
        return;
    } else {
        darkColor.red = 0;
        darkColor.green = 0;
        darkColor.blue = 0;
        ((WinBorder*)borderPtr)->dark2ColorPtr = Tk_GetColorByValue(tkwin,
            &darkColor);
        lightColor = *(borderPtr->bgColorPtr);
        ((WinBorder*)borderPtr)->light2ColorPtr = Tk_GetColorByValue(tkwin, 
            &lightColor);
    }
    
    /*
     * First, handle the case of a color display with lots of colors.
     * The shadow colors get computed using whichever formula results
     * in the greatest change in color:
     * 1. Lighter shadow is half-way to white, darker shadow is half
     *    way to dark.
     * 2. Lighter shadow is 40% brighter than background, darker shadow
     *    is 40% darker than background.
     */

    if (Tk_Depth(tkwin) >= 6) {
        /*
         * This is a color display with lots of colors.  For the dark
         * shadow, cut 40% from each of the background color components.
         * But if the background is already very dark, make the
         * dark color a little lighter than the background by increasing
         * each color component 1/4th of the way to MAX_INTENSITY.
         *
         * For the light shadow, boost each component by 40% or half-way
         * to white, whichever is greater (the first approach works
         * better for unsaturated colors, the second for saturated ones).
         * But if the background is already very bright, instead choose a
         * slightly darker color for the light shadow by reducing each
         * color component by 10%.
         *
         * Compute the colors using integers, not using lightColor.red
         * etc.: these are shorts and may have problems with integer
         * overflow.
         */

        /*
         * Compute the dark shadow color
         */

        r = (int) borderPtr->bgColorPtr->red;
        g = (int) borderPtr->bgColorPtr->green;
        b = (int) borderPtr->bgColorPtr->blue;

        if (r*0.5*r + g*1.0*g + b*0.28*b < MAX_INTENSITY*0.05*MAX_INTENSITY) {
            darkColor.red = (MAX_INTENSITY + 3*r)/4;
            darkColor.green = (MAX_INTENSITY + 3*g)/4;
            darkColor.blue = (MAX_INTENSITY + 3*b)/4;
        } else {
            darkColor.red = (60 * r)/100;
            darkColor.green = (60 * g)/100;
            darkColor.blue = (60 * b)/100;
        }

        /*
         * Allocate the dark shadow color and its GC
         */

        borderPtr->darkColorPtr = Tk_GetColorByValue(tkwin, &darkColor);
        gcValues.foreground = borderPtr->darkColorPtr->pixel;
        borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues);

        /*
         * Compute the light shadow color
         */

        if (g > MAX_INTENSITY*0.95) {
            lightColor.red = (90 * r)/100;
            lightColor.green = (90 * g)/100;
            lightColor.blue = (90 * b)/100;
        } else {
            tmp1 = (14 * r)/10;
            if (tmp1 > MAX_INTENSITY) {
                tmp1 = MAX_INTENSITY;
            }
            tmp2 = (MAX_INTENSITY + r)/2;
            lightColor.red = (tmp1 > tmp2) ? tmp1 : tmp2;
            tmp1 = (14 * g)/10;
            if (tmp1 > MAX_INTENSITY) {
                tmp1 = MAX_INTENSITY;
            }
            tmp2 = (MAX_INTENSITY + g)/2;
            lightColor.green = (tmp1 > tmp2) ? tmp1 : tmp2;
            tmp1 = (14 * b)/10;
            if (tmp1 > MAX_INTENSITY) {
                tmp1 = MAX_INTENSITY;
            }
            tmp2 = (MAX_INTENSITY + b)/2;
            lightColor.blue = (tmp1 > tmp2) ? tmp1 : tmp2;
        }
        
       /*
        * Allocate the light shadow color and its GC
        */

        borderPtr->lightColorPtr = Tk_GetColorByValue(tkwin, &lightColor);
        gcValues.foreground = borderPtr->lightColorPtr->pixel;
        borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
        return;
    }

    if (borderPtr->shadow == None) {
        borderPtr->shadow = Tk_GetBitmap((Tcl_Interp *) NULL, tkwin,
                Tk_GetUid("gray50"));
        if (borderPtr->shadow == None) {
            panic("TkpGetShadows couldn't allocate bitmap for border");
        }
    }
    if (borderPtr->visual->map_entries > 2) {
        /*
         * This isn't a monochrome display, but the colormap either
         * ran out of entries or didn't have very many to begin with.
         * Generate the light shadows with a white stipple and the
         * dark shadows with a black stipple.
         */

        gcValues.foreground = borderPtr->bgColorPtr->pixel;
        gcValues.background = BlackPixelOfScreen(borderPtr->screen);
        gcValues.stipple = borderPtr->shadow;
        gcValues.fill_style = FillOpaqueStippled;
        borderPtr->darkGC = Tk_GetGC(tkwin,
                GCForeground|GCBackground|GCStipple|GCFillStyle, &gcValues);
        gcValues.foreground = WhitePixelOfScreen(borderPtr->screen);
        gcValues.background = borderPtr->bgColorPtr->pixel;
        borderPtr->lightGC = Tk_GetGC(tkwin,
                GCForeground|GCBackground|GCStipple|GCFillStyle, &gcValues);
        return;
    }

    /*
     * This is just a measly monochrome display, hardly even worth its
     * existence on this earth.  Make one shadow a 50% stipple and the
     * other the opposite of the background.
     */

    gcValues.foreground = WhitePixelOfScreen(borderPtr->screen);
    gcValues.background = BlackPixelOfScreen(borderPtr->screen);
    gcValues.stipple = borderPtr->shadow;
    gcValues.fill_style = FillOpaqueStippled;
    borderPtr->lightGC = Tk_GetGC(tkwin,
            GCForeground|GCBackground|GCStipple|GCFillStyle, &gcValues);
    if (borderPtr->bgColorPtr->pixel
            == WhitePixelOfScreen(borderPtr->screen)) {
        gcValues.foreground = BlackPixelOfScreen(borderPtr->screen);
        borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
    } else {
        borderPtr->darkGC = borderPtr->lightGC;
        borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TkWinGetBorderPixels --
 *
 *      This routine returns the 5 COLORREFs used to draw a given
 *      3d border.  
 *
 * Results:
 *      Returns the colors in the specified array.
 *
 * Side effects:
 *      May cause the remaining colors to be allocated.
 *
 *----------------------------------------------------------------------
 */

COLORREF
TkWinGetBorderPixels(tkwin, border, which)
    Tk_Window tkwin;
    Tk_3DBorder border;
    int which;                  /* One of TK_3D_FLAT_GC, TK_3D_LIGHT_GC,
                                 * TK_3D_DARK_GC, TK_3D_LIGHT2, TK_3D_DARK2 */
{
    WinBorder *borderPtr = (WinBorder *) border;
    
    if (borderPtr->info.lightGC == None) {
        TkpGetShadows(&borderPtr->info, tkwin);
    }
    switch (which) {
        case TK_3D_FLAT_GC:
            return borderPtr->info.bgColorPtr->pixel;
        case TK_3D_LIGHT_GC:
            if (borderPtr->info.lightColorPtr == NULL) {
                return WhitePixelOfScreen(borderPtr->info.screen);
            }
            return borderPtr->info.lightColorPtr->pixel;
        case TK_3D_DARK_GC:
            if (borderPtr->info.darkColorPtr == NULL) {
                return BlackPixelOfScreen(borderPtr->info.screen);
            }
            return borderPtr->info.darkColorPtr->pixel;
        case TK_3D_LIGHT2:
            return borderPtr->light2ColorPtr->pixel;
        case TK_3D_DARK2:
            return borderPtr->dark2ColorPtr->pixel;
    }
    return 0;
}

/* End of tkwin3d.c */
1	/* $Header$ */
2
3	/*
4	* tkWin3d.c --
5	*
6	* This file contains the platform specific routines for
7	* drawing 3d borders in the Windows 95 style.
8	*
9	* Copyright (c) 1996 by Sun Microsystems, Inc.
10	*
11	* See the file "license.terms" for information on usage and redistribution
12	* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13	*
14	* RCS: @(#) $Id: tkwin3d.c,v 1.1.1.1 2001/06/13 05:11:49 dtashley Exp $
15	*/
16
17	#include "tkWinInt.h"
18	#include "tk3d.h"
19
20	/*
21	* This structure is used to keep track of the extra colors used by
22	* Windows 3d borders.
23	*/
24
25	typedef struct {
26	TkBorder info;
27	XColor light2ColorPtr; / System3dLight */
28	XColor dark2ColorPtr; / System3dDarkShadow */
29	} WinBorder;
30
31
32	/*
33	*----------------------------------------------------------------------
34	*
35	* TkpGetBorder --
36	*
37	* This function allocates a new TkBorder structure.
38	*
39	* Results:
40	* Returns a newly allocated TkBorder.
41	*
42	* Side effects:
43	* None.
44	*
45	*----------------------------------------------------------------------
46	*/
47
48	TkBorder *
49	TkpGetBorder()
50	{
51	WinBorder borderPtr = (WinBorder ) ckalloc(sizeof(WinBorder));
52	borderPtr->light2ColorPtr = NULL;
53	borderPtr->dark2ColorPtr = NULL;
54	return (TkBorder *) borderPtr;
55	}
56
57	/*
58	*----------------------------------------------------------------------
59	*
60	* TkpFreeBorder --
61	*
62	* This function frees any colors allocated by the platform
63	* specific part of this module.
64	*
65	* Results:
66	* None.
67	*
68	* Side effects:
69	* May deallocate some colors.
70	*
71	*----------------------------------------------------------------------
72	*/
73
74	void
75	TkpFreeBorder(borderPtr)
76	TkBorder *borderPtr;
77	{
78	WinBorder winBorderPtr = (WinBorder ) borderPtr;
79	if (winBorderPtr->light2ColorPtr) {
80	Tk_FreeColor(winBorderPtr->light2ColorPtr);
81	}
82	if (winBorderPtr->dark2ColorPtr) {
83	Tk_FreeColor(winBorderPtr->dark2ColorPtr);
84	}
85	}
86
87	/*
88	*--------------------------------------------------------------
89	*
90	* Tk_3DVerticalBevel --
91	*
92	* This procedure draws a vertical bevel along one side of
93	* an object. The bevel is always rectangular in shape:
94	* \|\|\|
95	* \|\|\|
96	* \|\|\|
97	* \|\|\|
98	* \|\|\|
99	* \|\|\|
100	* An appropriate shadow color is chosen for the bevel based
101	* on the leftBevel and relief arguments. Normally this
102	* procedure is called first, then Tk_3DHorizontalBevel is
103	* called next to draw neat corners.
104	*
105	* Results:
106	* None.
107	*
108	* Side effects:
109	* Graphics are drawn in drawable.
110	*
111	*--------------------------------------------------------------
112	*/
113
114	void
115	Tk_3DVerticalBevel(tkwin, drawable, border, x, y, width, height,
116	leftBevel, relief)
117	Tk_Window tkwin; /* Window for which border was allocated. */
118	Drawable drawable; /* X window or pixmap in which to draw. */
119	Tk_3DBorder border; /* Token for border to draw. */
120	int x, y, width, height; /* Area of vertical bevel. */
121	int leftBevel; /* Non-zero means this bevel forms the
122	* left side of the object; 0 means it
123	* forms the right side. */
124	int relief; /* Kind of bevel to draw. For example,
125	* TK_RELIEF_RAISED means interior of
126	* object should appear higher than
127	* exterior. */
128	{
129	TkBorder borderPtr = (TkBorder ) border;
130	int left, right;
131	Display *display = Tk_Display(tkwin);
132	TkWinDCState state;
133	HDC dc = TkWinGetDrawableDC(display, drawable, &state);
134	int half;
135
136	if ((borderPtr->lightGC == None) && (relief != TK_RELIEF_FLAT)) {
137	TkpGetShadows(borderPtr, tkwin);
138	}
139
140	switch (relief) {
141	case TK_RELIEF_RAISED:
142	left = (leftBevel)
143	? borderPtr->lightGC->foreground
144	: borderPtr->darkGC->foreground;
145	right = (leftBevel)
146	? ((WinBorder *)borderPtr)->light2ColorPtr->pixel
147	: ((WinBorder *)borderPtr)->dark2ColorPtr->pixel;
148	break;
149	case TK_RELIEF_SUNKEN:
150	left = (leftBevel)
151	? ((WinBorder *)borderPtr)->dark2ColorPtr->pixel
152	: ((WinBorder *)borderPtr)->light2ColorPtr->pixel;
153	right = (leftBevel)
154	? borderPtr->darkGC->foreground
155	: borderPtr->lightGC->foreground;
156	break;
157	case TK_RELIEF_RIDGE:
158	left = borderPtr->lightGC->foreground;
159	right = borderPtr->darkGC->foreground;
160	break;
161	case TK_RELIEF_GROOVE:
162	left = borderPtr->darkGC->foreground;
163	right = borderPtr->lightGC->foreground;
164	break;
165	case TK_RELIEF_FLAT:
166	left = right = borderPtr->bgGC->foreground;
167	break;
168	case TK_RELIEF_SOLID:
169	left = right = RGB(0,0,0);
170	break;
171	}
172	half = width/2;
173	if (leftBevel && (width & 1)) {
174	half++;
175	}
176	TkWinFillRect(dc, x, y, half, height, left);
177	TkWinFillRect(dc, x+half, y, width-half, height, right);
178	TkWinReleaseDrawableDC(drawable, dc, &state);
179	}
180
181	/*
182	*--------------------------------------------------------------
183	*
184	* Tk_3DHorizontalBevel --
185	*
186	* This procedure draws a horizontal bevel along one side of
187	* an object. The bevel has mitered corners (depending on
188	* leftIn and rightIn arguments).
189	*
190	* Results:
191	* None.
192	*
193	* Side effects:
194	* None.
195	*
196	*--------------------------------------------------------------
197	*/
198
199	void
200	Tk_3DHorizontalBevel(tkwin, drawable, border, x, y, width, height,
201	leftIn, rightIn, topBevel, relief)
202	Tk_Window tkwin; /* Window for which border was allocated. */
203	Drawable drawable; /* X window or pixmap in which to draw. */
204	Tk_3DBorder border; /* Token for border to draw. */
205	int x, y, width, height; /* Bounding box of area of bevel. Height
206	* gives width of border. */
207	int leftIn, rightIn; /* Describes whether the left and right
208	* edges of the bevel angle in or out as
209	* they go down. For example, if "leftIn"
210	* is true, the left side of the bevel
211	* looks like this:
212	* ___________
213	* __________
214	* _________
215	* ________
216	*/
217	int topBevel; /* Non-zero means this bevel forms the
218	* top side of the object; 0 means it
219	* forms the bottom side. */
220	int relief; /* Kind of bevel to draw. For example,
221	* TK_RELIEF_RAISED means interior of
222	* object should appear higher than
223	* exterior. */
224	{
225	TkBorder borderPtr = (TkBorder ) border;
226	Display *display = Tk_Display(tkwin);
227	int bottom, halfway, x1, x2, x1Delta, x2Delta;
228	TkWinDCState state;
229	HDC dc = TkWinGetDrawableDC(display, drawable, &state);
230	int topColor, bottomColor;
231
232	if ((borderPtr->lightGC == None) && (relief != TK_RELIEF_FLAT)) {
233	TkpGetShadows(borderPtr, tkwin);
234	}
235
236	/*
237	* Compute a GC for the top half of the bevel and a GC for the
238	* bottom half (they're the same in many cases).
239	*/
240
241	switch (relief) {
242	case TK_RELIEF_RAISED:
243	topColor = (topBevel)
244	? borderPtr->lightGC->foreground
245	: borderPtr->darkGC->foreground;
246	bottomColor = (topBevel)
247	? ((WinBorder *)borderPtr)->light2ColorPtr->pixel
248	: ((WinBorder *)borderPtr)->dark2ColorPtr->pixel;
249	break;
250	case TK_RELIEF_SUNKEN:
251	topColor = (topBevel)
252	? ((WinBorder *)borderPtr)->dark2ColorPtr->pixel
253	: ((WinBorder *)borderPtr)->light2ColorPtr->pixel;
254	bottomColor = (topBevel)
255	? borderPtr->darkGC->foreground
256	: borderPtr->lightGC->foreground;
257	break;
258	case TK_RELIEF_RIDGE:
259	topColor = borderPtr->lightGC->foreground;
260	bottomColor = borderPtr->darkGC->foreground;
261	break;
262	case TK_RELIEF_GROOVE:
263	topColor = borderPtr->darkGC->foreground;
264	bottomColor = borderPtr->lightGC->foreground;
265	break;
266	case TK_RELIEF_FLAT:
267	topColor = bottomColor = borderPtr->bgGC->foreground;
268	break;
269	case TK_RELIEF_SOLID:
270	topColor = bottomColor = RGB(0,0,0);
271	}
272
273	/*
274	* Compute various other geometry-related stuff.
275	*/
276
277	if (leftIn) {
278	x1 = x+1;
279	} else {
280	x1 = x+height-1;
281	}
282	x2 = x+width;
283	if (rightIn) {
284	x2--;
285	} else {
286	x2 -= height;
287	}
288	x1Delta = (leftIn) ? 1 : -1;
289	x2Delta = (rightIn) ? -1 : 1;
290	halfway = y + height/2;
291	if (topBevel && (height & 1)) {
292	halfway++;
293	}
294	bottom = y + height;
295
296	/*
297	* Draw one line for each y-coordinate covered by the bevel.
298	*/
299
300	for ( ; y < bottom; y++) {
301	/*
302	* In some weird cases (such as large border widths for skinny
303	* rectangles) x1 can be >= x2. Don't draw the lines
304	* in these cases.
305	*/
306
307	if (x1 < x2) {
308	TkWinFillRect(dc, x1, y, x2-x1, 1,
309	(y < halfway) ? topColor : bottomColor);
310	}
311	x1 += x1Delta;
312	x2 += x2Delta;
313	}
314	TkWinReleaseDrawableDC(drawable, dc, &state);
315	}
316
317	/*
318	*----------------------------------------------------------------------
319	*
320	* TkpGetShadows --
321	*
322	* This procedure computes the shadow colors for a 3-D border
323	* and fills in the corresponding fields of the Border structure.
324	* It's called lazily, so that the colors aren't allocated until
325	* something is actually drawn with them. That way, if a border
326	* is only used for flat backgrounds the shadow colors will
327	* never be allocated.
328	*
329	* Results:
330	* None.
331	*
332	* Side effects:
333	* The lightGC and darkGC fields in borderPtr get filled in,
334	* if they weren't already.
335	*
336	*----------------------------------------------------------------------
337	*/
338
339	void
340	TkpGetShadows(borderPtr, tkwin)
341	TkBorder borderPtr; / Information about border. */
342	Tk_Window tkwin; /* Window where border will be used for
343	* drawing. */
344	{
345	XColor lightColor, darkColor;
346	int tmp1, tmp2;
347	int r, g, b;
348	XGCValues gcValues;
349
350	if (borderPtr->lightGC != None) {
351	return;
352	}
353
354	/*
355	* Handle the special case of the default system colors.
356	*/
357
358	if ((TkWinIndexOfColor(borderPtr->bgColorPtr) == COLOR_3DFACE)
359	\|\| (TkWinIndexOfColor(borderPtr->bgColorPtr) == COLOR_WINDOW)) {
360	borderPtr->darkColorPtr = Tk_GetColor(NULL, tkwin,
361	Tk_GetUid("SystemButtonShadow"));
362	gcValues.foreground = borderPtr->darkColorPtr->pixel;
363	borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
364	borderPtr->lightColorPtr = Tk_GetColor(NULL, tkwin,
365	Tk_GetUid("SystemButtonHighlight"));
366	gcValues.foreground = borderPtr->lightColorPtr->pixel;
367	borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
368	((WinBorder*)borderPtr)->dark2ColorPtr = Tk_GetColor(NULL, tkwin,
369	Tk_GetUid("System3dDarkShadow"));
370	((WinBorder*)borderPtr)->light2ColorPtr = Tk_GetColor(NULL, tkwin,
371	Tk_GetUid("System3dLight"));
372	return;
373	} else {
374	darkColor.red = 0;
375	darkColor.green = 0;
376	darkColor.blue = 0;
377	((WinBorder*)borderPtr)->dark2ColorPtr = Tk_GetColorByValue(tkwin,
378	&darkColor);
379	lightColor = *(borderPtr->bgColorPtr);
380	((WinBorder*)borderPtr)->light2ColorPtr = Tk_GetColorByValue(tkwin,
381	&lightColor);
382	}
383
384	/*
385	* First, handle the case of a color display with lots of colors.
386	* The shadow colors get computed using whichever formula results
387	* in the greatest change in color:
388	* 1. Lighter shadow is half-way to white, darker shadow is half
389	* way to dark.
390	* 2. Lighter shadow is 40% brighter than background, darker shadow
391	* is 40% darker than background.
392	*/
393
394	if (Tk_Depth(tkwin) >= 6) {
395	/*
396	* This is a color display with lots of colors. For the dark
397	* shadow, cut 40% from each of the background color components.
398	* But if the background is already very dark, make the
399	* dark color a little lighter than the background by increasing
400	* each color component 1/4th of the way to MAX_INTENSITY.
401	*
402	* For the light shadow, boost each component by 40% or half-way
403	* to white, whichever is greater (the first approach works
404	* better for unsaturated colors, the second for saturated ones).
405	* But if the background is already very bright, instead choose a
406	* slightly darker color for the light shadow by reducing each
407	* color component by 10%.
408	*
409	* Compute the colors using integers, not using lightColor.red
410	* etc.: these are shorts and may have problems with integer
411	* overflow.
412	*/
413
414	/*
415	* Compute the dark shadow color
416	*/
417
418	r = (int) borderPtr->bgColorPtr->red;
419	g = (int) borderPtr->bgColorPtr->green;
420	b = (int) borderPtr->bgColorPtr->blue;
421
422	if (r0.5r + g1.0g + b0.28b < MAX_INTENSITY0.05MAX_INTENSITY) {
423	darkColor.red = (MAX_INTENSITY + 3*r)/4;
424	darkColor.green = (MAX_INTENSITY + 3*g)/4;
425	darkColor.blue = (MAX_INTENSITY + 3*b)/4;
426	} else {
427	darkColor.red = (60 * r)/100;
428	darkColor.green = (60 * g)/100;
429	darkColor.blue = (60 * b)/100;
430	}
431
432	/*
433	* Allocate the dark shadow color and its GC
434	*/
435
436	borderPtr->darkColorPtr = Tk_GetColorByValue(tkwin, &darkColor);
437	gcValues.foreground = borderPtr->darkColorPtr->pixel;
438	borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
439
440	/*
441	* Compute the light shadow color
442	*/
443
444	if (g > MAX_INTENSITY*0.95) {
445	lightColor.red = (90 * r)/100;
446	lightColor.green = (90 * g)/100;
447	lightColor.blue = (90 * b)/100;
448	} else {
449	tmp1 = (14 * r)/10;
450	if (tmp1 > MAX_INTENSITY) {
451	tmp1 = MAX_INTENSITY;
452	}
453	tmp2 = (MAX_INTENSITY + r)/2;
454	lightColor.red = (tmp1 > tmp2) ? tmp1 : tmp2;
455	tmp1 = (14 * g)/10;
456	if (tmp1 > MAX_INTENSITY) {
457	tmp1 = MAX_INTENSITY;
458	}
459	tmp2 = (MAX_INTENSITY + g)/2;
460	lightColor.green = (tmp1 > tmp2) ? tmp1 : tmp2;
461	tmp1 = (14 * b)/10;
462	if (tmp1 > MAX_INTENSITY) {
463	tmp1 = MAX_INTENSITY;
464	}
465	tmp2 = (MAX_INTENSITY + b)/2;
466	lightColor.blue = (tmp1 > tmp2) ? tmp1 : tmp2;
467	}
468
469	/*
470	* Allocate the light shadow color and its GC
471	*/
472
473	borderPtr->lightColorPtr = Tk_GetColorByValue(tkwin, &lightColor);
474	gcValues.foreground = borderPtr->lightColorPtr->pixel;
475	borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
476	return;
477	}
478
479	if (borderPtr->shadow == None) {
480	borderPtr->shadow = Tk_GetBitmap((Tcl_Interp *) NULL, tkwin,
481	Tk_GetUid("gray50"));
482	if (borderPtr->shadow == None) {
483	panic("TkpGetShadows couldn't allocate bitmap for border");
484	}
485	}
486	if (borderPtr->visual->map_entries > 2) {
487	/*
488	* This isn't a monochrome display, but the colormap either
489	* ran out of entries or didn't have very many to begin with.
490	* Generate the light shadows with a white stipple and the
491	* dark shadows with a black stipple.
492	*/
493
494	gcValues.foreground = borderPtr->bgColorPtr->pixel;
495	gcValues.background = BlackPixelOfScreen(borderPtr->screen);
496	gcValues.stipple = borderPtr->shadow;
497	gcValues.fill_style = FillOpaqueStippled;
498	borderPtr->darkGC = Tk_GetGC(tkwin,
499	GCForeground\|GCBackground\|GCStipple\|GCFillStyle, &gcValues);
500	gcValues.foreground = WhitePixelOfScreen(borderPtr->screen);
501	gcValues.background = borderPtr->bgColorPtr->pixel;
502	borderPtr->lightGC = Tk_GetGC(tkwin,
503	GCForeground\|GCBackground\|GCStipple\|GCFillStyle, &gcValues);
504	return;
505	}
506
507	/*
508	* This is just a measly monochrome display, hardly even worth its
509	* existence on this earth. Make one shadow a 50% stipple and the
510	* other the opposite of the background.
511	*/
512
513	gcValues.foreground = WhitePixelOfScreen(borderPtr->screen);
514	gcValues.background = BlackPixelOfScreen(borderPtr->screen);
515	gcValues.stipple = borderPtr->shadow;
516	gcValues.fill_style = FillOpaqueStippled;
517	borderPtr->lightGC = Tk_GetGC(tkwin,
518	GCForeground\|GCBackground\|GCStipple\|GCFillStyle, &gcValues);
519	if (borderPtr->bgColorPtr->pixel
520	== WhitePixelOfScreen(borderPtr->screen)) {
521	gcValues.foreground = BlackPixelOfScreen(borderPtr->screen);
522	borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
523	} else {
524	borderPtr->darkGC = borderPtr->lightGC;
525	borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
526	}
527	}
528
529	/*
530	*----------------------------------------------------------------------
531	*
532	* TkWinGetBorderPixels --
533	*
534	* This routine returns the 5 COLORREFs used to draw a given
535	* 3d border.
536	*
537	* Results:
538	* Returns the colors in the specified array.
539	*
540	* Side effects:
541	* May cause the remaining colors to be allocated.
542	*
543	*----------------------------------------------------------------------
544	*/
545
546	COLORREF
547	TkWinGetBorderPixels(tkwin, border, which)
548	Tk_Window tkwin;
549	Tk_3DBorder border;
550	int which; /* One of TK_3D_FLAT_GC, TK_3D_LIGHT_GC,
551	* TK_3D_DARK_GC, TK_3D_LIGHT2, TK_3D_DARK2 */
552	{
553	WinBorder borderPtr = (WinBorder ) border;
554
555	if (borderPtr->info.lightGC == None) {
556	TkpGetShadows(&borderPtr->info, tkwin);
557	}
558	switch (which) {
559	case TK_3D_FLAT_GC:
560	return borderPtr->info.bgColorPtr->pixel;
561	case TK_3D_LIGHT_GC:
562	if (borderPtr->info.lightColorPtr == NULL) {
563	return WhitePixelOfScreen(borderPtr->info.screen);
564	}
565	return borderPtr->info.lightColorPtr->pixel;
566	case TK_3D_DARK_GC:
567	if (borderPtr->info.darkColorPtr == NULL) {
568	return BlackPixelOfScreen(borderPtr->info.screen);
569	}
570	return borderPtr->info.darkColorPtr->pixel;
571	case TK_3D_LIGHT2:
572	return borderPtr->light2ColorPtr->pixel;
573	case TK_3D_DARK2:
574	return borderPtr->dark2ColorPtr->pixel;
575	}
576	return 0;
577	}
578
579	/* End of tkwin3d.c */