?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Get rid of some direct accesses to the DC structure from outside GDI.
[wine/multimedia.git] / dlls / x11drv / palette.c
blob58f5924a7ff989c0ff8bda839a49c27345fbe876
1 /*
2 * X11DRV OEM bitmap objects
3 *
4 * Copyright 1994, 1995 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "gdi.h"
27 #include "palette.h"
28 #include "windef.h"
29 #include "winreg.h"
30 #include "x11drv.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(palette);
34
35 /* Palette indexed mode:
36 * logical palette -> mapping -> pixel
37 *
38 *
39 * Windows needs contiguous color space ( from 0 to n ) but
40 * it is possible only with the private colormap. Otherwise we
41 * have to map DC palette indices to real pixel values. With
42 * private colormaps it boils down to the identity mapping. The
43 * other special case is when we have a fixed color visual with
44 * the screendepth > 8 - we abandon palette mappings altogether
45 * because pixel values can be calculated without X server
46 * assistance.
47 *
48 * Windows palette manager is described in the
49 * http://premium.microsoft.com/msdn/library/techart/f30/f34/f40/d4d/sa942.htm
50 */
51
52 static PALETTEENTRY *COLOR_sysPal; /* current system palette */
53
54 static int COLOR_gapStart = 256;
55 static int COLOR_gapEnd = -1;
56 static int COLOR_gapFilled = 0;
57 static int COLOR_max = 256;
58
59 Colormap X11DRV_PALETTE_PaletteXColormap = 0;
60 UINT16 X11DRV_PALETTE_PaletteFlags = 0;
61
62 typedef struct {
63 int shift;
64 int scale;
65 int max;
66 } ColorShifts;
67
68 /* initialize to zero to handle abortive X11DRV_PALETTE_VIRTUAL visuals */
69 static ColorShifts X11DRV_PALETTE_PRed = {0,0,0};
70 static ColorShifts X11DRV_PALETTE_LRed = {0,0,0};
71 static ColorShifts X11DRV_PALETTE_PGreen = {0,0,0};
72 static ColorShifts X11DRV_PALETTE_LGreen = {0,0,0};
73 static ColorShifts X11DRV_PALETTE_PBlue = {0,0,0};
74 static ColorShifts X11DRV_PALETTE_LBlue = {0,0,0};
75 static int X11DRV_PALETTE_Graymax = 0;
76
77 static int palette_size;
78
79 /* First free dynamic color cell, 0 = full palette, -1 = fixed palette */
80 static int X11DRV_PALETTE_firstFree = 0;
81 static unsigned char X11DRV_PALETTE_freeList[256];
82
83 /**********************************************************************/
84
85 /* Map an EGA index (0..15) to a pixel value in the system color space. */
86
87 int X11DRV_PALETTE_mapEGAPixel[16];
88
89 /**********************************************************************/
90
91 #define NB_COLORCUBE_START_INDEX 63
92 #define NB_PALETTE_EMPTY_VALUE -1
93
94 /* Maps entry in the system palette to X pixel value */
95 int *X11DRV_PALETTE_PaletteToXPixel = NULL;
96
97 /* Maps pixel to the entry in the system palette */
98 int *X11DRV_PALETTE_XPixelToPalette = NULL;
99
100 /**********************************************************************/
101
102 static BOOL X11DRV_PALETTE_BuildPrivateMap( const PALETTEENTRY *sys_pal_template );
103 static BOOL X11DRV_PALETTE_BuildSharedMap( const PALETTEENTRY *sys_pal_template );
104 static void X11DRV_PALETTE_ComputeShifts(unsigned long maskbits, ColorShifts *physical, ColorShifts *to_logical);
105 static void X11DRV_PALETTE_FillDefaultColors( const PALETTEENTRY *sys_pal_template );
106 static void X11DRV_PALETTE_FormatSystemPalette(void);
107 static BOOL X11DRV_PALETTE_CheckSysColor( const PALETTEENTRY *sys_pal_template, COLORREF c);
108 static int X11DRV_PALETTE_LookupSystemXPixel(COLORREF col);
109
110
111 /***********************************************************************
112 * COLOR_Init
113 *
114 * Initialize color management.
115 */
116 int X11DRV_PALETTE_Init(void)
117 {
118 int mask, white, black;
119 int monoPlane;
120 PALETTEENTRY sys_pal_template[NB_RESERVED_COLORS];
121
122 TRACE("initializing palette manager...\n");
123
124 white = WhitePixel( gdi_display, DefaultScreen(gdi_display) );
125 black = BlackPixel( gdi_display, DefaultScreen(gdi_display) );
126 monoPlane = 1;
127 for( mask = 1; !((white & mask)^(black & mask)); mask <<= 1 )
128 monoPlane++;
129 X11DRV_PALETTE_PaletteFlags = (white & mask) ? X11DRV_PALETTE_WHITESET : 0;
130 palette_size = visual->map_entries;
131
132 switch(visual->class)
133 {
134 case DirectColor:
135 X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_VIRTUAL;
136 case GrayScale:
137 case PseudoColor:
138 {
139 HKEY hkey;
140 BOOL private_color_map = FALSE;
141 if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\x11drv", &hkey))
142 {
143 char buffer[20];
144 DWORD type, count = sizeof(buffer);
145 if(!RegQueryValueExA(hkey, "PrivateColorMap", 0, &type, buffer, &count))
146 {
147 char ch = buffer[0];
148 private_color_map = (ch == 'y' || ch == 'Y' || ch == 't' || ch == 'T' || ch == '1');
149 }
150 RegCloseKey(hkey);
151 }
152
153 wine_tsx11_lock();
154 if (private_color_map)
155 {
156 XSetWindowAttributes win_attr;
157
158 X11DRV_PALETTE_PaletteXColormap = XCreateColormap( gdi_display, root_window,
159 visual, AllocAll );
160 if (X11DRV_PALETTE_PaletteXColormap)
161 {
162 X11DRV_PALETTE_PaletteFlags |= (X11DRV_PALETTE_PRIVATE | X11DRV_PALETTE_WHITESET);
163
164 monoPlane = 1;
165 for( white = palette_size - 1; !(white & 1); white >>= 1 )
166 monoPlane++;
167
168 if( root_window != DefaultRootWindow(gdi_display) )
169 {
170 win_attr.colormap = X11DRV_PALETTE_PaletteXColormap;
171 XChangeWindowAttributes( gdi_display, root_window, CWColormap, &win_attr );
172 }
173 break;
174 }
175 }
176 X11DRV_PALETTE_PaletteXColormap = XCreateColormap(gdi_display, root_window,
177 visual, AllocNone);
178 wine_tsx11_unlock();
179 break;
180 }
181
182 case StaticGray:
183 wine_tsx11_lock();
184 X11DRV_PALETTE_PaletteXColormap = XCreateColormap(gdi_display, root_window,
185 visual, AllocNone);
186 X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_FIXED;
187 X11DRV_PALETTE_Graymax = (1 << screen_depth)-1;
188 wine_tsx11_unlock();
189 break;
190
191 case TrueColor:
192 X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_VIRTUAL;
193 case StaticColor: {
194 int *depths,nrofdepths;
195 /* FIXME: hack to detect XFree32 XF_VGA16 ... We just have
196 * depths 1 and 4
197 */
198 wine_tsx11_lock();
199 depths = XListDepths(gdi_display,DefaultScreen(gdi_display),&nrofdepths);
200 if ((nrofdepths==2) && ((depths[0]==4) || depths[1]==4)) {
201 monoPlane = 1;
202 for( white = palette_size - 1; !(white & 1); white >>= 1 )
203 monoPlane++;
204 X11DRV_PALETTE_PaletteFlags = (white & mask) ? X11DRV_PALETTE_WHITESET : 0;
205 X11DRV_PALETTE_PaletteXColormap = XCreateColormap(gdi_display, root_window,
206 visual, AllocNone);
207 }
208 else
209 {
210 X11DRV_PALETTE_PaletteXColormap = XCreateColormap(gdi_display, root_window,
211 visual, AllocNone);
212 X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_FIXED;
213 X11DRV_PALETTE_ComputeShifts(visual->red_mask, &X11DRV_PALETTE_PRed, &X11DRV_PALETTE_LRed);
214 X11DRV_PALETTE_ComputeShifts(visual->green_mask, &X11DRV_PALETTE_PGreen, &X11DRV_PALETTE_LGreen);
215 X11DRV_PALETTE_ComputeShifts(visual->blue_mask, &X11DRV_PALETTE_PBlue, &X11DRV_PALETTE_LBlue);
216 }
217 XFree(depths);
218 wine_tsx11_unlock();
219 break;
220 }
221 }
222
223 TRACE(" visual class %i (%i)\n", visual->class, monoPlane);
224
225 GetPaletteEntries( GetStockObject(DEFAULT_PALETTE), 0, NB_RESERVED_COLORS, sys_pal_template );
226
227 if( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL )
228 {
229 palette_size = 0;
230 }
231 else
232 {
233 if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE)
234 X11DRV_PALETTE_BuildPrivateMap( sys_pal_template );
235 else
236 X11DRV_PALETTE_BuildSharedMap( sys_pal_template );
237
238 /* Build free list */
239
240 if( X11DRV_PALETTE_firstFree != -1 )
241 X11DRV_PALETTE_FormatSystemPalette();
242
243 X11DRV_PALETTE_FillDefaultColors( sys_pal_template );
244 palette_size = visual->map_entries;
245 }
246
247 return palette_size;
248 }
249
250 /***********************************************************************
251 * X11DRV_PALETTE_Cleanup
252 *
253 * Free external colors we grabbed in the FillDefaultPalette()
254 */
255 void X11DRV_PALETTE_Cleanup(void)
256 {
257 if( COLOR_gapFilled )
258 {
259 wine_tsx11_lock();
260 XFreeColors(gdi_display, X11DRV_PALETTE_PaletteXColormap,
261 (unsigned long*)(X11DRV_PALETTE_PaletteToXPixel + COLOR_gapStart),
262 COLOR_gapFilled, 0);
263 wine_tsx11_unlock();
264 }
265 }
266
267 /***********************************************************************
268 * X11DRV_PALETTE_ComputeShifts
269 *
270 * Calculate conversion parameters for direct mapped visuals
271 */
272 static void X11DRV_PALETTE_ComputeShifts(unsigned long maskbits, ColorShifts *physical, ColorShifts *to_logical)
273 {
274 int i;
275
276 if (maskbits==0)
277 {
278 physical->shift=0;
279 physical->scale=0;
280 physical->max=0;
281 to_logical->shift=0;
282 to_logical->scale=0;
283 to_logical->max=0;
284 return;
285 }
286
287 for(i=0;!(maskbits&1);i++)
288 maskbits >>= 1;
289
290 physical->shift = i;
291 physical->max = maskbits;
292
293 for(i=0;maskbits!=0;i++)
294 maskbits >>= 1;
295 physical->scale = i;
296
297 if (physical->scale>8)
298 {
299 /* On FreeBSD, VNC's default 32bpp mode is bgrabb (ffc00000,3ff800,7ff)!
300 * So we adjust the shifts to also normalize the color fields to
301 * the Win32 standard of 8 bits per color.
302 */
303 to_logical->shift=physical->shift+(physical->scale-8);
304 to_logical->scale=8;
305 to_logical->max=0xff;
306 } else {
307 to_logical->shift=physical->shift;
308 to_logical->scale=physical->scale;
309 to_logical->max=physical->max;
310 }
311 }
312
313 /***********************************************************************
314 * X11DRV_PALETTE_BuildPrivateMap
315 *
316 * Allocate colorcells and initialize mapping tables.
317 */
318 static BOOL X11DRV_PALETTE_BuildPrivateMap( const PALETTEENTRY *sys_pal_template )
319 {
320 /* Private colormap - identity mapping */
321
322 XColor color;
323 int i;
324
325 if((COLOR_sysPal = (PALETTEENTRY*)HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY)*palette_size)) == NULL) {
326 WARN("Can not allocate system palette\n");
327 return FALSE;
328 }
329
330 TRACE("Building private map - %i palette entries\n", palette_size);
331
332 /* Allocate system palette colors */
333
334 wine_tsx11_lock();
335 for( i=0; i < palette_size; i++ )
336 {
337 if( i < NB_RESERVED_COLORS/2 )
338 {
339 color.red = sys_pal_template[i].peRed * 65535 / 255;
340 color.green = sys_pal_template[i].peGreen * 65535 / 255;
341 color.blue = sys_pal_template[i].peBlue * 65535 / 255;
342 COLOR_sysPal[i] = sys_pal_template[i];
343 COLOR_sysPal[i].peFlags |= PC_SYS_USED;
344 }
345 else if( i >= palette_size - NB_RESERVED_COLORS/2 )
346 {
347 int j = NB_RESERVED_COLORS + i - palette_size;
348 color.red = sys_pal_template[j].peRed * 65535 / 255;
349 color.green = sys_pal_template[j].peGreen * 65535 / 255;
350 color.blue = sys_pal_template[j].peBlue * 65535 / 255;
351 COLOR_sysPal[i] = sys_pal_template[j];
352 COLOR_sysPal[i].peFlags |= PC_SYS_USED;
353 }
354
355 color.flags = DoRed | DoGreen | DoBlue;
356 color.pixel = i;
357 XStoreColor(gdi_display, X11DRV_PALETTE_PaletteXColormap, &color);
358
359 /* Set EGA mapping if color is from the first or last eight */
360
361 if (i < 8)
362 X11DRV_PALETTE_mapEGAPixel[i] = color.pixel;
363 else if (i >= palette_size - 8 )
364 X11DRV_PALETTE_mapEGAPixel[i - (palette_size - 16)] = color.pixel;
365 }
366 wine_tsx11_unlock();
367
368 X11DRV_PALETTE_XPixelToPalette = X11DRV_PALETTE_PaletteToXPixel = NULL;
369
370 COLOR_gapStart = 256; COLOR_gapEnd = -1;
371
372 X11DRV_PALETTE_firstFree = (palette_size > NB_RESERVED_COLORS)?NB_RESERVED_COLORS/2 : -1;
373
374 return FALSE;
375 }
376
377 /***********************************************************************
378 * X11DRV_PALETTE_BuildSharedMap
379 *
380 * Allocate colorcells and initialize mapping tables.
381 */
382 static BOOL X11DRV_PALETTE_BuildSharedMap( const PALETTEENTRY *sys_pal_template )
383 {
384 XColor color;
385 unsigned long sysPixel[NB_RESERVED_COLORS];
386 unsigned long* pixDynMapping = NULL;
387 unsigned long plane_masks[1];
388 int i, j, warn = 0;
389 int diff, r, g, b, max = 256, bp = 0, wp = 1;
390 int step = 1;
391 int defaultCM_max_copy;
392 Colormap defaultCM;
393 XColor defaultColors[256];
394 HKEY hkey;
395
396 defaultCM_max_copy = 128;
397 COLOR_max = 256;
398
399 if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\x11drv", &hkey))
400 {
401 char buffer[20];
402 DWORD type, count;
403
404 count = sizeof(buffer);
405 if(!RegQueryValueExA(hkey, "CopyDefaultColors", 0, &type, buffer, &count))
406 defaultCM_max_copy = atoi(buffer);
407
408 count = sizeof(buffer);
409 if(!RegQueryValueExA(hkey, "AllocSystemColors", 0, &type, buffer, &count))
410 COLOR_max = atoi(buffer);
411
412 RegCloseKey(hkey);
413 }
414
415 /* Copy the first bunch of colors out of the default colormap to prevent
416 * colormap flashing as much as possible. We're likely to get the most
417 * important Window Manager colors, etc in the first 128 colors */
418 defaultCM = DefaultColormap( gdi_display, DefaultScreen(gdi_display) );
419
420 for (i = 0; i < defaultCM_max_copy; i++)
421 defaultColors[i].pixel = (long) i;
422 wine_tsx11_lock();
423 XQueryColors(gdi_display, defaultCM, &defaultColors[0], defaultCM_max_copy);
424 for (i = 0; i < defaultCM_max_copy; i++)
425 XAllocColor( gdi_display, X11DRV_PALETTE_PaletteXColormap, &defaultColors[i] );
426
427 if (COLOR_max > 256) COLOR_max = 256;
428 else if (COLOR_max < 20) COLOR_max = 20;
429 TRACE("%d colors configured.\n", COLOR_max);
430
431 TRACE("Building shared map - %i palette entries\n", palette_size);
432
433 /* Be nice and allocate system colors as read-only */
434
435 for( i = 0; i < NB_RESERVED_COLORS; i++ )
436 {
437 color.red = sys_pal_template[i].peRed * 65535 / 255;
438 color.green = sys_pal_template[i].peGreen * 65535 / 255;
439 color.blue = sys_pal_template[i].peBlue * 65535 / 255;
440 color.flags = DoRed | DoGreen | DoBlue;
441
442 if (!XAllocColor( gdi_display, X11DRV_PALETTE_PaletteXColormap, &color ))
443 {
444 XColor best, c;
445
446 if( !warn++ )
447 {
448 WARN("Not enough colors for the full system palette.\n");
449
450 bp = BlackPixel(gdi_display, DefaultScreen(gdi_display));
451 wp = WhitePixel(gdi_display, DefaultScreen(gdi_display));
452
453 max = (0xffffffff)>>(32 - screen_depth);
454 if( max > 256 )
455 {
456 step = max/256;
457 max = 256;
458 }
459 }
460
461 /* reinit color (XAllocColor() may change it)
462 * and map to the best shared colorcell */
463
464 color.red = sys_pal_template[i].peRed * 65535 / 255;
465 color.green = sys_pal_template[i].peGreen * 65535 / 255;
466 color.blue = sys_pal_template[i].peBlue * 65535 / 255;
467
468 best.pixel = best.red = best.green = best.blue = 0;
469 for( c.pixel = 0, diff = 0x7fffffff; c.pixel < max; c.pixel += step )
470 {
471 XQueryColor(gdi_display, X11DRV_PALETTE_PaletteXColormap, &c);
472 r = (c.red - color.red)>>8;
473 g = (c.green - color.green)>>8;
474 b = (c.blue - color.blue)>>8;
475 r = r*r + g*g + b*b;
476 if( r < diff ) { best = c; diff = r; }
477 }
478
479 if( XAllocColor(gdi_display, X11DRV_PALETTE_PaletteXColormap, &best) )
480 color.pixel = best.pixel;
481 else color.pixel = (i < NB_RESERVED_COLORS/2)? bp : wp;
482 }
483
484 sysPixel[i] = color.pixel;
485
486 TRACE("syscolor(%lx) -> pixel %i\n",
487 *(COLORREF*)(sys_pal_template+i), (int)color.pixel);
488
489 /* Set EGA mapping if color in the first or last eight */
490
491 if (i < 8)
492 X11DRV_PALETTE_mapEGAPixel[i] = color.pixel;
493 else if (i >= NB_RESERVED_COLORS - 8 )
494 X11DRV_PALETTE_mapEGAPixel[i - (NB_RESERVED_COLORS-16)] = color.pixel;
495 }
496 wine_tsx11_unlock();
497
498 /* now allocate changeable set */
499
500 if( !(X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED) )
501 {
502 int c_min = 0, c_max = palette_size, c_val;
503
504 TRACE("Dynamic colormap... \n");
505
506 /* let's become the first client that actually follows
507 * X guidelines and does binary search...
508 */
509
510 if((pixDynMapping = (unsigned long*)HeapAlloc(GetProcessHeap(), 0, sizeof(long)*palette_size)) == NULL) {
511 WARN("Out of memory while building system palette.\n");
512 return FALSE;
513 }
514
515 wine_tsx11_lock();
516 /* comment this out if you want to debug palette init */
517 XGrabServer(gdi_display);
518
519 while( c_max - c_min > 0 )
520 {
521 c_val = (c_max + c_min)/2 + (c_max + c_min)%2;
522
523 if( !XAllocColorCells(gdi_display, X11DRV_PALETTE_PaletteXColormap, False,
524 plane_masks, 0, pixDynMapping, c_val) )
525 c_max = c_val - 1;
526 else
527 {
528 XFreeColors(gdi_display, X11DRV_PALETTE_PaletteXColormap, pixDynMapping, c_val, 0);
529 c_min = c_val;
530 }
531 }
532
533 if( c_min > COLOR_max - NB_RESERVED_COLORS)
534 c_min = COLOR_max - NB_RESERVED_COLORS;
535
536 c_min = (c_min/2) + (c_min/2); /* need even set for split palette */
537
538 if( c_min > 0 )
539 if( !XAllocColorCells(gdi_display, X11DRV_PALETTE_PaletteXColormap, False,
540 plane_masks, 0, pixDynMapping, c_min) )
541 {
542 WARN("Inexplicable failure during colorcell allocation.\n");
543 c_min = 0;
544 }
545
546 palette_size = c_min + NB_RESERVED_COLORS;
547
548 XUngrabServer(gdi_display);
549 wine_tsx11_unlock();
550
551 TRACE("adjusted size %i colorcells\n", palette_size);
552 }
553 else if( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL )
554 {
555 /* virtual colorspace - ToPhysical takes care of
556 * color translations but we have to allocate full palette
557 * to maintain compatibility
558 */
559 palette_size = 256;
560 TRACE("Virtual colorspace - screendepth %i\n", screen_depth);
561 }
562 else palette_size = NB_RESERVED_COLORS; /* system palette only - however we can alloc a bunch
563 * of colors and map to them */
564
565 TRACE("Shared system palette uses %i colors.\n", palette_size);
566
567 /* set gap to account for pixel shortage. It has to be right in the center
568 * of the system palette because otherwise raster ops get screwed. */
569
570 if( palette_size >= 256 )
571 { COLOR_gapStart = 256; COLOR_gapEnd = -1; }
572 else
573 { COLOR_gapStart = palette_size/2; COLOR_gapEnd = 255 - palette_size/2; }
574
575 X11DRV_PALETTE_firstFree = ( palette_size > NB_RESERVED_COLORS &&
576 (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL || !(X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED)) )
577 ? NB_RESERVED_COLORS/2 : -1;
578
579 COLOR_sysPal = (PALETTEENTRY*)HeapAlloc(GetProcessHeap(),0,sizeof(PALETTEENTRY)*256);
580 if(COLOR_sysPal == NULL) {
581 ERR("Can not allocate system palette!\n");
582 return FALSE;
583 }
584
585 /* setup system palette entry <-> pixel mappings and fill in 20 fixed entries */
586
587 if (screen_depth <= 8)
588 {
589 X11DRV_PALETTE_XPixelToPalette = HeapAlloc( GetProcessHeap(), 0, 256 * sizeof(int) );
590 if(X11DRV_PALETTE_XPixelToPalette == NULL) {
591 ERR("Out of memory: XPixelToPalette!\n");
592 return FALSE;
593 }
594 for( i = 0; i < 256; i++ )
595 X11DRV_PALETTE_XPixelToPalette[i] = NB_PALETTE_EMPTY_VALUE;
596 }
597
598 /* for hicolor visuals PaletteToPixel mapping is used to skip
599 * RGB->pixel calculation in X11DRV_PALETTE_ToPhysical().
600 */
601
602 X11DRV_PALETTE_PaletteToXPixel = (int*)HeapAlloc(GetProcessHeap(),0,sizeof(int)*256);
603 if(X11DRV_PALETTE_PaletteToXPixel == NULL) {
604 ERR("Out of memory: PaletteToXPixel!\n");
605 return FALSE;
606 }
607
608 for( i = j = 0; i < 256; i++ )
609 {
610 if( i >= COLOR_gapStart && i <= COLOR_gapEnd )
611 {
612 X11DRV_PALETTE_PaletteToXPixel[i] = NB_PALETTE_EMPTY_VALUE;
613 COLOR_sysPal[i].peFlags = 0; /* mark as unused */
614 continue;
615 }
616
617 if( i < NB_RESERVED_COLORS/2 )
618 {
619 X11DRV_PALETTE_PaletteToXPixel[i] = sysPixel[i];
620 COLOR_sysPal[i] = sys_pal_template[i];
621 COLOR_sysPal[i].peFlags |= PC_SYS_USED;
622 }
623 else if( i >= 256 - NB_RESERVED_COLORS/2 )
624 {
625 X11DRV_PALETTE_PaletteToXPixel[i] = sysPixel[(i + NB_RESERVED_COLORS) - 256];
626 COLOR_sysPal[i] = sys_pal_template[(i + NB_RESERVED_COLORS) - 256];
627 COLOR_sysPal[i].peFlags |= PC_SYS_USED;
628 }
629 else if( pixDynMapping )
630 X11DRV_PALETTE_PaletteToXPixel[i] = pixDynMapping[j++];
631 else
632 X11DRV_PALETTE_PaletteToXPixel[i] = i;
633
634 TRACE("index %i -> pixel %i\n", i, X11DRV_PALETTE_PaletteToXPixel[i]);
635
636 if( X11DRV_PALETTE_XPixelToPalette )
637 X11DRV_PALETTE_XPixelToPalette[X11DRV_PALETTE_PaletteToXPixel[i]] = i;
638 }
639
640 if( pixDynMapping ) HeapFree(GetProcessHeap(), 0, pixDynMapping);
641
642 return TRUE;
643 }
644
645 /***********************************************************************
646 * Colormap Initialization
647 */
648 static void X11DRV_PALETTE_FillDefaultColors( const PALETTEENTRY *sys_pal_template )
649 {
650 /* initialize unused entries to what Windows uses as a color
651 * cube - based on Greg Kreider's code.
652 */
653
654 int i = 0, idx = 0;
655 int red, no_r, inc_r;
656 int green, no_g, inc_g;
657 int blue, no_b, inc_b;
658
659 if (palette_size <= NB_RESERVED_COLORS)
660 return;
661 while (i*i*i < (palette_size - NB_RESERVED_COLORS)) i++;
662 no_r = no_g = no_b = --i;
663 if ((no_r * (no_g+1) * no_b) < (palette_size - NB_RESERVED_COLORS)) no_g++;
664 if ((no_r * no_g * (no_b+1)) < (palette_size - NB_RESERVED_COLORS)) no_b++;
665 inc_r = (255 - NB_COLORCUBE_START_INDEX)/no_r;
666 inc_g = (255 - NB_COLORCUBE_START_INDEX)/no_g;
667 inc_b = (255 - NB_COLORCUBE_START_INDEX)/no_b;
668
669 wine_tsx11_lock();
670
671 idx = X11DRV_PALETTE_firstFree;
672
673 if( idx != -1 )
674 for (blue = NB_COLORCUBE_START_INDEX; blue < 256 && idx; blue += inc_b )
675 for (green = NB_COLORCUBE_START_INDEX; green < 256 && idx; green += inc_g )
676 for (red = NB_COLORCUBE_START_INDEX; red < 256 && idx; red += inc_r )
677 {
678 /* weird but true */
679
680 if( red == NB_COLORCUBE_START_INDEX && green == red && blue == green ) continue;
681
682 COLOR_sysPal[idx].peRed = red;
683 COLOR_sysPal[idx].peGreen = green;
684 COLOR_sysPal[idx].peBlue = blue;
685
686 /* set X color */
687
688 if( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL )
689 {
690 if (X11DRV_PALETTE_PRed.max != 255) no_r = (red * X11DRV_PALETTE_PRed.max) / 255;
691 if (X11DRV_PALETTE_PGreen.max != 255) no_g = (green * X11DRV_PALETTE_PGreen.max) / 255;
692 if (X11DRV_PALETTE_PBlue.max != 255) no_b = (blue * X11DRV_PALETTE_PBlue.max) / 255;
693
694 X11DRV_PALETTE_PaletteToXPixel[idx] = (no_r << X11DRV_PALETTE_PRed.shift) | (no_g << X11DRV_PALETTE_PGreen.shift) | (no_b << X11DRV_PALETTE_PBlue.shift);
695 }
696 else if( !(X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED) )
697 {
698 XColor color;
699 color.pixel = (X11DRV_PALETTE_PaletteToXPixel)? X11DRV_PALETTE_PaletteToXPixel[idx] : idx;
700 color.red = COLOR_sysPal[idx].peRed << 8;
701 color.green = COLOR_sysPal[idx].peGreen << 8;
702 color.blue = COLOR_sysPal[idx].peBlue << 8;
703 color.flags = DoRed | DoGreen | DoBlue;
704 XStoreColor(gdi_display, X11DRV_PALETTE_PaletteXColormap, &color);
705 }
706 idx = X11DRV_PALETTE_freeList[idx];
707 }
708
709 /* try to fill some entries in the "gap" with
710 * what's already in the colormap - they will be
711 * mappable to but not changeable. */
712
713 if( COLOR_gapStart < COLOR_gapEnd && X11DRV_PALETTE_XPixelToPalette )
714 {
715 XColor xc;
716 int r, g, b, max;
717
718 max = COLOR_max - (256 - (COLOR_gapEnd - COLOR_gapStart));
719 for ( i = 0, idx = COLOR_gapStart; i < 256 && idx <= COLOR_gapEnd; i++ )
720 if( X11DRV_PALETTE_XPixelToPalette[i] == NB_PALETTE_EMPTY_VALUE )
721 {
722 xc.pixel = i;
723
724 XQueryColor(gdi_display, X11DRV_PALETTE_PaletteXColormap, &xc);
725 r = xc.red>>8; g = xc.green>>8; b = xc.blue>>8;
726
727 if( xc.pixel < 256 && X11DRV_PALETTE_CheckSysColor( sys_pal_template, RGB(r, g, b)) &&
728 XAllocColor(gdi_display, X11DRV_PALETTE_PaletteXColormap, &xc) )
729 {
730 X11DRV_PALETTE_XPixelToPalette[xc.pixel] = idx;
731 X11DRV_PALETTE_PaletteToXPixel[idx] = xc.pixel;
732 *(COLORREF*)(COLOR_sysPal + idx) = RGB(r, g, b);
733 COLOR_sysPal[idx++].peFlags |= PC_SYS_USED;
734 if( --max <= 0 ) break;
735 }
736 }
737 COLOR_gapFilled = idx - COLOR_gapStart;
738 }
739 wine_tsx11_unlock();
740 }
741
742
743 /***********************************************************************
744 * X11DRV_IsSolidColor
745 *
746 * Check whether 'color' can be represented with a solid color.
747 */
748 BOOL X11DRV_IsSolidColor( COLORREF color )
749 {
750 int i;
751 const PALETTEENTRY *pEntry = COLOR_sysPal;
752
753 if (color & 0xff000000) return TRUE; /* indexed color */
754
755 if (!color || (color == 0xffffff)) return TRUE; /* black or white */
756
757 for (i = 0; i < 256 ; i++, pEntry++)
758 {
759 if( i < COLOR_gapStart || i > COLOR_gapEnd )
760 if ((GetRValue(color) == pEntry->peRed) &&
761 (GetGValue(color) == pEntry->peGreen) &&
762 (GetBValue(color) == pEntry->peBlue)) return TRUE;
763 }
764 return FALSE;
765 }
766
767
768 /***********************************************************************
769 * X11DRV_PALETTE_ToLogical
770 *
771 * Return RGB color for given X pixel.
772 */
773 COLORREF X11DRV_PALETTE_ToLogical(int pixel)
774 {
775 XColor color;
776
777 #if 0
778 /* truecolor visual */
779
780 if (screen_depth >= 24) return pixel;
781 #endif
782
783 /* check for hicolor visuals first */
784
785 if ( (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED) && !X11DRV_PALETTE_Graymax )
786 {
787 color.red = (pixel >> X11DRV_PALETTE_LRed.shift) & X11DRV_PALETTE_LRed.max;
788 if (X11DRV_PALETTE_LRed.scale<8)
789 color.red= color.red << (8-X11DRV_PALETTE_LRed.scale) |
790 color.red >> (2*X11DRV_PALETTE_LRed.scale-8);
791 color.green = (pixel >> X11DRV_PALETTE_LGreen.shift) & X11DRV_PALETTE_LGreen.max;
792 if (X11DRV_PALETTE_LGreen.scale<8)
793 color.green=color.green << (8-X11DRV_PALETTE_LGreen.scale) |
794 color.green >> (2*X11DRV_PALETTE_LGreen.scale-8);
795 color.blue = (pixel >> X11DRV_PALETTE_LBlue.shift) & X11DRV_PALETTE_LBlue.max;
796 if (X11DRV_PALETTE_LBlue.scale<8)
797 color.blue= color.blue << (8-X11DRV_PALETTE_LBlue.scale) |
798 color.blue >> (2*X11DRV_PALETTE_LBlue.scale-8);
799 return RGB(color.red,color.green,color.blue);
800 }
801
802 /* check if we can bypass X */
803
804 if ((screen_depth <= 8) && (pixel < 256) &&
805 !(X11DRV_PALETTE_PaletteFlags & (X11DRV_PALETTE_VIRTUAL | X11DRV_PALETTE_FIXED)) ) {
806 return ( *(COLORREF*)(COLOR_sysPal +
807 ((X11DRV_PALETTE_XPixelToPalette)?X11DRV_PALETTE_XPixelToPalette[pixel]:pixel)) ) & 0x00ffffff;
808 }
809
810 wine_tsx11_lock();
811 color.pixel = pixel;
812 XQueryColor(gdi_display, X11DRV_PALETTE_PaletteXColormap, &color);
813 wine_tsx11_unlock();
814 return RGB(color.red >> 8, color.green >> 8, color.blue >> 8);
815 }
816
817
818 /***********************************************************************
819 * X11DRV_SysPaletteLookupPixel
820 */
821 static int X11DRV_SysPaletteLookupPixel( COLORREF col, BOOL skipReserved )
822 {
823 int i, best = 0, diff = 0x7fffffff;
824 int r,g,b;
825
826 for( i = 0; i < palette_size && diff ; i++ )
827 {
828 if( !(COLOR_sysPal[i].peFlags & PC_SYS_USED) ||
829 (skipReserved && COLOR_sysPal[i].peFlags & PC_SYS_RESERVED) )
830 continue;
831
832 r = COLOR_sysPal[i].peRed - GetRValue(col);
833 g = COLOR_sysPal[i].peGreen - GetGValue(col);
834 b = COLOR_sysPal[i].peBlue - GetBValue(col);
835
836 r = r*r + g*g + b*b;
837
838 if( r < diff ) { best = i; diff = r; }
839 }
840 return best;
841 }
842
843
844 /***********************************************************************
845 * X11DRV_PALETTE_ToPhysical
846 *
847 * Return the physical color closest to 'color'.
848 */
849 int X11DRV_PALETTE_ToPhysical( X11DRV_PDEVICE *physDev, COLORREF color )
850 {
851 WORD index = 0;
852 HPALETTE hPal = physDev ? GetCurrentObject(physDev->hdc, OBJ_PAL ) : GetStockObject(DEFAULT_PALETTE);
853 unsigned char spec_type = color >> 24;
854 PALETTEOBJ* palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
855
856 /* palPtr can be NULL when DC is being destroyed */
857 if( !palPtr ) return 0;
858
859 if ( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED )
860 {
861 /* there is no colormap limitation; we are going to have to compute
862 * the pixel value from the visual information stored earlier
863 */
864
865 unsigned long red, green, blue;
866 unsigned idx = 0;
867
868 switch(spec_type)
869 {
870 case 1: /* PALETTEINDEX */
871
872 if( (idx = color & 0xffff) >= palPtr->logpalette.palNumEntries)
873 {
874 WARN("RGB(%lx) : idx %d is out of bounds, assuming black\n", color, idx);
875 GDI_ReleaseObj( hPal );
876 return 0;
877 }
878
879 if( palPtr->mapping )
880 {
881 int ret = palPtr->mapping[idx];
882 GDI_ReleaseObj( hPal );
883 return ret;
884 }
885 color = *(COLORREF*)(palPtr->logpalette.palPalEntry + idx);
886 break;
887
888 default:
889 color &= 0xffffff;
890 /* fall through to RGB */
891
892 case 0: /* RGB */
893 if (physDev && (physDev->depth == 1) )
894 {
895 GDI_ReleaseObj( hPal );
896 return (((color >> 16) & 0xff) +
897 ((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0;
898 }
899
900 }
901
902 red = GetRValue(color); green = GetGValue(color); blue = GetBValue(color);
903
904 if (X11DRV_PALETTE_Graymax)
905 {
906 /* grayscale only; return scaled value */
907 GDI_ReleaseObj( hPal );
908 return ( (red * 30 + green * 59 + blue * 11) * X11DRV_PALETTE_Graymax) / 25500;
909 }
910 else
911 {
912 /* scale each individually and construct the TrueColor pixel value */
913 if (X11DRV_PALETTE_PRed.scale < 8)
914 red = red >> (8-X11DRV_PALETTE_PRed.scale);
915 else if (X11DRV_PALETTE_PRed.scale > 8)
916 red = red << (X11DRV_PALETTE_PRed.scale-8) |
917 red >> (16-X11DRV_PALETTE_PRed.scale);
918 if (X11DRV_PALETTE_PGreen.scale < 8)
919 green = green >> (8-X11DRV_PALETTE_PGreen.scale);
920 else if (X11DRV_PALETTE_PGreen.scale > 8)
921 green = green << (X11DRV_PALETTE_PGreen.scale-8) |
922 green >> (16-X11DRV_PALETTE_PGreen.scale);
923 if (X11DRV_PALETTE_PBlue.scale < 8)
924 blue = blue >> (8-X11DRV_PALETTE_PBlue.scale);
925 else if (X11DRV_PALETTE_PBlue.scale > 8)
926 blue = blue << (X11DRV_PALETTE_PBlue.scale-8) |
927 blue >> (16-X11DRV_PALETTE_PBlue.scale);
928
929 GDI_ReleaseObj( hPal );
930 return (red << X11DRV_PALETTE_PRed.shift) | (green << X11DRV_PALETTE_PGreen.shift) | (blue << X11DRV_PALETTE_PBlue.shift);
931 }
932 }
933 else
934 {
935
936 if( !palPtr->mapping )
937 WARN("Palette %p is not realized\n", hPal);
938
939 switch(spec_type) /* we have to peruse DC and system palette */
940 {
941 default:
942 color &= 0xffffff;
943 /* fall through to RGB */
944
945 case 0: /* RGB */
946 if (physDev && (physDev->depth == 1) )
947 {
948 GDI_ReleaseObj( hPal );
949 return (((color >> 16) & 0xff) +
950 ((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0;
951 }
952
953 index = X11DRV_SysPaletteLookupPixel( color, FALSE);
954 if (X11DRV_PALETTE_PaletteToXPixel) index = X11DRV_PALETTE_PaletteToXPixel[index];
955
956 /* TRACE(palette,"RGB(%lx) -> pixel %i\n", color, index);
957 */
958 break;
959 case 1: /* PALETTEINDEX */
960 index = color & 0xffff;
961
962 if( index >= palPtr->logpalette.palNumEntries )
963 WARN("RGB(%lx) : index %i is out of bounds\n", color, index);
964 else if( palPtr->mapping ) index = palPtr->mapping[index];
965
966 /* TRACE(palette,"PALETTEINDEX(%04x) -> pixel %i\n", (WORD)color, index);
967 */
968 break;
969 case 2: /* PALETTERGB */
970 index = GetNearestPaletteIndex( hPal, color );
971 if (palPtr->mapping) index = palPtr->mapping[index];
972 /* TRACE(palette,"PALETTERGB(%lx) -> pixel %i\n", color, index);
973 */
974 break;
975 }
976 }
977
978 GDI_ReleaseObj( hPal );
979 return index;
980 }
981
982 /***********************************************************************
983 * X11DRV_PALETTE_LookupSystemXPixel
984 */
985 static int X11DRV_PALETTE_LookupSystemXPixel(COLORREF col)
986 {
987 int i, best = 0, diff = 0x7fffffff;
988 int size = palette_size;
989 int r,g,b;
990
991 for( i = 0; i < size && diff ; i++ )
992 {
993 if( i == NB_RESERVED_COLORS/2 )
994 {
995 int newi = size - NB_RESERVED_COLORS/2;
996 if (newi>i) i=newi;
997 }
998
999 r = COLOR_sysPal[i].peRed - GetRValue(col);
1000 g = COLOR_sysPal[i].peGreen - GetGValue(col);
1001 b = COLOR_sysPal[i].peBlue - GetBValue(col);
1002
1003 r = r*r + g*g + b*b;
1004
1005 if( r < diff ) { best = i; diff = r; }
1006 }
1007
1008 return (X11DRV_PALETTE_PaletteToXPixel)? X11DRV_PALETTE_PaletteToXPixel[best] : best;
1009 }
1010
1011 /***********************************************************************
1012 * X11DRV_PALETTE_FormatSystemPalette
1013 */
1014 static void X11DRV_PALETTE_FormatSystemPalette(void)
1015 {
1016 /* Build free list so we'd have an easy way to find
1017 * out if there are any available colorcells.
1018 */
1019
1020 int i, j = X11DRV_PALETTE_firstFree = NB_RESERVED_COLORS/2;
1021
1022 COLOR_sysPal[j].peFlags = 0;
1023 for( i = NB_RESERVED_COLORS/2 + 1 ; i < 256 - NB_RESERVED_COLORS/2 ; i++ )
1024 if( i < COLOR_gapStart || i > COLOR_gapEnd )
1025 {
1026 COLOR_sysPal[i].peFlags = 0; /* unused tag */
1027 X11DRV_PALETTE_freeList[j] = i; /* next */
1028 j = i;
1029 }
1030 X11DRV_PALETTE_freeList[j] = 0;
1031 }
1032
1033 /***********************************************************************
1034 * X11DRV_PALETTE_CheckSysColor
1035 */
1036 static BOOL X11DRV_PALETTE_CheckSysColor( const PALETTEENTRY *sys_pal_template, COLORREF c)
1037 {
1038 int i;
1039 for( i = 0; i < NB_RESERVED_COLORS; i++ )
1040 if( c == (*(COLORREF*)(sys_pal_template + i) & 0x00ffffff) )
1041 return 0;
1042 return 1;
1043 }
1044
1045
1046 /***********************************************************************
1047 * X11DRV_LookupSysPaletteExact
1048 */
1049 static int X11DRV_LookupSysPaletteExact( COLORREF col )
1050 {
1051 int i;
1052 BYTE r = GetRValue(col), g = GetGValue(col), b = GetBValue(col);
1053 for( i = 0; i < palette_size; i++ )
1054 {
1055 if( COLOR_sysPal[i].peFlags & PC_SYS_USED ) /* skips gap */
1056 if( COLOR_sysPal[i].peRed == r &&
1057 COLOR_sysPal[i].peGreen == g &&
1058 COLOR_sysPal[i].peBlue == b )
1059 return i;
1060 }
1061 return -1;
1062 }
1063
1064
1065 /***********************************************************************
1066 * X11DRV_PALETTE_SetMapping
1067 *
1068 * Set the color-mapping table for selected palette.
1069 * Return number of entries which mapping has changed.
1070 */
1071 static UINT X11DRV_PALETTE_SetMapping( PALETTEOBJ* palPtr, UINT uStart, UINT uNum, BOOL mapOnly )
1072 {
1073 char flag;
1074 int prevMapping = (palPtr->mapping) ? 1 : 0;
1075 int index;
1076 UINT iRemapped = 0;
1077 int* mapping;
1078
1079 /* reset dynamic system palette entries */
1080
1081 if( !mapOnly && X11DRV_PALETTE_firstFree != -1)
1082 X11DRV_PALETTE_FormatSystemPalette();
1083
1084 /* initialize palette mapping table */
1085 if (palPtr->mapping)
1086 mapping = HeapReAlloc( GetProcessHeap(), 0, palPtr->mapping,
1087 sizeof(int)*palPtr->logpalette.palNumEntries);
1088 else
1089 mapping = HeapAlloc( GetProcessHeap(), 0,
1090 sizeof(int)*palPtr->logpalette.palNumEntries);
1091
1092 if(mapping == NULL) {
1093 ERR("Can not allocate new mapping -- memory exausted!\n");
1094 return 0;
1095 }
1096 palPtr->mapping = mapping;
1097
1098 if (uStart >= palPtr->logpalette.palNumEntries) return 0;
1099
1100 if (uStart + uNum > palPtr->logpalette.palNumEntries)
1101 uNum = palPtr->logpalette.palNumEntries - uStart;
1102
1103 for( uNum += uStart; uStart < uNum; uStart++ )
1104 {
1105 index = -1;
1106 flag = PC_SYS_USED;
1107
1108 switch( palPtr->logpalette.palPalEntry[uStart].peFlags & 0x07 )
1109 {
1110 case PC_EXPLICIT: /* palette entries are indices into system palette */
1111 index = *(WORD*)(palPtr->logpalette.palPalEntry + uStart);
1112 if( index > 255 || (index >= COLOR_gapStart && index <= COLOR_gapEnd) )
1113 {
1114 WARN("PC_EXPLICIT: idx %d out of system palette, assuming black.\n", index);
1115 index = 0;
1116 }
1117 break;
1118
1119 case PC_RESERVED: /* forbid future mappings to this entry */
1120 flag |= PC_SYS_RESERVED;
1121
1122 /* fall through */
1123 default: /* try to collapse identical colors */
1124 index = X11DRV_LookupSysPaletteExact(*(COLORREF*)(palPtr->logpalette.palPalEntry + uStart));
1125 /* fall through */
1126 case PC_NOCOLLAPSE:
1127 if( index < 0 )
1128 {
1129 if( X11DRV_PALETTE_firstFree > 0 && !(X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED) )
1130 {
1131 XColor color;
1132 index = X11DRV_PALETTE_firstFree; /* ought to be available */
1133 X11DRV_PALETTE_firstFree = X11DRV_PALETTE_freeList[index];
1134
1135 color.pixel = (X11DRV_PALETTE_PaletteToXPixel) ? X11DRV_PALETTE_PaletteToXPixel[index] : index;
1136 color.red = palPtr->logpalette.palPalEntry[uStart].peRed << 8;
1137 color.green = palPtr->logpalette.palPalEntry[uStart].peGreen << 8;
1138 color.blue = palPtr->logpalette.palPalEntry[uStart].peBlue << 8;
1139 color.flags = DoRed | DoGreen | DoBlue;
1140 wine_tsx11_lock();
1141 XStoreColor(gdi_display, X11DRV_PALETTE_PaletteXColormap, &color);
1142 wine_tsx11_unlock();
1143
1144 COLOR_sysPal[index] = palPtr->logpalette.palPalEntry[uStart];
1145 COLOR_sysPal[index].peFlags = flag;
1146 X11DRV_PALETTE_freeList[index] = 0;
1147
1148 if( X11DRV_PALETTE_PaletteToXPixel ) index = X11DRV_PALETTE_PaletteToXPixel[index];
1149 break;
1150 }
1151 else if ( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL )
1152 {
1153 index = X11DRV_PALETTE_ToPhysical( NULL, 0x00ffffff &
1154 *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart));
1155 break;
1156 }
1157
1158 /* we have to map to existing entry in the system palette */
1159
1160 index = X11DRV_SysPaletteLookupPixel( *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart), TRUE);
1161 }
1162 palPtr->logpalette.palPalEntry[uStart].peFlags |= PC_SYS_USED;
1163
1164 if( X11DRV_PALETTE_PaletteToXPixel ) index = X11DRV_PALETTE_PaletteToXPixel[index];
1165 break;
1166 }
1167
1168 if( !prevMapping || palPtr->mapping[uStart] != index ) iRemapped++;
1169 palPtr->mapping[uStart] = index;
1170
1171 TRACE("entry %i (%lx) -> pixel %i\n", uStart,
1172 *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart), index);
1173
1174 }
1175 return iRemapped;
1176 }
1177
1178 /***********************************************************************
1179 * GetSystemPaletteEntries (X11DRV.@)
1180 */
1181 UINT X11DRV_GetSystemPaletteEntries( X11DRV_PDEVICE *physDev, UINT start, UINT count,
1182 LPPALETTEENTRY entries )
1183 {
1184 UINT i;
1185
1186 if (!entries) return palette_size;
1187 if (start >= palette_size) return 0;
1188 if (start + count >= palette_size) count = palette_size - start;
1189
1190 for (i = 0; i < count; i++)
1191 {
1192 entries[i].peRed = COLOR_sysPal[start + i].peRed;
1193 entries[i].peGreen = COLOR_sysPal[start + i].peGreen;
1194 entries[i].peBlue = COLOR_sysPal[start + i].peBlue;
1195 entries[i].peFlags = 0;
1196 TRACE("\tidx(%02x) -> RGB(%08lx)\n", start + i, *(COLORREF*)(entries + i) );
1197 }
1198 return count;
1199 }
1200
1201
1202 /***********************************************************************
1203 * GetNearestColor (X11DRV.@)
1204 */
1205 COLORREF X11DRV_GetNearestColor( X11DRV_PDEVICE *physDev, COLORREF color )
1206 {
1207 unsigned char spec_type = color >> 24;
1208 COLORREF nearest;
1209
1210 if (!palette_size) return color;
1211
1212 if (spec_type == 1 || spec_type == 2)
1213 {
1214 /* we need logical palette for PALETTERGB and PALETTEINDEX colorrefs */
1215
1216 UINT index;
1217 PALETTEENTRY entry;
1218 HPALETTE hpal = GetCurrentObject( physDev->hdc, OBJ_PAL );
1219
1220 if (!hpal) hpal = GetStockObject( DEFAULT_PALETTE );
1221
1222 if (spec_type == 2) /* PALETTERGB */
1223 index = GetNearestPaletteIndex( hpal, color );
1224 else /* PALETTEINDEX */
1225 index = LOWORD(color);
1226
1227 if (!GetPaletteEntries( hpal, index, 1, &entry ))
1228 {
1229 WARN("RGB(%lx) : idx %d is out of bounds, assuming NULL\n", color, index );
1230 if (!GetPaletteEntries( hpal, 0, 1, &entry )) return CLR_INVALID;
1231 }
1232 color = RGB( entry.peRed, entry.peGreen, entry.peBlue );
1233 }
1234 color &= 0x00ffffff;
1235 nearest = (0x00ffffff & *(COLORREF*)(COLOR_sysPal + X11DRV_SysPaletteLookupPixel(color, FALSE)));
1236
1237 TRACE("(%06lx): returning %06lx\n", color, nearest );
1238 return nearest;
1239 }
1240
1241
1242 /***********************************************************************
1243 * RealizePalette (X11DRV.@)
1244 */
1245 UINT X11DRV_RealizePalette( X11DRV_PDEVICE *physDev, HPALETTE hpal, BOOL primary )
1246 {
1247 UINT ret;
1248 PALETTEOBJ *palPtr;
1249
1250 if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL) return 0;
1251
1252 if (!(palPtr = GDI_GetObjPtr( hpal, PALETTE_MAGIC ))) return 0;
1253 ret = X11DRV_PALETTE_SetMapping( palPtr, 0, palPtr->logpalette.palNumEntries, !primary );
1254 GDI_ReleaseObj( hpal );
1255 return ret;
1256 }
1257
1258
1259 /***********************************************************************
1260 * RealizeDefaultPalette (X11DRV.@)
1261 */
1262 UINT X11DRV_RealizeDefaultPalette( X11DRV_PDEVICE *physDev )
1263 {
1264 UINT ret = 0;
1265
1266 if (palette_size && GetObjectType(physDev->hdc) != OBJ_MEMDC)
1267 {
1268 PALETTEOBJ* palPtr = GDI_GetObjPtr( GetStockObject(DEFAULT_PALETTE), PALETTE_MAGIC );
1269 if (palPtr)
1270 {
1271 /* lookup is needed to account for SetSystemPaletteUse() stuff */
1272 int i, index;
1273
1274 for( i = 0; i < 20; i++ )
1275 {
1276 index = X11DRV_PALETTE_LookupSystemXPixel(*(COLORREF*)(palPtr->logpalette.palPalEntry + i));
1277 /* mapping is allocated in COLOR_InitPalette() */
1278 if( index != palPtr->mapping[i] )
1279 {
1280 palPtr->mapping[i]=index;
1281 ret++;
1282 }
1283 }
1284 GDI_ReleaseObj( GetStockObject(DEFAULT_PALETTE) );
1285 }
1286 }
1287 return ret;
1288 }
Maarten's multimedia branch