objects/palette.c

   1 /*
   2  * GDI palette objects
   3  *
   4  * Copyright 1993,1994 Alexandre Julliard
   5  *
   6 static char Copyright[] = "Copyright  Alexandre Julliard, 1993,1994";
   7 */
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <limits.h>
  11
  12 #if !defined  (MAXINT)
  13 #include <limits.h>
  14 #define MAXINT INT_MAX
  15 #endif
  16
  17 #include <X11/Xlib.h>
  18 #include "color.h"
  19 #include "palette.h"
  20 #include "stddebug.h"
  21 /* #define DEBUG_PALETTE */
  22 #include "debug.h"
  23
  24 static WORD SystemPaletteUse = SYSPAL_STATIC;   /* currently not considered */
  25
  26
  27 /***********************************************************************
  28  *           PALETTE_GetNearestIndexAndColor
  29  */
  30 static WORD PALETTE_GetNearestIndexAndColor(HPALETTE hpalette, COLORREF *color)
  31 {
  32     int i, minDist, dist;
  33     WORD index = 0;
  34     BYTE r, g, b;
  35     PALETTEENTRY * entry;
  36     PALETTEOBJ * palPtr;
  37
  38     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
  39     if (!palPtr) return 0;
  40
  41     if ((COLOR_WinColormap != DefaultColormapOfScreen(screen)) &&
  42         (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 = MAXINT; 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     entry = &palPtr->logpalette.palPalEntry[index];
  71     *color = RGB( entry->peRed, entry->peGreen, entry->peBlue );
  72     return index;
  73 }
  74
  75
  76 /***********************************************************************
  77  *           CreatePalette    (GDI.360)
  78  */
  79 HPALETTE CreatePalette( LOGPALETTE * palette )
  80 {
  81     PALETTEOBJ * palettePtr;
  82     HPALETTE hpalette;
  83     int size;
  84
  85     size = sizeof(LOGPALETTE) + (palette->palNumEntries - 1) * sizeof(PALETTEENTRY);
  86     hpalette = GDI_AllocObject( sizeof(GDIOBJHDR) + size, PALETTE_MAGIC );
  87     if (!hpalette) return 0;
  88     palettePtr = (PALETTEOBJ *) GDI_HEAP_LIN_ADDR( hpalette );
  89     memcpy( &palettePtr->logpalette, palette, size );
  90     return hpalette;
  91 }
  92
  93
  94 /***********************************************************************
  95  *           GetPaletteEntries    (GDI.363)
  96  */
  97 WORD GetPaletteEntries( HPALETTE hpalette, WORD start, WORD count,
  98                         LPPALETTEENTRY entries )
  99 {
 100     PALETTEOBJ * palPtr;
 101     int numEntries;
 102
 103     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 104     if (!palPtr) return 0;
 105     numEntries = palPtr->logpalette.palNumEntries;
 106     if (start >= numEntries) return 0;
 107     if (start+count > numEntries) count = numEntries - start;
 108     memcpy( entries, &palPtr->logpalette.palPalEntry[start],
 109             count * sizeof(PALETTEENTRY) );
 110     return count;
 111 }
 112
 113
 114 /***********************************************************************
 115  *           SetPaletteEntries    (GDI.364)
 116  */
 117 WORD SetPaletteEntries( HPALETTE hpalette, WORD start, WORD count,
 118                         LPPALETTEENTRY entries )
 119 {
 120     PALETTEOBJ * palPtr;
 121     int numEntries;
 122
 123     palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hpalette, PALETTE_MAGIC );
 124     if (!palPtr) return 0;
 125     numEntries = palPtr->logpalette.palNumEntries;
 126     if (start >= numEntries) return 0;
 127     if (start+count > numEntries) count = numEntries - start;
 128     memcpy( &palPtr->logpalette.palPalEntry[start], entries,
 129             count * sizeof(PALETTEENTRY) );
 130     return count;
 131 }
 132
 133 /***********************************************************************
 134  *           ResizePalette          (GDI.368)
 135  */
 136 BOOL ResizePalette(HPALETTE hPal, UINT cEntries)
 137 {
 138     fprintf(stdnimp,"ResizePalette: empty stub! \n");
 139     return FALSE;
 140 }
 141
 142 /***********************************************************************
 143  *           AnimatePalette          (GDI.367)
 144  */
 145 void AnimatePalette(HPALETTE hPal, UINT StartIndex, UINT NumEntries,
 146                     LPPALETTEENTRY PaletteColors)
 147 {
 148     fprintf(stdnimp,"AnimatePalette: empty stub! \n");
 149 }
 150
 151 /***********************************************************************
 152  *           SetSystemPaletteUse    (GDI.373)
 153  *      Should this be per DC rather than system wide?
 154  *  Currently, it does not matter as the use is only set and returned,
 155  *  but not taken into account
 156  */
 157 WORD SetSystemPaletteUse( HDC hdc, WORD use)
 158 {
 159          WORD old=SystemPaletteUse;
 160          printf("SetSystemPaletteUse("NPFMT",%04X) // empty stub !!!\n", hdc, use);
 161          SystemPaletteUse=use;
 162          return old;
 163 }
 164
 165 /***********************************************************************
 166  *           GetSystemPaletteUse    (GDI.374)
 167  */
 168 WORD GetSystemPaletteUse( HDC hdc )
 169 {
 170         printf("GetSystemPaletteUse("NPFMT") // empty stub !!!\n", hdc);
 171         return SystemPaletteUse;
 172 }
 173
 174
 175 /***********************************************************************
 176  *           GetSystemPaletteEntries    (GDI.375)
 177  */
 178 WORD GetSystemPaletteEntries( HDC hdc, WORD start, WORD count,
 179                               LPPALETTEENTRY entries )
 180 {
 181     WORD i;
 182     DC *dc;
 183     XColor color;
 184
 185     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 186     if (start >= dc->w.devCaps->sizePalette) return 0;
 187     if (start+count >= dc->w.devCaps->sizePalette)
 188         count = dc->w.devCaps->sizePalette - start;
 189     for (i = 0; i < count; i++)
 190     {
 191         color.pixel = start + i;
 192         XQueryColor( display, COLOR_WinColormap, &color );
 193         entries[i].peRed   = color.red >> 8;
 194         entries[i].peGreen = color.green >> 8;
 195         entries[i].peBlue  = color.blue >> 8;
 196         entries[i].peFlags = 0;
 197     }
 198     return count;
 199 }
 200
 201
 202 /***********************************************************************
 203  *           GetNearestPaletteIndex    (GDI.370)
 204  */
 205 WORD GetNearestPaletteIndex( HPALETTE hpalette, COLORREF color )
 206 {
 207     WORD index = PALETTE_GetNearestIndexAndColor( hpalette, &color );
 208     dprintf_palette(stddeb,"GetNearestPaletteIndex("NPFMT",%06lx): returning %d\n",
 209                     hpalette, color, index );
 210     return index;
 211 }
 212
 213
 214 /***********************************************************************
 215  *           GetNearestColor    (GDI.154)
 216  */
 217 COLORREF GetNearestColor( HDC hdc, COLORREF color )
 218 {
 219     COLORREF nearest = color;
 220     DC *dc;
 221
 222     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 223     PALETTE_GetNearestIndexAndColor( dc->w.hPalette, &nearest );
 224     dprintf_palette(stddeb,"GetNearestColor(%06lx): returning %06lx\n",
 225                     color, nearest );
 226     return nearest;
 227 }
 228
 229
 230 /***********************************************************************
 231  *           PALETTE_GetObject
 232  */
 233 int PALETTE_GetObject( PALETTEOBJ * palette, int count, LPSTR buffer )
 234 {
 235     if (count > sizeof(WORD)) count = sizeof(WORD);
 236     memcpy( buffer, &palette->logpalette.palNumEntries, count );
 237     return count;
 238 }
 239
 240
 241 /***********************************************************************
 242  *           GDISelectPalette    (GDI.361)
 243  */
 244 HPALETTE GDISelectPalette( HDC hdc, HPALETTE hpal )
 245 {
 246     HPALETTE prev;
 247     DC *dc;
 248
 249     dprintf_palette(stddeb, "GDISelectPalette: "NPFMT" "NPFMT"\n", hdc, hpal );
 250     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 251     prev = dc->w.hPalette;
 252     dc->w.hPalette = hpal;
 253     if (hpal != STOCK_DEFAULT_PALETTE) COLOR_SetMapping( dc, 0, 0, 0 );
 254     else RealizeDefaultPalette( hdc );  /* Always realize default palette */
 255     return prev;
 256 }
 257
 258
 259 /***********************************************************************
 260  *           GDIRealizePalette    (GDI.362)
 261  */
 262 UINT GDIRealizePalette( HDC hdc )
 263 {
 264     dprintf_palette(stdnimp, "GDIRealizePalette: "NPFMT"\n", hdc );
 265     return 0;
 266 }
 267
 268
 269 /***********************************************************************
 270  *           SelectPalette    (USER.282)
 271  */
 272 HPALETTE SelectPalette(HDC hDC, HPALETTE hPal, BOOL bForceBackground)
 273 {
 274     return GDISelectPalette( hDC, hPal );
 275 }
 276
 277
 278 /***********************************************************************
 279  *           RealizePalette    (USER.283)
 280  */
 281 UINT RealizePalette(HDC hDC)
 282 {
 283     return GDIRealizePalette( hDC );
 284 }
 285