/* * 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 2007/07/10 15:05:18 duncan 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; }