]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/x11/palette.cpp
Don't use "Cancel" button in the about dialog of the listctrl sample.
[wxWidgets.git] / src / x11 / palette.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/x11/palette.cpp
3// Purpose: wxPalette
4// Author: Julian Smart
5// Modified by:
6// Created: 17/09/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12/*
13 * Colour map
14 *
15 * When constructed with the default constructor, we start from
16 * the wxApp::GetMainColormap, allocating additional read-only cells
17 * in Create(). The cells are freed on the next call to Create()
18 * or when the destructor is called.
19 */
20
21/* Wolfram Gloger <u7y22ab@sunmail.lrz-muenchen.de>
22I have implemented basic colormap support for the X11 versions of
23wxWidgets, notably wxPalette::Create(). The way I did it is to
24allocate additional read-only color cells in the default colormap. In
25general you will get arbitrary pixel values assigned to these new
26cells and therefore I added a method wxPalette::TransferBitmap()
27which maps the pixel values 0..n to the real ones obtained with
28Create(). This is only implemented for the popular case of 8-bit
29depth.
30
31Allocating read-write color cells would involve installing a private
32X11 colormap for a particular window, and AFAIK this is not
33recommended; only the window manager should do this... Also, it is
34not the functionality that wxPalette::Create() aims to provide.
35 */
36
37// for compilers that support precompilation, includes "wx.h".
38#include "wx/wxprec.h"
39
40#include "wx/palette.h"
41
42#ifndef WX_PRECOMP
43 #include "wx/app.h"
44 #include "wx/utils.h"
45 #include "wx/window.h"
46#endif
47
48#ifdef __VMS__
49#pragma message disable nosimpint
50#endif
51
52#ifdef __VMS__
53#pragma message enable nosimpint
54#endif
55#include "wx/x11/private.h"
56
57IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
58IMPLEMENT_DYNAMIC_CLASS(wxXPalette, wxObject)
59
60/*
61* Palette
62*
63*/
64
65wxXPalette::wxXPalette()
66{
67 m_cmap = (WXColormap) 0;
68 m_pix_array_n = 0;
69 m_pix_array = (unsigned long*) 0;
70 m_display = (WXDisplay*) 0;
71 m_destroyable = false;
72}
73
74wxPaletteRefData::wxPaletteRefData()
75{
76}
77
78wxPaletteRefData::~wxPaletteRefData()
79{
80 Display *display = NULL;
81
82 wxList::compatibility_iterator node, next;
83
84 for (node = m_palettes.GetFirst(); node; node = next) {
85 wxXPalette *c = (wxXPalette *)node->GetData();
86 unsigned long *pix_array = c->m_pix_array;
87 Colormap cmap = (Colormap) c->m_cmap;
88 bool destroyable = c->m_destroyable;
89 int pix_array_n = c->m_pix_array_n;
90 display = (Display*) c->m_display;
91
92 if (pix_array_n > 0)
93 {
94#if !wxUSE_NANOX
95 // XFreeColors(display, cmap, pix_array, pix_array_n, 0);
96 // Be careful not to free '0' pixels...
97 int i, j;
98 for(i=j=0; i<pix_array_n; i=j) {
99 while(j<pix_array_n && pix_array[j]!=0) j++;
100 if(j > i) XFreeColors(display, cmap, &pix_array[i], j-i, 0);
101 while(j<pix_array_n && pix_array[j]==0) j++;
102 }
103#endif
104 delete [] pix_array;
105 }
106
107 if (destroyable)
108 XFreeColormap(display, cmap);
109
110 next = node->GetNext();
111 m_palettes.Erase(node);
112 delete c;
113 }
114}
115
116wxPalette::wxPalette()
117{
118}
119
120wxPalette::wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
121{
122 Create(n, red, green, blue);
123}
124
125wxPalette::~wxPalette()
126{
127}
128
129bool wxPalette::Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
130{
131 UnRef();
132
133 if (!n) {
134 return false;
135 }
136
137 m_refData = new wxPaletteRefData;
138
139 XColor xcol;
140 Display* display = (Display*) wxGetDisplay();
141
142 unsigned long *pix_array;
143 Colormap cmap;
144 int pix_array_n;
145
146 cmap = (Colormap) wxTheApp->GetMainColormap(display);
147
148 pix_array = new unsigned long[n];
149 if (!pix_array)
150 return false;
151
152 pix_array_n = n;
153 xcol.flags = DoRed | DoGreen | DoBlue;
154 for(int i = 0; i < n; i++) {
155 xcol.red = (unsigned short)red[i] << 8;
156 xcol.green = (unsigned short)green[i] << 8;
157 xcol.blue = (unsigned short)blue[i] << 8;
158 pix_array[i] = (XAllocColor(display, cmap, &xcol) == 0) ? 0 : xcol.pixel;
159 }
160
161 wxXPalette *c = new wxXPalette;
162
163 c->m_pix_array_n = pix_array_n;
164 c->m_pix_array = pix_array;
165 c->m_cmap = (WXColormap) cmap;
166 c->m_display = (WXDisplay*) display;
167 c->m_destroyable = false;
168 M_PALETTEDATA->m_palettes.Append(c);
169
170 return true;
171}
172
173wxGDIRefData *wxPalette::CreateGDIRefData() const
174{
175 return new wxPaletteRefData;
176}
177
178wxGDIRefData *
179wxPalette::CloneGDIRefData(const wxGDIRefData * WXUNUSED(data)) const
180{
181 wxFAIL_MSG( wxS("Cloning palettes is not implemented in wxX11.") );
182
183 return new wxPaletteRefData;
184}
185
186int wxPalette::GetPixel(unsigned char WXUNUSED(red),
187 unsigned char WXUNUSED(green),
188 unsigned char WXUNUSED(blue)) const
189{
190 if ( !m_refData )
191 return wxNOT_FOUND;
192
193 // TODO
194 return wxNOT_FOUND;
195}
196
197bool wxPalette::GetRGB(int index, unsigned char *WXUNUSED(red), unsigned char *WXUNUSED(green), unsigned char *WXUNUSED(blue)) const
198{
199 if ( !m_refData )
200 return false;
201
202 if (index < 0 || index > 255)
203 return false;
204
205 // TODO
206 return false;
207}
208
209WXColormap wxPalette::GetXColormap(WXDisplay* display) const
210{
211 if (!M_PALETTEDATA || (M_PALETTEDATA->m_palettes.GetCount() == 0))
212 return wxTheApp->GetMainColormap(display);
213
214 wxList::compatibility_iterator node = M_PALETTEDATA->m_palettes.GetFirst();
215 if (!display && node)
216 {
217 wxXPalette* p = (wxXPalette*) node->GetData();
218 return p->m_cmap;
219 }
220 while (node)
221 {
222 wxXPalette* p = (wxXPalette*) node->GetData();
223 if (p->m_display == display)
224 return p->m_cmap;
225
226 node = node->GetNext();
227 }
228
229 /* Make a new one: */
230 wxXPalette *c = new wxXPalette;
231 wxXPalette *first = (wxXPalette *)M_PALETTEDATA->m_palettes.GetFirst()->GetData();
232 XColor xcol;
233 int pix_array_n = first->m_pix_array_n;
234
235 c->m_pix_array_n = pix_array_n;
236 c->m_pix_array = new unsigned long[pix_array_n];
237 c->m_display = display;
238 c->m_cmap = wxTheApp->GetMainColormap(display);
239 c->m_destroyable = false;
240
241 xcol.flags = DoRed | DoGreen | DoBlue;
242 int i;
243 for (i = 0; i < pix_array_n; i++)
244 {
245 xcol.pixel = first->m_pix_array[i];
246 XQueryColor((Display*) first->m_display, (Colormap) first->m_cmap, &xcol);
247 c->m_pix_array[i] =
248 (XAllocColor((Display*) display, (Colormap) c->m_cmap, &xcol) == 0) ? 0 : xcol.pixel;
249 }
250
251 // wxPalette* nonConstThis = (wxPalette*) this;
252
253 M_PALETTEDATA->m_palettes.Append(c);
254
255 return c->m_cmap;
256}
257
258bool wxPalette::TransferBitmap(void *data, int depth, int size)
259{
260 switch(depth) {
261 case 8:
262 {
263 unsigned char *uptr = (unsigned char *)data;
264 int pix_array_n;
265 unsigned long *pix_array = GetXPixArray((Display*) wxGetDisplay(), &pix_array_n);
266 while(size-- > 0)
267 {
268 if((int)*uptr < pix_array_n)
269 *uptr = (unsigned char)pix_array[*uptr];
270 uptr++;
271 }
272
273 return true;
274 }
275 default:
276 return false;
277 }
278}
279
280bool wxPalette::TransferBitmap8(unsigned char *data, unsigned long sz,
281 void *dest, unsigned int bpp)
282{
283 int pix_array_n;
284 unsigned long *pix_array = GetXPixArray((Display*) wxGetDisplay(), &pix_array_n);
285 switch(bpp) {
286 case 8: {
287 unsigned char *dptr = (unsigned char *)dest;
288 while(sz-- > 0) {
289 if((int)*data < pix_array_n)
290 *dptr = (unsigned char)pix_array[*data];
291 data++;
292 dptr++;
293 }
294 break;
295 }
296 case 16: {
297 unsigned short *dptr = (unsigned short *)dest;
298 while(sz-- > 0) {
299 if((int)*data < pix_array_n)
300 *dptr = (unsigned short)pix_array[*data];
301 data++;
302 dptr++;
303 }
304 break;
305 }
306 case 24: {
307 struct rgb24 { unsigned char r, g, b; } *dptr = (struct rgb24 *)dest;
308 while(sz-- > 0) {
309 if((int)*data < pix_array_n) {
310 dptr->r = pix_array[*data] & 0xFF;
311 dptr->g = (pix_array[*data] >> 8) & 0xFF;
312 dptr->b = (pix_array[*data] >> 16) & 0xFF;
313 }
314 data++;
315 dptr++;
316 }
317 break;
318 }
319 case 32: {
320 unsigned long *dptr = (unsigned long *)dest;
321 while(sz-- > 0) {
322 if((int)*data < pix_array_n)
323 *dptr = pix_array[*data];
324 data++;
325 dptr++;
326 }
327 break;
328 }
329 default:
330 return false;
331 }
332 return true;
333}
334
335unsigned long *wxPalette::GetXPixArray(WXDisplay *display, int *n)
336{
337 if (!M_PALETTEDATA)
338 return (unsigned long*) 0;
339 wxList::compatibility_iterator node;
340
341 for (node = M_PALETTEDATA->m_palettes.GetFirst(); node; node = node->GetNext())
342 {
343 wxXPalette *c = (wxXPalette *)node->GetData();
344 if (c->m_display == display)
345 {
346 if (n)
347 *n = c->m_pix_array_n;
348 return c->m_pix_array;
349 }
350 }
351
352 /* Not found; call GetXColormap, which will create it, then this again */
353 if (GetXColormap(display))
354 return GetXPixArray(display, n);
355 else
356 return (unsigned long*) 0;
357}
358
359void wxPalette::PutXColormap(WXDisplay* display, WXColormap cm, bool dp)
360{
361 UnRef();
362
363 m_refData = new wxPaletteRefData;
364
365 wxXPalette *c = new wxXPalette;
366
367 c->m_pix_array_n = 0;
368 c->m_pix_array = (unsigned long*) NULL;
369 c->m_display = display;
370 c->m_cmap = cm;
371 c->m_destroyable = dp;
372
373 M_PALETTEDATA->m_palettes.Append(c);
374}