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