objects/palette.c

   1 /*
   2  * GDI palette objects
   3  *
   4  * Copyright 1993,1994 Alexandre Julliard
   5  * Copyright 1996 Alex Korobka
   6  *
   7  */
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <X11/Xlib.h>
  11
  12 #include "color.h"
  13 #include "palette.h"
  14 #include "stddebug.h"
  15 /* #define DEBUG_PALETTE */
  16 #include "debug.h"
  17
  18 extern HWND             DCE_hDC2hWnd( HDC );                    /* get associated window by
  19                                                                  * walking DCE list */
  20
  21 static WORD SystemPaletteUse = SYSPAL_STATIC;   /* currently not considered */
  22
  23 static HPALETTE16 hPrimaryPalette = 0; /* used for WM_PALETTECHANGED */
  24 static HPALETTE16 hLastRealizedPalette = 0; /* UnrealizeObject() needs it */
  25
  26
  27 /***********************************************************************
  28  *           PALETTE_GetNearestIndexAndColor
  29  */
  30 static WORD PALETTE_GetNearestIndexAndColor( HPALETTE16 hpalette,
  31                                              COLORREF *color)
  32 {
  33     int i, minDist, dist;
  34     WORD index = 0;
  35     BYTE r, g, b;
  36     PALETTEENTRY * entry;
  37     PALETTEOBJ * palPtr;
  38
  39     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
  40     if (!palPtr) return 0;
  41
  42     if ( hpalette == STOCK_DEFAULT_PALETTE )
  43     {
  44         if ((*color & 0xffffff) == 0) return 0;  /* Entry 0 is black */
  45         if ((*color & 0xffffff) == 0xffffff)     /* Max entry is white */
  46             return palPtr->logpalette.palNumEntries - 1;
  47     }
  48
  49     r = GetRValue(*color);
  50     g = GetGValue(*color);
  51     b = GetBValue(*color);
  52
  53     entry = palPtr->logpalette.palPalEntry;
  54     for (i = 0, minDist = 0xffffff; minDist !=0 &&
  55          i < palPtr->logpalette.palNumEntries ; i++)
  56     {
  57         if (entry->peFlags != 0xff)
  58         {
  59             dist = (r - entry->peRed) * (r - entry->peRed) +
  60                    (g - entry->peGreen) * (g - entry->peGreen) +
  61                    (b - entry->peBlue) * (b - entry->peBlue);
  62             if (dist < minDist)
  63             {
  64                 minDist = dist;
  65                 index = i;
  66             }
  67         }
  68         entry++;
  69     }
  70
  71     entry = &palPtr->logpalette.palPalEntry[index];
  72     *color = RGB( entry->peRed, entry->peGreen, entry->peBlue );
  73     return index;
  74 }
  75
  76
  77 /***********************************************************************
  78  *           PALETTE_ValidateFlags
  79  */
  80 void PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, int size)
  81 {
  82     int i = 0;
  83     for( ; i<size ; i++ )
  84         lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
  85 }
  86
  87
  88 /***********************************************************************
  89  *           CreatePalette    (GDI.360)
  90  */
  91 HPALETTE16 CreatePalette( const LOGPALETTE* palette )
  92 {
  93     PALETTEOBJ * palettePtr;
  94     HPALETTE16 hpalette;
  95     int size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
  96
  97     dprintf_palette(stddeb,"CreatePalette: ");
  98
  99     dprintf_palette(stddeb,"%i entries, ", palette->palNumEntries);
 100
 101     hpalette = GDI_AllocObject( size + sizeof(int*) +sizeof(GDIOBJHDR) , PALETTE_MAGIC );
 102     if (!hpalette) return 0;
 103
 104     palettePtr = (PALETTEOBJ *) GDI_HEAP_LIN_ADDR( hpalette );
 105     memcpy( &palettePtr->logpalette, palette, size );
 106     PALETTE_ValidateFlags(palettePtr->logpalette.palPalEntry,
 107                           palettePtr->logpalette.palNumEntries);
 108     palettePtr->mapping = NULL;
 109
 110     dprintf_palette(stddeb,"returning %04x\n", hpalette);
 111     return hpalette;
 112 }
 113
 114
 115 /***********************************************************************
 116  *           GetPaletteEntries    (GDI.363)
 117  */
 118 WORD GetPaletteEntries( HPALETTE16 hpalette, WORD start, WORD count,
 119                         LPPALETTEENTRY entries )
 120 {
 121     PALETTEOBJ * palPtr;
 122     int numEntries;
 123
 124     dprintf_palette(stddeb,"GetPaletteEntries: hpal = %04x, %i entries\n", hpalette, count);
 125
 126     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 127     if (!palPtr) return 0;
 128
 129     numEntries = palPtr->logpalette.palNumEntries;
 130     if (start >= numEntries) return 0;
 131     if (start+count > numEntries) count = numEntries - start;
 132     memcpy( entries, &palPtr->logpalette.palPalEntry[start],
 133             count * sizeof(PALETTEENTRY) );
 134     for( numEntries = 0; numEntries < count ; numEntries++ )
 135          if( entries[numEntries].peFlags & 0xF0 ) entries[numEntries].peFlags = 0;
 136     return count;
 137 }
 138
 139
 140 /***********************************************************************
 141  *           SetPaletteEntries    (GDI.364)
 142  */
 143 WORD SetPaletteEntries( HPALETTE16 hpalette, WORD start, WORD count,
 144                         LPPALETTEENTRY entries )
 145 {
 146     PALETTEOBJ * palPtr;
 147     int numEntries;
 148
 149     dprintf_palette(stddeb,"SetPaletteEntries: hpal = %04x, %i entries\n", hpalette, count);
 150
 151     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 152     if (!palPtr) return 0;
 153
 154     numEntries = palPtr->logpalette.palNumEntries;
 155     if (start >= numEntries) return 0;
 156     if (start+count > numEntries) count = numEntries - start;
 157     memcpy( &palPtr->logpalette.palPalEntry[start], entries,
 158             count * sizeof(PALETTEENTRY) );
 159     PALETTE_ValidateFlags(palPtr->logpalette.palPalEntry,
 160                           palPtr->logpalette.palNumEntries);
 161     return count;
 162 }
 163
 164 /***********************************************************************
 165  *           ResizePalette          (GDI.368)
 166  */
 167 BOOL ResizePalette(HPALETTE16 hPal, UINT cEntries)
 168 {
 169
 170     /* should simply realloc memory and zero out
 171      * added entries, if any */
 172
 173     fprintf(stdnimp,"ResizePalette: empty stub! \n");
 174     return FALSE;
 175 }
 176
 177 /***********************************************************************
 178  *           AnimatePalette          (GDI.367)
 179  */
 180 BOOL AnimatePalette(HPALETTE16 hPal, UINT StartIndex, UINT NumEntries,
 181                     LPPALETTEENTRY PaletteColors)
 182 {
 183     fprintf(stdnimp,"AnimatePalette: empty stub! \n");
 184     return TRUE;
 185 }
 186
 187 /***********************************************************************
 188  *           SetSystemPaletteUse    (GDI.373)
 189  */
 190 WORD SetSystemPaletteUse( HDC hdc, WORD use)
 191 {
 192          WORD old=SystemPaletteUse;
 193          fprintf(stdnimp,"SetSystemPaletteUse(%04x,%04x) // empty stub !!!\n", hdc, use);
 194          SystemPaletteUse=use;
 195          return old;
 196 }
 197
 198 /***********************************************************************
 199  *           GetSystemPaletteUse    (GDI.374)
 200  */
 201 WORD GetSystemPaletteUse( HDC hdc )
 202 {
 203         fprintf(stdnimp,"GetSystemPaletteUse(%04x) // empty stub !!!\n", hdc);
 204         return SystemPaletteUse;
 205 }
 206
 207
 208 /***********************************************************************
 209  *           GetSystemPaletteEntries    (GDI.375)
 210  */
 211 WORD GetSystemPaletteEntries( HDC hdc, WORD start, WORD count,
 212                               LPPALETTEENTRY entries )
 213 {
 214     WORD i;
 215     DC *dc;
 216     XColor color;
 217
 218     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 219     if (start >= dc->w.devCaps->sizePalette) return 0;
 220     if (start+count >= dc->w.devCaps->sizePalette)
 221         count = dc->w.devCaps->sizePalette - start;
 222     for (i = 0; i < count; i++)
 223     {
 224         color.pixel = (COLOR_PaletteToPixel)
 225                       ? COLOR_PaletteToPixel[start + i]
 226                       : start + i;
 227         XQueryColor( display, COLOR_GetColormap(), &color );
 228         entries[i].peRed   = color.red >> 8;
 229         entries[i].peGreen = color.green >> 8;
 230         entries[i].peBlue  = color.blue >> 8;
 231         entries[i].peFlags = 0;
 232     }
 233     return count;
 234 }
 235
 236
 237 /***********************************************************************
 238  *           GetNearestPaletteIndex    (GDI.370)
 239  */
 240 WORD GetNearestPaletteIndex( HPALETTE16 hpalette, COLORREF color )
 241 {
 242     WORD index = PALETTE_GetNearestIndexAndColor( hpalette, &color );
 243     dprintf_palette(stddeb,"GetNearestPaletteIndex(%04x,%06lx): returning %d\n",
 244                     hpalette, color, index );
 245     return index;
 246 }
 247
 248
 249 /***********************************************************************
 250  *           GetNearestColor    (GDI.154)
 251  */
 252 COLORREF GetNearestColor( HDC hdc, COLORREF color )
 253 {
 254     COLORREF nearest = color;
 255     DC *dc;
 256
 257     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 258     PALETTE_GetNearestIndexAndColor( dc->w.hPalette, &nearest );
 259     dprintf_palette(stddeb,"GetNearestColor(%06lx): returning %06lx\n",
 260                     color, nearest );
 261     return nearest;
 262 }
 263
 264
 265 /***********************************************************************
 266  *           PALETTE_GetObject
 267  */
 268 int PALETTE_GetObject( PALETTEOBJ * palette, int count, LPSTR buffer )
 269 {
 270     if (count > sizeof(WORD)) count = sizeof(WORD);
 271     memcpy( buffer, &palette->logpalette.palNumEntries, count );
 272     return count;
 273 }
 274
 275
 276 /***********************************************************************
 277  *           PALETTE_UnrealizeObject
 278  */
 279 BOOL PALETTE_UnrealizeObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 280 {
 281     if (palette->mapping)
 282     {
 283         free( palette->mapping );
 284         palette->mapping = NULL;
 285     }
 286     if (hLastRealizedPalette == hpalette) hLastRealizedPalette = 0;
 287     return TRUE;
 288 }
 289
 290
 291 /***********************************************************************
 292  *           PALETTE_DeleteObject
 293  */
 294 BOOL PALETTE_DeleteObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 295 {
 296     free( palette->mapping );
 297     return GDI_FreeObject( hpalette );
 298 }
 299
 300
 301 /***********************************************************************
 302  *           GDISelectPalette    (GDI.361)
 303  */
 304 HPALETTE16 GDISelectPalette( HDC hdc, HPALETTE16 hpal, WORD wBkg)
 305 {
 306     HPALETTE16 prev;
 307     DC *dc;
 308
 309     dprintf_palette(stddeb, "GDISelectPalette: %04x %04x\n", hdc, hpal );
 310     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 311     prev = dc->w.hPalette;
 312     dc->w.hPalette = hpal;
 313     if (!wBkg) hPrimaryPalette = hpal;
 314     return prev;
 315 }
 316
 317
 318 /***********************************************************************
 319  *           GDIRealizePalette    (GDI.362)
 320  *
 321  */
 322 UINT GDIRealizePalette( HDC hdc )
 323 {
 324     DC*         dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ) ;
 325     PALETTEOBJ* palPtr;
 326     int         realized = 0;
 327
 328     dprintf_palette(stddeb, "GDIRealizePalette: %04x...", hdc );
 329
 330     if( dc &&  dc->w.hPalette != hLastRealizedPalette )
 331     {
 332         palPtr = (PALETTEOBJ *) GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC );
 333
 334         realized = COLOR_SetMapping(palPtr, dc->w.hPalette != hPrimaryPalette
 335                                   || dc->w.hPalette == STOCK_DEFAULT_PALETTE );
 336         hLastRealizedPalette = dc->w.hPalette;
 337     }
 338     else dprintf_palette(stddeb, " skipping ");
 339
 340     dprintf_palette(stdnimp, " realized %i colors\n", realized );
 341     return (UINT)realized;
 342 }
 343
 344
 345 /***********************************************************************
 346  *           RealizeDefaultPalette    (GDI.365)
 347  */
 348 WORD RealizeDefaultPalette( HDC hdc )
 349 {
 350     DC *dc;
 351
 352     dprintf_palette(stddeb,"RealizeDefaultPalette: %04x\n", hdc );
 353
 354     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 355     if ( dc->w.flags & DC_MEMORY ) return 0;
 356
 357     hPrimaryPalette = STOCK_DEFAULT_PALETTE;
 358     hLastRealizedPalette = STOCK_DEFAULT_PALETTE;
 359     return COLOR_SetMapping( (PALETTEOBJ*)GDI_GetObjPtr(STOCK_DEFAULT_PALETTE, PALETTE_MAGIC ), TRUE);
 360 }
 361
 362
 363 /***********************************************************************
 364  *           IsDCCurrentPalette   (GDI.412)
 365  */
 366 BOOL IsDCCurrentPalette(HDC hDC)
 367 {
 368     DC* dc = (DC *)GDI_GetObjPtr( hDC, DC_MAGIC );
 369     return (dc->w.hPalette == hPrimaryPalette);
 370 }
 371
 372 /***********************************************************************
 373  *           SelectPalette    (USER.282)
 374  */
 375 HPALETTE16 SelectPalette( HDC hDC, HPALETTE16 hPal, BOOL bForceBackground )
 376 {
 377     WORD        wBkgPalette = 1;
 378     PALETTEOBJ* lpt = (PALETTEOBJ*) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 379
 380     dprintf_palette(stddeb,"SelectPalette: dc %04x pal %04x, force=%i ",
 381                             hDC, hPal, bForceBackground);
 382     if( !lpt ) return 0;
 383
 384     dprintf_palette(stddeb," entries = %d\n",
 385                             lpt->logpalette.palNumEntries);
 386
 387     if( hPal != STOCK_DEFAULT_PALETTE )
 388     {
 389         HWND hWnd = DCE_hDC2hWnd( hDC );
 390         HWND hActive = GetActiveWindow();
 391
 392         /* set primary palette if it's related to current active */
 393
 394         if( hWnd && (hActive == hWnd || IsChild(hActive,hWnd)) &&
 395             !bForceBackground )
 396             wBkgPalette = 0;
 397     }
 398     return GDISelectPalette( hDC, hPal, wBkgPalette);
 399 }
 400
 401
 402 /***********************************************************************
 403  *           RealizePalette    (USER.283) (GDI32.280)
 404  */
 405 UINT16 RealizePalette( HDC32 hDC )
 406 {
 407     UINT16 realized = GDIRealizePalette( hDC );
 408
 409     /* do not send anything if no colors were changed */
 410
 411     if( IsDCCurrentPalette( hDC ) && realized )
 412     {
 413         /* Send palette change notification */
 414
 415         HWND hWnd;
 416         if( (hWnd = DCE_hDC2hWnd( hDC )) )
 417             SendMessage16( HWND_BROADCAST, WM_PALETTECHANGED, hWnd, 0L);
 418     }
 419     return realized;
 420 }
 421
 422
 423 /**********************************************************************
 424  *          UpdateColors        (GDI.366)
 425  *
 426  */
 427 int UpdateColors( HDC hDC )
 428 {
 429     HWND hWnd = DCE_hDC2hWnd( hDC );
 430
 431     /* Docs say that we have to remap current drawable pixel by pixel
 432      * but it would take forever given the speed of XGet/PutPixel.
 433      */
 434     if (hWnd) InvalidateRect16( hWnd, NULL, FALSE );
 435     return 0x666;
 436 }