objects/palette.c

   1 /*
   2  * GDI palette objects
   3  *
   4  * Copyright 1993,1994 Alexandre Julliard
   5  * Copyright 1996 Alex Korobka
   6  *
   7  */
   8
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <X11/Xlib.h>
  12
  13 #include "gdi.h"
  14 #include "color.h"
  15 #include "palette.h"
  16 #include "xmalloc.h"
  17 #include "stddebug.h"
  18 /* #define DEBUG_PALETTE */
  19 #include "debug.h"
  20
  21  /* lookup pixel among static entries of the system palette */
  22 extern int COLOR_LookupSystemPixel(COLORREF);
  23
  24 static UINT32 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  *           CreatePalette16    (GDI.360)
  43  */
  44 HPALETTE16 CreatePalette16( const LOGPALETTE* palette )
  45 {
  46     return CreatePalette32( palette );
  47 }
  48
  49
  50 /***********************************************************************
  51  *           CreatePalette32    (GDI32.53)
  52  */
  53 HPALETTE32 CreatePalette32( const LOGPALETTE* palette )
  54 {
  55     PALETTEOBJ * palettePtr;
  56     HPALETTE32 hpalette;
  57     int size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
  58
  59     dprintf_palette(stddeb,"CreatePalette: %i entries, ",
  60                     palette->palNumEntries);
  61
  62     hpalette = GDI_AllocObject( size + sizeof(int*) +sizeof(GDIOBJHDR) , PALETTE_MAGIC );
  63     if (!hpalette) return 0;
  64
  65     palettePtr = (PALETTEOBJ *) GDI_HEAP_LIN_ADDR( hpalette );
  66     memcpy( &palettePtr->logpalette, palette, size );
  67     PALETTE_ValidateFlags(palettePtr->logpalette.palPalEntry,
  68                           palettePtr->logpalette.palNumEntries);
  69     palettePtr->mapping = NULL;
  70
  71     dprintf_palette(stddeb,"returning %04x\n", hpalette);
  72     return hpalette;
  73 }
  74
  75
  76 /***********************************************************************
  77  *           GetPaletteEntries16    (GDI.363)
  78  */
  79 UINT16 GetPaletteEntries16( HPALETTE16 hpalette, UINT16 start, UINT16 count,
  80                             LPPALETTEENTRY entries )
  81 {
  82     return GetPaletteEntries32( hpalette, start, count, entries );
  83 }
  84
  85
  86 /***********************************************************************
  87  *           GetPaletteEntries32    (GDI32.209)
  88  */
  89 UINT32 GetPaletteEntries32( HPALETTE32 hpalette, UINT32 start, UINT32 count,
  90                             LPPALETTEENTRY entries )
  91 {
  92     PALETTEOBJ * palPtr;
  93     INT32 numEntries;
  94
  95     dprintf_palette( stddeb,"GetPaletteEntries: hpal = %04x, %i entries\n",
  96                      hpalette, count );
  97
  98     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
  99     if (!palPtr) return 0;
 100
 101     numEntries = palPtr->logpalette.palNumEntries;
 102     if (start >= numEntries) return 0;
 103     if (start+count > numEntries) count = numEntries - start;
 104     memcpy( entries, &palPtr->logpalette.palPalEntry[start],
 105             count * sizeof(PALETTEENTRY) );
 106     for( numEntries = 0; numEntries < count ; numEntries++ )
 107          if (entries[numEntries].peFlags & 0xF0)
 108              entries[numEntries].peFlags = 0;
 109     return count;
 110 }
 111
 112
 113 /***********************************************************************
 114  *           SetPaletteEntries16    (GDI.364)
 115  */
 116 UINT16 SetPaletteEntries16( HPALETTE16 hpalette, UINT16 start, UINT16 count,
 117                             LPPALETTEENTRY entries )
 118 {
 119     return SetPaletteEntries32( hpalette, start, count, entries );
 120 }
 121
 122
 123 /***********************************************************************
 124  *           SetPaletteEntries32    (GDI32.326)
 125  */
 126 UINT32 SetPaletteEntries32( HPALETTE32 hpalette, UINT32 start, UINT32 count,
 127                             LPPALETTEENTRY entries )
 128 {
 129     PALETTEOBJ * palPtr;
 130     INT32 numEntries;
 131
 132     dprintf_palette( stddeb,"SetPaletteEntries: hpal = %04x, %i entries\n",
 133                      hpalette, count );
 134
 135     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 136     if (!palPtr) return 0;
 137
 138     numEntries = palPtr->logpalette.palNumEntries;
 139     if (start >= numEntries) return 0;
 140     if (start+count > numEntries) count = numEntries - start;
 141     memcpy( &palPtr->logpalette.palPalEntry[start], entries,
 142             count * sizeof(PALETTEENTRY) );
 143     PALETTE_ValidateFlags(palPtr->logpalette.palPalEntry,
 144                           palPtr->logpalette.palNumEntries);
 145     free(palPtr->mapping);
 146     palPtr->mapping = NULL;
 147
 148     return count;
 149 }
 150
 151
 152 /***********************************************************************
 153  *           ResizePalette16   (GDI.368)
 154  */
 155 BOOL16 ResizePalette16( HPALETTE16 hPal, UINT16 cEntries )
 156 {
 157     return ResizePalette32( hPal, cEntries );
 158 }
 159
 160
 161 /***********************************************************************
 162  *           ResizePalette32   (GDI32.289)
 163  */
 164 BOOL32 ResizePalette32( HPALETTE32 hPal, UINT32 cEntries )
 165 {
 166     PALETTEOBJ * palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 167     UINT32       cPrevEnt, prevVer;
 168     int          prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
 169     int*         mapping = NULL;
 170
 171     dprintf_palette(stddeb,"ResizePalette: hpal = %04x, prev = %i, new = %i\n",
 172                     hPal, palPtr ? palPtr->logpalette.palNumEntries : -1,
 173                     cEntries );
 174     if( !palPtr ) return FALSE;
 175     cPrevEnt = palPtr->logpalette.palNumEntries;
 176     prevVer = palPtr->logpalette.palVersion;
 177     prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) +
 178                                         sizeof(int*) + sizeof(GDIOBJHDR);
 179     size += sizeof(int*) + sizeof(GDIOBJHDR);
 180     mapping = palPtr->mapping;
 181
 182     hPal = GDI_HEAP_REALLOC( hPal, size );
 183     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 184     if( !palPtr ) return FALSE;
 185
 186     if( mapping )
 187         palPtr->mapping = (int*) xrealloc( mapping, cEntries * sizeof(int) );
 188     if( cEntries > cPrevEnt )
 189     {
 190         if( mapping )
 191             memset(palPtr->mapping + cPrevEnt, 0, (cEntries - cPrevEnt)*sizeof(int));
 192         memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
 193         PALETTE_ValidateFlags((PALETTEENTRY*)((BYTE*)palPtr + prevsize),
 194                                                      cEntries - cPrevEnt );
 195     }
 196     palPtr->logpalette.palNumEntries = cEntries;
 197     palPtr->logpalette.palVersion = prevVer;
 198     return TRUE;
 199 }
 200
 201
 202 /***********************************************************************
 203  *           AnimatePalette16   (GDI.367)
 204  */
 205 BOOL16 AnimatePalette16( HPALETTE16 hPal, UINT16 StartIndex, UINT16 NumEntries,
 206                          LPPALETTEENTRY PaletteColors )
 207 {
 208     return AnimatePalette32( hPal, StartIndex, NumEntries, PaletteColors );
 209 }
 210
 211
 212 /***********************************************************************
 213  *           AnimatePalette32   (GDI32.6)
 214  */
 215 BOOL32 AnimatePalette32( HPALETTE32 hPal, UINT32 StartIndex, UINT32 NumEntries,
 216                          LPPALETTEENTRY PaletteColors )
 217 {
 218     fprintf(stdnimp,"AnimatePalette: empty stub! \n");
 219     return TRUE;
 220 }
 221
 222
 223 /***********************************************************************
 224  *           SetSystemPaletteUse16   (GDI.373)
 225  */
 226 UINT16 SetSystemPaletteUse16( HDC16 hdc, UINT16 use )
 227 {
 228     return SetSystemPaletteUse32( hdc, use );
 229 }
 230
 231
 232 /***********************************************************************
 233  *           SetSystemPaletteUse32   (GDI32.335)
 234  */
 235 UINT32 SetSystemPaletteUse32( HDC32 hdc, UINT32 use )
 236 {
 237     UINT32 old = SystemPaletteUse;
 238     fprintf( stdnimp,"SetSystemPaletteUse(%04x,%04x) // empty stub !!!\n",
 239              hdc, use );
 240     SystemPaletteUse = use;
 241     return old;
 242 }
 243
 244
 245 /***********************************************************************
 246  *           GetSystemPaletteUse16   (GDI.374)
 247  */
 248 UINT16 GetSystemPaletteUse16( HDC16 hdc )
 249 {
 250     return SystemPaletteUse;
 251 }
 252
 253
 254 /***********************************************************************
 255  *           GetSystemPaletteUse32   (GDI32.223)
 256  */
 257 UINT32 GetSystemPaletteUse32( HDC32 hdc )
 258 {
 259     return SystemPaletteUse;
 260 }
 261
 262
 263 /***********************************************************************
 264  *           GetSystemPaletteEntries16   (GDI.375)
 265  */
 266 UINT16 GetSystemPaletteEntries16( HDC16 hdc, UINT16 start, UINT16 count,
 267                                   LPPALETTEENTRY entries )
 268 {
 269     return GetSystemPaletteEntries32( hdc, start, count, entries );
 270 }
 271
 272
 273 /***********************************************************************
 274  *           GetSystemPaletteEntries32   (GDI32.222)
 275  */
 276 UINT32 GetSystemPaletteEntries32( HDC32 hdc, UINT32 start, UINT32 count,
 277                                   LPPALETTEENTRY entries )
 278 {
 279     UINT32 i;
 280     DC *dc;
 281
 282     dprintf_palette(stddeb,"GetSystemPaletteEntries: hdc = %04x, cound = %i", hdc, count );
 283
 284     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 285     if (start >= dc->w.devCaps->sizePalette) return 0;
 286     if (start+count >= dc->w.devCaps->sizePalette)
 287         count = dc->w.devCaps->sizePalette - start;
 288     for (i = 0; i < count; i++)
 289     {
 290         *(COLORREF*)(entries + i) = COLOR_GetSystemPaletteEntry( start + i );
 291
 292         dprintf_palette( stddeb,"\tidx(%02x) -> RGB(%08lx)\n",
 293                          start + i, *(COLORREF*)(entries + i) );
 294     }
 295     return count;
 296 }
 297
 298
 299 /***********************************************************************
 300  *           GetNearestPaletteIndex16   (GDI.370)
 301  */
 302 UINT16 GetNearestPaletteIndex16( HPALETTE16 hpalette, COLORREF color )
 303 {
 304     return GetNearestPaletteIndex32( hpalette, color );
 305 }
 306
 307
 308 /***********************************************************************
 309  *           GetNearestPaletteIndex32   (GDI32.203)
 310  */
 311 UINT32 GetNearestPaletteIndex32( HPALETTE32 hpalette, COLORREF color )
 312 {
 313     PALETTEOBJ* palObj = (PALETTEOBJ*)GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 314     UINT32 index  = 0;
 315
 316     if( palObj )
 317         index = COLOR_PaletteLookupPixel( palObj->logpalette.palPalEntry,
 318                                           palObj->logpalette.palNumEntries,
 319                                           NULL, color, FALSE );
 320
 321     dprintf_palette(stddeb,"GetNearestPaletteIndex(%04x,%06lx): returning %d\n",
 322                     hpalette, color, index );
 323     return index;
 324 }
 325
 326
 327 /***********************************************************************
 328  *           GetNearestColor16   (GDI.154)
 329  */
 330 COLORREF GetNearestColor16( HDC16 hdc, COLORREF color )
 331 {
 332     return GetNearestColor32( hdc, color );
 333 }
 334
 335
 336 /***********************************************************************
 337  *           GetNearestColor32   (GDI32.202)
 338  */
 339 COLORREF GetNearestColor32( HDC32 hdc, COLORREF color )
 340 {
 341     COLORREF     nearest = 0xFADECAFE;
 342     DC          *dc;
 343     PALETTEOBJ  *palObj;
 344
 345     if ( (dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC )) )
 346     {
 347       palObj = (PALETTEOBJ*)
 348                 GDI_GetObjPtr( (dc->w.hPalette)? dc->w.hPalette
 349                                                : STOCK_DEFAULT_PALETTE, PALETTE_MAGIC );
 350
 351       nearest = COLOR_LookupNearestColor( palObj->logpalette.palPalEntry,
 352                                           palObj->logpalette.palNumEntries, color );
 353     }
 354
 355     dprintf_palette(stddeb,"GetNearestColor(%06lx): returning %06lx\n",
 356                     color, nearest );
 357     return nearest;
 358 }
 359
 360
 361 /***********************************************************************
 362  *           PALETTE_GetObject
 363  */
 364 int PALETTE_GetObject( PALETTEOBJ * palette, int count, LPSTR buffer )
 365 {
 366     if (count > sizeof(WORD)) count = sizeof(WORD);
 367     memcpy( buffer, &palette->logpalette.palNumEntries, count );
 368     return count;
 369 }
 370
 371
 372 /***********************************************************************
 373  *           PALETTE_UnrealizeObject
 374  */
 375 BOOL32 PALETTE_UnrealizeObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 376 {
 377     if (palette->mapping)
 378     {
 379         free( palette->mapping );
 380         palette->mapping = NULL;
 381     }
 382     if (hLastRealizedPalette == hpalette) hLastRealizedPalette = 0;
 383     return TRUE;
 384 }
 385
 386
 387 /***********************************************************************
 388  *           PALETTE_DeleteObject
 389  */
 390 BOOL32 PALETTE_DeleteObject( HPALETTE16 hpalette, PALETTEOBJ *palette )
 391 {
 392     free( palette->mapping );
 393     return GDI_FreeObject( hpalette );
 394 }
 395
 396
 397 /***********************************************************************
 398  *           GDISelectPalette    (GDI.361)
 399  */
 400 HPALETTE16 GDISelectPalette( HDC16 hdc, HPALETTE16 hpal, WORD wBkg)
 401 {
 402     HPALETTE16 prev;
 403     DC *dc;
 404
 405     dprintf_palette(stddeb, "GDISelectPalette: %04x %04x\n", hdc, hpal );
 406
 407     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 408     if (!dc)
 409     {
 410         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 411         if (!dc) return 0;
 412     }
 413     prev = dc->w.hPalette;
 414     dc->w.hPalette = hpal;
 415     if (!wBkg) hPrimaryPalette = hpal;
 416     return prev;
 417 }
 418
 419
 420 /***********************************************************************
 421  *           GDIRealizePalette    (GDI.362)
 422  */
 423 UINT16 GDIRealizePalette( HDC16 hdc )
 424 {
 425     PALETTEOBJ* palPtr;
 426     int realized = 0;
 427     DC*         dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 428     if (!dc)
 429     {
 430         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 431         if (!dc) return 0;
 432     }
 433
 434     dprintf_palette(stddeb, "GDIRealizePalette: %04x...", hdc );
 435
 436     if( dc &&  dc->w.hPalette != hLastRealizedPalette )
 437     {
 438         if( dc->w.hPalette == STOCK_DEFAULT_PALETTE )
 439             return RealizeDefaultPalette( hdc );
 440
 441         palPtr = (PALETTEOBJ *) GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC );
 442
 443         realized = COLOR_SetMapping(palPtr, dc->w.hPalette != hPrimaryPalette
 444                                   || dc->w.hPalette == STOCK_DEFAULT_PALETTE );
 445         hLastRealizedPalette = dc->w.hPalette;
 446     }
 447     else dprintf_palette(stddeb, " skipping ");
 448
 449     dprintf_palette(stdnimp, " realized %i colors\n", realized );
 450     return (UINT16)realized;
 451 }
 452
 453
 454 /***********************************************************************
 455  *           RealizeDefaultPalette    (GDI.365)
 456  */
 457 UINT16 RealizeDefaultPalette( HDC16 hdc )
 458 {
 459     DC          *dc;
 460     PALETTEOBJ*  palPtr;
 461     int          i, index, realized = 0;
 462
 463     dprintf_palette(stddeb,"RealizeDefaultPalette: %04x\n", hdc );
 464
 465     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 466     if (!dc)
 467     {
 468         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 469         if (!dc) return 0;
 470     }
 471
 472     if ( dc->w.flags & DC_MEMORY ) return 0;
 473
 474     hPrimaryPalette = STOCK_DEFAULT_PALETTE;
 475     hLastRealizedPalette = STOCK_DEFAULT_PALETTE;
 476
 477     palPtr = (PALETTEOBJ*)GDI_GetObjPtr(STOCK_DEFAULT_PALETTE, PALETTE_MAGIC );
 478
 479     /* lookup is needed to account for SetSystemPaletteUse() stuff */
 480
 481     for( i = 0; i < 20; i++ )
 482        {
 483          index = COLOR_LookupSystemPixel(*(COLORREF*)(palPtr->logpalette.palPalEntry + i));
 484
 485          /* mapping is allocated in COLOR_InitPalette() */
 486
 487          if( index != palPtr->mapping[i] ) { palPtr->mapping[i]=index; realized++; }
 488        }
 489     return realized;
 490 }
 491
 492 /***********************************************************************
 493  *           IsDCCurrentPalette   (GDI.412)
 494  */
 495 BOOL16 IsDCCurrentPalette(HDC16 hDC)
 496 {
 497     DC* dc = (DC *)GDI_GetObjPtr( hDC, DC_MAGIC );
 498     return (dc)?(dc->w.hPalette == hPrimaryPalette):FALSE;
 499 }
 500
 501
 502 /***********************************************************************
 503  *           SelectPalette16    (USER.282)
 504  */
 505 HPALETTE16 SelectPalette16( HDC16 hDC, HPALETTE16 hPal,
 506                             BOOL16 bForceBackground )
 507 {
 508     return SelectPalette32( hDC, hPal, bForceBackground );
 509 }
 510
 511
 512 /***********************************************************************
 513  *           SelectPalette32    (GDI32.300)
 514  */
 515 HPALETTE32 SelectPalette32( HDC32 hDC, HPALETTE32 hPal,
 516                             BOOL32 bForceBackground )
 517 {
 518     WORD        wBkgPalette = 1;
 519     PALETTEOBJ* lpt = (PALETTEOBJ*) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
 520
 521     dprintf_palette(stddeb,"SelectPalette: dc %04x pal %04x, force=%i ",
 522                             hDC, hPal, bForceBackground);
 523     if( !lpt ) return 0;
 524
 525     dprintf_palette(stddeb," entries = %d\n",
 526                             lpt->logpalette.palNumEntries);
 527
 528     if( hPal != STOCK_DEFAULT_PALETTE )
 529     {
 530         HWND32 hWnd = WindowFromDC32( hDC );
 531         HWND32 hActive = GetActiveWindow32();
 532
 533         /* set primary palette if it's related to current active */
 534
 535         if((!hWnd || (hActive == hWnd || IsChild16(hActive,hWnd))) &&
 536             !bForceBackground )
 537             wBkgPalette = 0;
 538     }
 539     return GDISelectPalette( hDC, hPal, wBkgPalette);
 540 }
 541
 542
 543 /***********************************************************************
 544  *           RealizePalette16    (USER.283)
 545  */
 546 UINT16 RealizePalette16( HDC16 hDC )
 547 {
 548     return RealizePalette32( hDC );
 549 }
 550
 551
 552 /***********************************************************************
 553  *           RealizePalette32    (GDI32.280)
 554  */
 555 UINT32 RealizePalette32( HDC32 hDC )
 556 {
 557     UINT32 realized = GDIRealizePalette( hDC );
 558
 559     /* do not send anything if no colors were changed */
 560
 561     if( IsDCCurrentPalette( hDC ) && realized &&
 562         !(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) )
 563     {
 564         /* Send palette change notification */
 565
 566         HWND32 hWnd;
 567         if( (hWnd = WindowFromDC32( hDC )) )
 568             SendMessage16( HWND_BROADCAST, WM_PALETTECHANGED, hWnd, 0L);
 569     }
 570     return realized;
 571 }
 572
 573
 574 /**********************************************************************
 575  *            UpdateColors16   (GDI.366)
 576  */
 577 INT16 UpdateColors16( HDC16 hDC )
 578 {
 579     HWND32 hWnd = WindowFromDC32( hDC );
 580
 581     /* Docs say that we have to remap current drawable pixel by pixel
 582      * but it would take forever given the speed of XGet/PutPixel.
 583      */
 584     if (hWnd && !(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) )
 585         InvalidateRect32( hWnd, NULL, FALSE );
 586     return 0x666;
 587 }
 588
 589
 590 /**********************************************************************
 591  *            UpdateColors32   (GDI32.359)
 592  */
 593 BOOL32 UpdateColors32( HDC32 hDC )
 594 {
 595     UpdateColors16( hDC );
 596     return TRUE;
 597 }