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