]> git.saurik.com Git - wxWidgets.git/blob - src/x11/bitmap.cpp
projects / wxWidgets.git / blob
? search:


9a4f71feb1d12d09b3effc572a60a49a9f14d161
[wxWidgets.git] / src / x11 / bitmap.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: bitmap.cpp
3 // Purpose: wxBitmap
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 #ifdef __GNUG__
13 #pragma implementation "bitmap.h"
14 #endif
15
16 #include "wx/setup.h"
17 #include "wx/utils.h"
18 #include "wx/palette.h"
19 #include "wx/bitmap.h"
20 #include "wx/icon.h"
21 #include "wx/log.h"
22 #include "wx/control.h"
23 #include "wx/dcmemory.h"
24 #include "wx/image.h"
25 #include "wx/app.h"
26
27 #ifdef __VMS__
28 #pragma message disable nosimpint
29 #endif
30 #ifdef __VMS__
31 #pragma message enable nosimpint
32 #endif
33
34 #include "wx/x11/private.h"
35
36 #if wxHAVE_LIB_XPM
37 #include <X11/xpm.h>
38 #endif
39 #include <math.h>
40
41
42 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
43 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
44
45 wxBitmapRefData::wxBitmapRefData()
46 {
47 m_ok = FALSE;
48 m_width = 0;
49 m_height = 0;
50 m_depth = 0;
51 m_quality = 0;
52 m_numColors = 0;
53 m_bitmapMask = NULL;
54
55 m_pixmap = (WXPixmap) 0;
56 m_display = (WXDisplay*) 0;
57
58 m_freePixmap = TRUE; //TODO: necessary?
59 m_freeColors = (unsigned long*) 0;
60 m_freeColorsCount = 0;
61 }
62
63 wxBitmapRefData::~wxBitmapRefData()
64 {
65 if (m_pixmap && m_freePixmap)
66 XFreePixmap ((Display*) m_display, (Pixmap) m_pixmap);
67
68 if (m_freeColors)
69 {
70 int screen = DefaultScreen((Display*) m_display);
71 Colormap cmp = DefaultColormap((Display*) m_display,screen);
72 long llp;
73 for(llp = 0;llp < m_freeColorsCount;llp++)
74 XFreeColors((Display*) m_display, cmp, &m_freeColors[llp], 1, 0L);
75 delete m_freeColors;
76 };
77
78 if (m_bitmapMask)
79 delete m_bitmapMask;
80 m_bitmapMask = NULL;
81 }
82
83 wxList wxBitmap::sm_handlers;
84
85 #define M_BMPDATA ((wxBitmapRefData *)m_refData)
86
87 wxBitmap::wxBitmap()
88 {
89 m_refData = NULL;
90 }
91
92 wxBitmap::~wxBitmap()
93 {
94 }
95
96 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
97 {
98 m_refData = new wxBitmapRefData;
99
100 (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
101 }
102
103 wxBitmap::wxBitmap(int w, int h, int d)
104 {
105 (void)Create(w, h, d);
106 }
107
108 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
109 {
110 (void) Create(data, type, width, height, depth);
111 }
112
113 wxBitmap::wxBitmap(const wxString& filename, long type)
114 {
115 LoadFile(filename, (int)type);
116 }
117
118 bool wxBitmap::Create(int w, int h, int d)
119 {
120 UnRef();
121
122 m_refData = new wxBitmapRefData;
123
124 if (d < 1)
125 d = wxDisplayDepth();
126
127 M_BITMAPDATA->m_width = w;
128 M_BITMAPDATA->m_height = h;
129 M_BITMAPDATA->m_depth = d;
130 M_BITMAPDATA->m_freePixmap = TRUE;
131
132 Display *dpy = (Display*) wxGetDisplay();
133
134 M_BITMAPDATA->m_display = dpy; /* MATTHEW: [4] Remember the display */
135
136 M_BITMAPDATA->m_pixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
137 w, h, d);
138
139 M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_pixmap != (WXPixmap) 0) ;
140 return M_BITMAPDATA->m_ok;
141 }
142
143 bool wxBitmap::LoadFile(const wxString& filename, long type)
144 {
145 UnRef();
146
147 m_refData = new wxBitmapRefData;
148
149 wxBitmapHandler *handler = FindHandler(type);
150
151 if ( handler == NULL ) {
152 wxImage image;
153 if (!image.LoadFile( filename, type )) return FALSE;
154 if (image.Ok())
155 {
156 *this = image.ConvertToBitmap();
157 return TRUE;
158 }
159 else return FALSE;
160 }
161
162 return handler->LoadFile(this, filename, type, -1, -1);
163 }
164
165 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
166 {
167 UnRef();
168
169 m_refData = new wxBitmapRefData;
170
171 wxBitmapHandler *handler = FindHandler(type);
172
173 if ( handler == NULL ) {
174 wxLogWarning("no data bitmap handler for type %d defined.", type);
175
176 return FALSE;
177 }
178
179 return handler->Create(this, data, type, width, height, depth);
180 }
181
182 bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
183 {
184 wxBitmapHandler *handler = FindHandler(type);
185
186 if ( handler == NULL ) { // try wxImage
187 wxImage image( *this );
188 if (image.Ok()) return image.SaveFile( filename, type );
189 else return FALSE;
190 }
191
192 return handler->SaveFile(this, filename, type, palette);
193 }
194
195 void wxBitmap::SetWidth(int w)
196 {
197 if (!M_BITMAPDATA)
198 m_refData = new wxBitmapRefData;
199
200 M_BITMAPDATA->m_width = w;
201 }
202
203 void wxBitmap::SetHeight(int h)
204 {
205 if (!M_BITMAPDATA)
206 m_refData = new wxBitmapRefData;
207
208 M_BITMAPDATA->m_height = h;
209 }
210
211 void wxBitmap::SetDepth(int d)
212 {
213 if (!M_BITMAPDATA)
214 m_refData = new wxBitmapRefData;
215
216 M_BITMAPDATA->m_depth = d;
217 }
218
219 void wxBitmap::SetQuality(int q)
220 {
221 if (!M_BITMAPDATA)
222 m_refData = new wxBitmapRefData;
223
224 M_BITMAPDATA->m_quality = q;
225 }
226
227 void wxBitmap::SetOk(bool isOk)
228 {
229 if (!M_BITMAPDATA)
230 m_refData = new wxBitmapRefData;
231
232 M_BITMAPDATA->m_ok = isOk;
233 }
234
235 void wxBitmap::SetPalette(const wxPalette& palette)
236 {
237 if (!M_BITMAPDATA)
238 m_refData = new wxBitmapRefData;
239
240 M_BITMAPDATA->m_bitmapPalette = palette ;
241 }
242
243 void wxBitmap::SetMask(wxMask *mask)
244 {
245 if (!M_BITMAPDATA)
246 m_refData = new wxBitmapRefData;
247
248 M_BITMAPDATA->m_bitmapMask = mask ;
249 }
250
251 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
252 {
253 wxCHECK_MSG( Ok() &&
254 (rect.x >= 0) && (rect.y >= 0) &&
255 (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height),
256 wxNullBitmap, wxT("invalid bitmap or bitmap region") );
257
258 wxBitmap ret( rect.width, rect.height, 0 );
259 wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
260
261 // The remaining still TODO
262 return ret;
263 }
264
265 void wxBitmap::AddHandler(wxBitmapHandler *handler)
266 {
267 sm_handlers.Append(handler);
268 }
269
270 void wxBitmap::InsertHandler(wxBitmapHandler *handler)
271 {
272 sm_handlers.Insert(handler);
273 }
274
275 bool wxBitmap::RemoveHandler(const wxString& name)
276 {
277 wxBitmapHandler *handler = FindHandler(name);
278 if ( handler )
279 {
280 sm_handlers.DeleteObject(handler);
281 return TRUE;
282 }
283 else
284 return FALSE;
285 }
286
287 wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
288 {
289 wxNode *node = sm_handlers.First();
290 while ( node )
291 {
292 wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
293 if ( handler->GetName() == name )
294 return handler;
295 node = node->Next();
296 }
297 return NULL;
298 }
299
300 wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
301 {
302 wxNode *node = sm_handlers.First();
303 while ( node )
304 {
305 wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
306 if ( handler->GetExtension() == extension &&
307 (bitmapType == -1 || handler->GetType() == bitmapType) )
308 return handler;
309 node = node->Next();
310 }
311 return NULL;
312 }
313
314 wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
315 {
316 wxNode *node = sm_handlers.First();
317 while ( node )
318 {
319 wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
320 if (handler->GetType() == bitmapType)
321 return handler;
322 node = node->Next();
323 }
324 return NULL;
325 }
326
327 /*
328 * wxMask
329 */
330
331 wxMask::wxMask()
332 {
333 m_pixmap = (WXPixmap) 0;
334 }
335
336 // Construct a mask from a bitmap and a colour indicating
337 // the transparent area
338 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
339 {
340 m_pixmap = (WXPixmap) 0;
341
342 Create(bitmap, colour);
343 }
344
345 // Construct a mask from a bitmap and a palette index indicating
346 // the transparent area
347 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
348 {
349 m_pixmap = (WXPixmap) 0;
350
351 Create(bitmap, paletteIndex);
352 }
353
354 // Construct a mask from a mono bitmap (copies the bitmap).
355 wxMask::wxMask(const wxBitmap& bitmap)
356 {
357 m_pixmap = (WXPixmap) 0;
358
359 Create(bitmap);
360 }
361
362 wxMask::~wxMask()
363 {
364 // TODO: this may be the wrong display
365 if ( m_pixmap )
366 XFreePixmap ((Display*) wxGetDisplay(), (Pixmap) m_pixmap);
367 }
368
369 // Create a mask from a mono bitmap (copies the bitmap).
370 bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap))
371 {
372 // TODO
373 return FALSE;
374 }
375
376 // Create a mask from a bitmap and a palette index indicating
377 // the transparent area
378 bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex))
379 {
380 // TODO
381 return FALSE;
382 }
383
384 // Create a mask from a bitmap and a colour indicating
385 // the transparent area
386 bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour))
387 {
388 // TODO
389 return FALSE;
390 }
391
392 /*
393 * wxBitmapHandler
394 */
395
396 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
397
398 bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(type),
399 int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
400 {
401 return FALSE;
402 }
403
404 bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), long WXUNUSED(type),
405 int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
406 {
407 return FALSE;
408 }
409
410 bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), int WXUNUSED(type),
411 const wxPalette *WXUNUSED(palette))
412 {
413 return FALSE;
414 }
415
416 /*
417 * Standard handlers
418 */
419
420 class WXDLLEXPORT wxXBMFileHandler: public wxBitmapHandler
421 {
422 DECLARE_DYNAMIC_CLASS(wxXBMFileHandler)
423 public:
424 inline wxXBMFileHandler()
425 {
426 m_name = "XBM file";
427 m_extension = "xbm";
428 m_type = wxBITMAP_TYPE_XBM;
429 };
430
431 virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
432 int desiredWidth, int desiredHeight);
433 };
434 IMPLEMENT_DYNAMIC_CLASS(wxXBMFileHandler, wxBitmapHandler)
435
436 bool wxXBMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long WXUNUSED(flags),
437 int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
438 {
439 M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
440
441 int hotX, hotY;
442 unsigned int w, h;
443 Pixmap pixmap;
444
445 Display *dpy = (Display*) wxGetDisplay();
446 M_BITMAPDATA->m_display = (WXDisplay*) dpy;
447
448 int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)),
449 (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY);
450 M_BITMAPHANDLERDATA->m_width = w;
451 M_BITMAPHANDLERDATA->m_height = h;
452 M_BITMAPHANDLERDATA->m_depth = 1;
453 M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
454
455 if ((value == BitmapFileInvalid) ||
456 (value == BitmapOpenFailed) ||
457 (value == BitmapNoMemory))
458 {
459 M_BITMAPHANDLERDATA->m_ok = FALSE;
460 M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) 0;
461 }
462 else
463 M_BITMAPHANDLERDATA->m_ok = TRUE;
464
465 return M_BITMAPHANDLERDATA->m_ok ;
466 }
467
468 class WXDLLEXPORT wxXBMDataHandler: public wxBitmapHandler
469 {
470 DECLARE_DYNAMIC_CLASS(wxXBMDataHandler)
471 public:
472 inline wxXBMDataHandler()
473 {
474 m_name = "XBM data";
475 m_extension = "xbm";
476 m_type = wxBITMAP_TYPE_XBM_DATA;
477 };
478
479 virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
480 };
481 IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
482
483 bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags),
484 int width, int height, int WXUNUSED(depth))
485 {
486 M_BITMAPHANDLERDATA->m_width = width;
487 M_BITMAPHANDLERDATA->m_height = height;
488 M_BITMAPHANDLERDATA->m_depth = 1;
489 M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
490
491 Display *dpy = (Display*) wxGetDisplay();
492 M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
493
494 M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) XCreateBitmapFromData (dpy, RootWindow (dpy, DefaultScreen (dpy)), (char*) data, width, height);
495 M_BITMAPHANDLERDATA->m_ok = (M_BITMAPHANDLERDATA->m_pixmap != (WXPixmap) 0) ;
496
497 return TRUE;
498 }
499
500 void wxBitmap::CleanUpHandlers()
501 {
502 wxNode *node = sm_handlers.First();
503 while ( node )
504 {
505 wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
506 wxNode *next = node->Next();
507 delete handler;
508 delete node;
509 node = next;
510 }
511 }
512
513 void wxBitmap::InitStandardHandlers()
514 {
515 // Initialize all standard bitmap or derived class handlers here.
516 AddHandler(new wxXBMFileHandler);
517 AddHandler(new wxXBMDataHandler);
518
519 // XPM will be handled by wxImage
520 }
521
522 // Creates a bitmap with transparent areas drawn in
523 // the given colour.
524 wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour)
525 {
526 wxBitmap newBitmap(bitmap.GetWidth(),
527 bitmap.GetHeight(),
528 bitmap.GetDepth());
529 wxMemoryDC destDC;
530 wxMemoryDC srcDC;
531 srcDC.SelectObject(bitmap);
532 destDC.SelectObject(newBitmap);
533
534 #if 0
535 wxBrush brush(colour, wxSOLID);
536 destDC.SetOptimization(FALSE);
537 destDC.SetBackground(brush);
538 destDC.Clear();
539 destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), & srcDC, 0, 0, wxCOPY, TRUE);
540 #endif
541
542 return newBitmap;
543 }
544
545 //-----------------------------------------------------------------------------
546 // wxImage conversion routines
547 //-----------------------------------------------------------------------------
548
549 /*
550
551 Date: Wed, 05 Jan 2000 11:45:40 +0100
552 From: Frits Boel <boel@niob.knaw.nl>
553 To: julian.smart@ukonline.co.uk
554 Subject: Patch for Motif ConvertToBitmap
555
556 Hi Julian,
557
558 I've been working on a wxWin application for image processing. From the
559 beginning, I was surprised by the (lack of) speed of ConvertToBitmap,
560 till I looked in the source code of image.cpp. I saw that converting a
561 wxImage to a bitmap with 8-bit pixels is done with comparing every pixel
562 to the 256 colors of the palet. A very time-consuming piece of code!
563
564 Because I wanted a faster application, I've made a 'patch' for this. In
565 short: every pixel of the image is compared to a sorted list with
566 colors. If the color is found in the list, the palette entry is
567 returned; if the color is not found, the color palette is searched and
568 then the palette entry is returned and the color added to the sorted
569 list.
570
571 Maybe there is another method for this, namely changing the palette
572 itself (if the colors are known, as is the case with tiffs with a
573 colormap). I did not look at this, maybe someone else did?
574
575 The code of the patch is attached, have a look on it, and maybe you will
576 ship it with the next release of wxMotif?
577
578 Regards,
579
580 Frits Boel
581 Software engineer at Hubrecht Laboratory, The Netherlands.
582
583 */
584
585 class wxSearchColor
586 {
587 public:
588 wxSearchColor( void );
589 wxSearchColor( int size, XColor *colors );
590 ~wxSearchColor( void );
591
592 int SearchColor( int r, int g, int b );
593 private:
594 int AddColor( unsigned int value, int pos );
595
596 int size;
597 XColor *colors;
598 unsigned int *color;
599 int *entry;
600
601 int bottom;
602 int top;
603 };
604
605 wxSearchColor::wxSearchColor( void )
606 {
607 size = 0;
608 colors = (XColor*) NULL;
609 color = (unsigned int *) NULL;
610 entry = (int*) NULL;
611
612 bottom = 0;
613 top = 0;
614 }
615
616 wxSearchColor::wxSearchColor( int size_, XColor *colors_ )
617 {
618 int i;
619 size = size_;
620 colors = colors_;
621 color = new unsigned int[size];
622 entry = new int [size];
623
624 for (i = 0; i < size; i++ ) {
625 entry[i] = -1;
626 }
627
628 bottom = top = ( size >> 1 );
629 }
630
631 wxSearchColor::~wxSearchColor( void )
632 {
633 if ( color ) delete color;
634 if ( entry ) delete entry;
635 }
636
637 int wxSearchColor::SearchColor( int r, int g, int b )
638 {
639 unsigned int value = ( ( ( r * 256 ) + g ) * 256 ) + b;
640 int begin = bottom;
641 int end = top;
642 int middle = 0;
643
644 while ( begin <= end ) {
645
646 middle = ( begin + end ) >> 1;
647
648 if ( value == color[middle] ) {
649 return( entry[middle] );
650 } else if ( value < color[middle] ) {
651 end = middle - 1;
652 } else {
653 begin = middle + 1;
654 }
655
656 }
657
658 return AddColor( value, middle );
659 }
660
661 int wxSearchColor::AddColor( unsigned int value, int pos )
662 {
663 int i;
664 int pixel = -1;
665 int max = 3 * (65536);
666 for ( i = 0; i < 256; i++ ) {
667 int rdiff = ((value >> 8) & 0xFF00 ) - colors[i].red;
668 int gdiff = ((value ) & 0xFF00 ) - colors[i].green;
669 int bdiff = ((value << 8) & 0xFF00 ) - colors[i].blue;
670 int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
671 if (sum < max) { pixel = i; max = sum; }
672 }
673
674 if ( entry[pos] < 0 ) {
675 color[pos] = value;
676 entry[pos] = pixel;
677 } else if ( value < color[pos] ) {
678
679 if ( bottom > 0 ) {
680 for ( i = bottom; i < pos; i++ ) {
681 color[i-1] = color[i];
682 entry[i-1] = entry[i];
683 }
684 bottom--;
685 color[pos-1] = value;
686 entry[pos-1] = pixel;
687 } else if ( top < size-1 ) {
688 for ( i = top; i >= pos; i-- ) {
689 color[i+1] = color[i];
690 entry[i+1] = entry[i];
691 }
692 top++;
693 color[pos] = value;
694 entry[pos] = pixel;
695 }
696
697 } else {
698
699 if ( top < size-1 ) {
700 for ( i = top; i > pos; i-- ) {
701 color[i+1] = color[i];
702 entry[i+1] = entry[i];
703 }
704 top++;
705 color[pos+1] = value;
706 entry[pos+1] = pixel;
707 } else if ( bottom > 0 ) {
708 for ( i = bottom; i < pos; i++ ) {
709 color[i-1] = color[i];
710 entry[i-1] = entry[i];
711 }
712 bottom--;
713 color[pos] = value;
714 entry[pos] = pixel;
715 }
716
717 }
718
719 return( pixel );
720 }
721
722
723 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
724 {
725 wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
726 wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") )
727
728 m_refData = new wxBitmapRefData();
729
730 int width = image.GetWidth();
731 int height = image.GetHeight();
732
733 SetHeight( height );
734 SetWidth( width );
735
736 Display *dpy = (Display*) wxGetDisplay();
737 Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
738 int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
739
740 // Create image
741
742 XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
743 data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
744
745 Create( width, height, bpp );
746
747 // Create mask
748
749 XImage *mask_image = (XImage*) NULL;
750 if (image.HasMask())
751 {
752 mask_image = XCreateImage( dpy, vis, 1, ZPixmap, 0, 0, width, height, 32, 0 );
753 mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
754 }
755
756 // Retrieve depth info
757
758 XVisualInfo vinfo_template;
759 XVisualInfo *vi;
760
761 vinfo_template.visual = vis;
762 vinfo_template.visualid = XVisualIDFromVisual( vis );
763 vinfo_template.depth = bpp;
764 int nitem = 0;
765
766 vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
767
768 wxCHECK_MSG( vi, FALSE, wxT("no visual") );
769
770 XFree( vi );
771
772 if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
773 if (bpp < 8) bpp = 8;
774
775 // Render
776
777 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
778 byte_order b_o = RGB;
779
780 if (bpp >= 24)
781 {
782 if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask)) b_o = RGB;
783 else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask)) b_o = RGB;
784 else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask)) b_o = BRG;
785 else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
786 else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask)) b_o = GRB;
787 else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask)) b_o = GBR;
788 }
789
790 int r_mask = image.GetMaskRed();
791 int g_mask = image.GetMaskGreen();
792 int b_mask = image.GetMaskBlue();
793
794 XColor colors[256];
795 if (bpp == 8)
796 {
797 Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
798
799 for (int i = 0; i < 256; i++) colors[i].pixel = i;
800 XQueryColors( dpy, cmap, colors, 256 );
801 }
802
803 wxSearchColor scolor( 256, colors );
804 unsigned char* data = image.GetData();
805
806 bool hasMask = image.HasMask();
807
808 int index = 0;
809 for (int y = 0; y < height; y++)
810 {
811 for (int x = 0; x < width; x++)
812 {
813 int r = data[index];
814 index++;
815 int g = data[index];
816 index++;
817 int b = data[index];
818 index++;
819
820 if (hasMask)
821 {
822 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
823 XPutPixel( mask_image, x, y, 0 );
824 else
825 XPutPixel( mask_image, x, y, 1 );
826 }
827
828 switch (bpp)
829 {
830 case 8:
831 {
832 #if 0 // Old, slower code
833 int pixel = -1;
834 /*
835 if (wxTheApp->m_colorCube)
836 {
837 pixel = wxTheApp->m_colorCube
838 [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
839 }
840 else
841 {
842 */
843 int max = 3 * (65536);
844 for (int i = 0; i < 256; i++)
845 {
846 int rdiff = (r << 8) - colors[i].red;
847 int gdiff = (g << 8) - colors[i].green;
848 int bdiff = (b << 8) - colors[i].blue;
849 int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
850 if (sum < max) { pixel = i; max = sum; }
851 }
852 /*
853 }
854 */
855 #endif
856
857 // And this is all to get the 'right' color...
858 int pixel = scolor.SearchColor( r, g, b );
859 XPutPixel( data_image, x, y, pixel );
860 break;
861 }
862 case 15:
863 {
864 int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
865 XPutPixel( data_image, x, y, pixel );
866 break;
867 }
868 case 16:
869 {
870 int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
871 XPutPixel( data_image, x, y, pixel );
872 break;
873 }
874 case 32:
875 case 24:
876 {
877 int pixel = 0;
878 switch (b_o)
879 {
880 case RGB: pixel = (r << 16) | (g << 8) | b; break;
881 case RBG: pixel = (r << 16) | (b << 8) | g; break;
882 case BRG: pixel = (b << 16) | (r << 8) | g; break;
883 case BGR: pixel = (b << 16) | (g << 8) | r; break;
884 case GRB: pixel = (g << 16) | (r << 8) | b; break;
885 case GBR: pixel = (g << 16) | (b << 8) | r; break;
886 }
887 XPutPixel( data_image, x, y, pixel );
888 }
889 default: break;
890 }
891 } // for
892 } // for
893
894 // Blit picture
895
896 XGCValues gcvalues;
897 gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) );
898 GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues );
899 XPutImage( dpy, (Drawable)GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height );
900
901 XDestroyImage( data_image );
902 XFreeGC( dpy, gc );
903
904 // Blit mask
905 if (image.HasMask())
906 {
907 wxBitmap maskBitmap(width, height, 1);
908
909 GC gcMask = XCreateGC( dpy, (Pixmap) maskBitmap.GetPixmap(), 0, (XGCValues*)NULL );
910 XPutImage( dpy, (Drawable)maskBitmap.GetPixmap(), gcMask, mask_image, 0, 0, 0, 0, width, height );
911
912 XDestroyImage( mask_image );
913 XFreeGC( dpy, gcMask );
914
915 wxMask* mask = new wxMask;
916 mask->SetPixmap(maskBitmap.GetPixmap());
917
918 SetMask(mask);
919
920 maskBitmap.SetPixmapNull();
921 }
922
923
924 return TRUE;
925 }
926
927 wxImage wxBitmap::ConvertToImage() const
928 {
929 wxImage image;
930
931 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
932
933 Display *dpy = (Display*) wxGetDisplay();
934 Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
935 int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
936
937 XImage *ximage = XGetImage( dpy,
938 (Drawable)GetPixmap(),
939 0, 0,
940 GetWidth(), GetHeight(),
941 AllPlanes, ZPixmap );
942
943 wxCHECK_MSG( ximage, wxNullImage, wxT("couldn't create image") );
944
945 image.Create( GetWidth(), GetHeight() );
946 char unsigned *data = image.GetData();
947
948 if (!data)
949 {
950 XDestroyImage( ximage );
951 wxFAIL_MSG( wxT("couldn't create image") );
952 return wxNullImage;
953 }
954
955 /*
956 GdkImage *gdk_image_mask = (GdkImage*) NULL;
957 if (GetMask())
958 {
959 gdk_image_mask = gdk_image_get( GetMask()->GetBitmap(),
960 0, 0,
961 GetWidth(), GetHeight() );
962
963 image.SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
964 }
965 */
966
967 // Retrieve depth info
968
969 XVisualInfo vinfo_template;
970 XVisualInfo *vi;
971
972 vinfo_template.visual = vis;
973 vinfo_template.visualid = XVisualIDFromVisual( vis );
974 vinfo_template.depth = bpp;
975 int nitem = 0;
976
977 vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
978
979 wxCHECK_MSG( vi, wxNullImage, wxT("no visual") );
980
981 if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
982
983 XFree( vi );
984
985 XColor colors[256];
986 if (bpp == 8)
987 {
988 Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
989
990 for (int i = 0; i < 256; i++) colors[i].pixel = i;
991 XQueryColors( dpy, cmap, colors, 256 );
992 }
993
994 long pos = 0;
995 for (int j = 0; j < GetHeight(); j++)
996 {
997 for (int i = 0; i < GetWidth(); i++)
998 {
999 int pixel = XGetPixel( ximage, i, j );
1000 if (bpp <= 8)
1001 {
1002 data[pos] = colors[pixel].red >> 8;
1003 data[pos+1] = colors[pixel].green >> 8;
1004 data[pos+2] = colors[pixel].blue >> 8;
1005 } else if (bpp == 15)
1006 {
1007 data[pos] = (pixel >> 7) & 0xf8;
1008 data[pos+1] = (pixel >> 2) & 0xf8;
1009 data[pos+2] = (pixel << 3) & 0xf8;
1010 } else if (bpp == 16)
1011 {
1012 data[pos] = (pixel >> 8) & 0xf8;
1013 data[pos+1] = (pixel >> 3) & 0xfc;
1014 data[pos+2] = (pixel << 3) & 0xf8;
1015 } else
1016 {
1017 data[pos] = (pixel >> 16) & 0xff;
1018 data[pos+1] = (pixel >> 8) & 0xff;
1019 data[pos+2] = pixel & 0xff;
1020 }
1021
1022 /*
1023 if (gdk_image_mask)
1024 {
1025 int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
1026 if (mask_pixel == 0)
1027 {
1028 data[pos] = 16;
1029 data[pos+1] = 16;
1030 data[pos+2] = 16;
1031 }
1032 }
1033 */
1034
1035 pos += 3;
1036 }
1037 }
1038
1039 XDestroyImage( ximage );
1040 /*
1041 if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
1042 */
1043
1044 return image;
1045 }
1046
1047 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
1048 {
1049 wxBitmap* bitmap = (wxBitmap*) & icon;
1050
1051 *this = *bitmap;
1052
1053 return TRUE;
1054 }
wxWidgets (Impactor)