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