shared_source/tk_base/tkwin3d.c

/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/tkwin3d.c,v 1.1.1.1 2001/06/13 05:11:49 dtashley Exp $ */

/* 
 * 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;
}


/* $History: tkWin3d.c $
 * 
 * *****************  Version 1  *****************
 * User: Dtashley     Date: 1/02/01    Time: 3:11a
 * Created in $/IjuScripter, IjuConsole/Source/Tk Base
 * Initial check-in.
 */

/* End of TKWIN3D.C */
1	dashley	25	/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/tkwin3d.c,v 1.1.1.1 2001/06/13 05:11:49 dtashley Exp $ */
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
580			/* $History: tkWin3d.c $
581			*
582			* *************** Version 1 ***************
583			* User: Dtashley Date: 1/02/01 Time: 3:11a
584			* Created in $/IjuScripter, IjuConsole/Source/Tk Base
585			* Initial check-in.
586			*/
587
588			/* End of TKWIN3D.C */