windows/syscolor.c

   1 /*
   2  * Support for system colors
   3  *
   4  * Copyright  David W. Metcalfe, 1993
   5  * Copyright  Alexandre Julliard, 1994
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "wine/winbase16.h"
  31 #include "wine/winuser16.h"
  32 #include "winuser.h"
  33 #include "wownt32.h"
  34 #include "winreg.h"
  35 #include "local.h"
  36 #include "user.h"
  37 #include "gdi.h" /* sic */
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(syscolor);
  41
  42 static const char * const DefSysColors[] =
  43 {
  44     "Scrollbar", "192 192 192",      /* COLOR_SCROLLBAR           */
  45     "Background", "0 128 128",       /* COLOR_BACKGROUND          */
  46     "ActiveTitle", "0 0 128",        /* COLOR_ACTIVECAPTION       */
  47     "InactiveTitle", "128 128 128",  /* COLOR_INACTIVECAPTION     */
  48     "Menu", "192 192 192",           /* COLOR_MENU                */
  49     "Window", "255 255 255",         /* COLOR_WINDOW              */
  50     "WindowFrame", "0 0 0",          /* COLOR_WINDOWFRAME         */
  51     "MenuText", "0 0 0",             /* COLOR_MENUTEXT            */
  52     "WindowText", "0 0 0",           /* COLOR_WINDOWTEXT          */
  53     "TitleText", "255 255 255",      /* COLOR_CAPTIONTEXT         */
  54     "ActiveBorder", "192 192 192",   /* COLOR_ACTIVEBORDER        */
  55     "InactiveBorder", "192 192 192", /* COLOR_INACTIVEBORDER      */
  56     "AppWorkSpace", "128 128 128",   /* COLOR_APPWORKSPACE        */
  57     "Hilight", "0 0 128",            /* COLOR_HIGHLIGHT           */
  58     "HilightText", "255 255 255",    /* COLOR_HIGHLIGHTTEXT       */
  59     "ButtonFace", "192 192 192",     /* COLOR_BTNFACE             */
  60     "ButtonShadow", "128 128 128",   /* COLOR_BTNSHADOW           */
  61     "GrayText", "128 128 128",       /* COLOR_GRAYTEXT            */
  62     "ButtonText", "0 0 0",           /* COLOR_BTNTEXT             */
  63     "InactiveTitleText", "192 192 192",/* COLOR_INACTIVECAPTIONTEXT */
  64     "ButtonHilight", "255 255 255",  /* COLOR_BTNHIGHLIGHT        */
  65     "ButtonDkShadow", "0 0 0",       /* COLOR_3DDKSHADOW          */
  66     "ButtonLight", "224 224 224",    /* COLOR_3DLIGHT             */
  67     "InfoText", "0 0 0",             /* COLOR_INFOTEXT            */
  68     "InfoWindow", "255 255 225",     /* COLOR_INFOBK              */
  69     "ButtonAlternateFace", "180 180 180",  /* COLOR_ALTERNATEBTNFACE */
  70     "HotTrackingColor", "0 0 255",         /* COLOR_HOTLIGHT */
  71     "GradientActiveTitle", "16 132 208",   /* COLOR_GRADIENTACTIVECAPTION */
  72     "GradientInactiveTitle", "181 181 181",/* COLOR_GRADIENTINACTIVECAPTION */
  73     "MenuHilight", "0 0 0",          /* COLOR_MENUHILIGHT         */
  74     "MenuBar", "192 192 192"         /* COLOR_MENUBAR             */
  75 };
  76
  77
  78 #define NUM_SYS_COLORS     (COLOR_MENUBAR+1)
  79
  80 static COLORREF SysColors[NUM_SYS_COLORS];
  81 static HBRUSH SysColorBrushes[NUM_SYS_COLORS];
  82 static HPEN   SysColorPens[NUM_SYS_COLORS];
  83
  84
  85 /*************************************************************************
  86  * SYSCOLOR_MakeObjectSystem
  87  *
  88  * OK, now for a very ugly hack.
  89  * USER somehow has to tell GDI that its system brushes and pens are
  90  * non-deletable.
  91  * We don't want to export a function from GDI doing this for us,
  92  * so we just do that ourselves by "wildly flipping some bits in memory".
  93  * For a description of the GDI object magics and their flags,
  94  * see "Undocumented Windows" (wrong about the OBJECT_NOSYSTEM flag, though).
  95  */
  96 static void SYSCOLOR_MakeObjectSystem( HGDIOBJ16 handle, BOOL set)
  97 {
  98     static WORD heap_sel = 0;
  99     LPWORD ptr;
 100
 101     if (!heap_sel) heap_sel = LoadLibrary16( "gdi" );
 102     if (heap_sel >= 32)
 103     {
 104         ptr = (LPWORD)LOCAL_Lock(heap_sel, handle);
 105
 106         /* touch the "system" bit of the wMagic field of a GDIOBJHDR */
 107         if (set)
 108             *(ptr+1) &= ~OBJECT_NOSYSTEM;
 109         else
 110             *(ptr+1) |= OBJECT_NOSYSTEM;
 111         LOCAL_Unlock( heap_sel, handle );
 112     }
 113 }
 114
 115 /*************************************************************************
 116  *             SYSCOLOR_SetColor
 117  */
 118 static void SYSCOLOR_SetColor( int index, COLORREF color )
 119 {
 120     if (index < 0 || index >= NUM_SYS_COLORS) return;
 121     SysColors[index] = color;
 122     if (SysColorBrushes[index])
 123     {
 124         SYSCOLOR_MakeObjectSystem( HBRUSH_16(SysColorBrushes[index]), FALSE);
 125         DeleteObject( SysColorBrushes[index] );
 126     }
 127     SysColorBrushes[index] = CreateSolidBrush( color );
 128     SYSCOLOR_MakeObjectSystem( HBRUSH_16(SysColorBrushes[index]), TRUE);
 129
 130     if (SysColorPens[index])
 131     {
 132         SYSCOLOR_MakeObjectSystem( HPEN_16(SysColorPens[index]), FALSE);
 133         DeleteObject( SysColorPens[index] );
 134     }
 135     SysColorPens[index] = CreatePen( PS_SOLID, 1, color );
 136     SYSCOLOR_MakeObjectSystem( HPEN_16(SysColorPens[index]), TRUE);
 137 }
 138
 139
 140 /*************************************************************************
 141  *             SYSCOLOR_Init
 142  */
 143 void SYSCOLOR_Init(void)
 144 {
 145     int i, r, g, b;
 146     char buffer[100];
 147     BOOL bOk = FALSE, bNoReg = FALSE;
 148     HKEY  hKey;
 149
 150     /* first, try to read the values from the registry */
 151     if (RegCreateKeyExA(HKEY_CURRENT_USER, "Control Panel\\Colors", 0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
 152       bNoReg = TRUE;
 153     for (i = 0; i < NUM_SYS_COLORS; i++)
 154     { bOk = FALSE;
 155
 156       /* first try, registry */
 157       if (!bNoReg)
 158       {
 159         DWORD dwDataSize = sizeof(buffer);
 160         if (!(RegQueryValueExA(hKey,(LPSTR)DefSysColors[i*2], 0, 0, buffer, &dwDataSize)))
 161           if (sscanf( buffer, "%d %d %d", &r, &g, &b ) == 3)
 162             bOk = TRUE;
 163       }
 164
 165       /* second try, win.ini */
 166       if (!bOk)
 167       { GetProfileStringA( "colors", DefSysColors[i*2], DefSysColors[i*2+1], buffer, 100 );
 168         if (sscanf( buffer, " %d %d %d", &r, &g, &b ) == 3)
 169           bOk = TRUE;
 170       }
 171
 172       /* last chance, take the default */
 173       if (!bOk)
 174       { int iNumColors = sscanf( DefSysColors[i*2+1], " %d %d %d", &r, &g, &b );
 175         assert (iNumColors==3);
 176       }
 177
 178       SYSCOLOR_SetColor( i, RGB(r,g,b) );
 179     }
 180     if (!bNoReg)
 181       RegCloseKey(hKey);
 182 }
 183
 184
 185 /*************************************************************************
 186  *              GetSysColor (USER.180)
 187  */
 188 COLORREF WINAPI GetSysColor16( INT16 nIndex )
 189 {
 190     return GetSysColor (nIndex);
 191 }
 192
 193
 194 /*************************************************************************
 195  *              GetSysColor (USER32.@)
 196  */
 197 COLORREF WINAPI GetSysColor( INT nIndex )
 198 {
 199     if (nIndex >= 0 && nIndex < NUM_SYS_COLORS)
 200         return SysColors[nIndex];
 201     else
 202         return 0;
 203 }
 204
 205
 206 /*************************************************************************
 207  *              SetSysColors (USER.181)
 208  */
 209 VOID WINAPI SetSysColors16( INT16 nChanges, const INT16 *lpSysColor,
 210                             const COLORREF *lpColorValues )
 211 {
 212     int i;
 213
 214     for (i = 0; i < nChanges; i++)
 215     {
 216         SYSCOLOR_SetColor( lpSysColor[i], lpColorValues[i] );
 217     }
 218
 219     /* Send WM_SYSCOLORCHANGE message to all windows */
 220
 221     SendMessageTimeoutW( HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0,
 222                          SMTO_ABORTIFHUNG, 2000, NULL );
 223
 224     /* Repaint affected portions of all visible windows */
 225
 226     RedrawWindow( GetDesktopWindow(), NULL, 0,
 227                 RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN );
 228 }
 229
 230
 231 /*************************************************************************
 232  *              SetSysColors (USER32.@)
 233  */
 234 BOOL WINAPI SetSysColors( INT nChanges, const INT *lpSysColor,
 235                               const COLORREF *lpColorValues )
 236 {
 237     int i;
 238
 239     for (i = 0; i < nChanges; i++)
 240     {
 241         SYSCOLOR_SetColor( lpSysColor[i], lpColorValues[i] );
 242     }
 243
 244     /* Send WM_SYSCOLORCHANGE message to all windows */
 245
 246     SendMessageTimeoutW( HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0,
 247                          SMTO_ABORTIFHUNG, 2000, NULL );
 248
 249     /* Repaint affected portions of all visible windows */
 250
 251     RedrawWindow( GetDesktopWindow(), NULL, 0,
 252                 RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN );
 253     return TRUE;
 254 }
 255
 256 /*************************************************************************
 257  *              SetSysColorsTemp (USER32.@)
 258  *
 259  * UNDOCUMENTED !!
 260  *
 261  * Called by W98SE desk.cpl Control Panel Applet:
 262  * handle = SetSysColorsTemp(ptr, ptr, nCount);     ("set" call)
 263  * result = SetSysColorsTemp(NULL, NULL, handle);   ("restore" call)
 264  *
 265  * pPens is an array of COLORREF values, which seems to be used
 266  * to indicate the color values to create new pens with.
 267  *
 268  * pBrushes is an array of solid brush handles (returned by a previous
 269  * CreateSolidBrush), which seems to contain the brush handles to set
 270  * for the system colors.
 271  *
 272  * n seems to be used for
 273  *   a) indicating the number of entries to operate on (length of pPens,
 274  *      pBrushes)
 275  *   b) passing the handle that points to the previously used color settings.
 276  *      I couldn't figure out in hell what kind of handle this is on
 277  *      Windows. I just use a heap handle instead. Shouldn't matter anyway.
 278  *
 279  * RETURNS
 280  *     heap handle of our own copy of the current syscolors in case of
 281  *                 "set" call, i.e. pPens, pBrushes != NULL.
 282  *     TRUE (unconditionally !) in case of "restore" call,
 283  *          i.e. pPens, pBrushes == NULL.
 284  *     FALSE in case of either pPens != NULL and pBrushes == NULL
 285  *          or pPens == NULL and pBrushes != NULL.
 286  *
 287  * I'm not sure whether this implementation is 100% correct. [AM]
 288  */
 289 DWORD WINAPI SetSysColorsTemp( const COLORREF *pPens, const HBRUSH *pBrushes, DWORD n)
 290 {
 291         int i;
 292
 293         if (pPens && pBrushes) /* "set" call */
 294         {
 295             /* allocate our structure to remember old colors */
 296             LPVOID pOldCol = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)+n*sizeof(HPEN)+n*sizeof(HBRUSH));
 297             LPVOID p = pOldCol;
 298            *(DWORD *)p = n; p = (char*)p + sizeof(DWORD);
 299            memcpy(p, SysColorPens, n*sizeof(HPEN)); p = (char*)p + n*sizeof(HPEN);
 300            memcpy(p, SysColorBrushes, n*sizeof(HBRUSH)); p = (char*)p + n*sizeof(HBRUSH);
 301
 302             for (i=0; i < n; i++)
 303             {
 304                 SysColorPens[i] = CreatePen( PS_SOLID, 1, pPens[i] );
 305                 SysColorBrushes[i] = pBrushes[i];
 306             }
 307
 308             return (DWORD)pOldCol;
 309         }
 310         if ((!pPens) && (!pBrushes)) /* "restore" call */
 311         {
 312             LPVOID pOldCol = (LPVOID)n;
 313             LPVOID p = pOldCol;
 314             DWORD nCount = *(DWORD *)p;
 315            p = (char*)p + sizeof(DWORD);
 316
 317             for (i=0; i < nCount; i++)
 318             {
 319                 DeleteObject(SysColorPens[i]);
 320                SysColorPens[i] = *(HPEN *)p; p = (char*)p + sizeof(HPEN);
 321             }
 322             for (i=0; i < nCount; i++)
 323             {
 324                SysColorBrushes[i] = *(HBRUSH *)p; p = (char*)p + sizeof(HBRUSH);
 325             }
 326             /* get rid of storage structure */
 327             HeapFree(GetProcessHeap(), 0, pOldCol);
 328
 329             return TRUE;
 330         }
 331         return FALSE;
 332 }
 333
 334 /***********************************************************************
 335  *              GetSysColorBrush (USER32.@)
 336  */
 337 HBRUSH WINAPI GetSysColorBrush( INT index )
 338 {
 339     if (0 <= index && index < NUM_SYS_COLORS)
 340         return SysColorBrushes[index];
 341     WARN("Unknown index(%d)\n", index );
 342     return GetStockObject(LTGRAY_BRUSH);
 343 }
 344
 345
 346 /***********************************************************************
 347  *              SYSCOLOR_GetPen
 348  */
 349 HPEN SYSCOLOR_GetPen( INT index )
 350 {
 351     /* We can assert here, because this function is internal to Wine */
 352     assert (0 <= index && index < NUM_SYS_COLORS);
 353     return SysColorPens[index];
 354
 355 }