src/gtk/bitmap.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        bitmap.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifdef __GNUG__
  11 #pragma implementation "bitmap.h"
  12 #endif
  13
  14 #include "wx/bitmap.h"
  15 #include "wx/icon.h"
  16 #include "wx/filefn.h"
  17 #include "gdk/gdkprivate.h"
  18 #include "gdk/gdkx.h"
  19
  20 //-----------------------------------------------------------------------------
  21 // wxMask
  22 //-----------------------------------------------------------------------------
  23
  24 IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
  25
  26 wxMask::wxMask(void)
  27 {
  28     m_bitmap = (GdkBitmap *) NULL;
  29 }
  30
  31 wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour) )
  32 {
  33 }
  34
  35 wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex) )
  36 {
  37 }
  38
  39 wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap) )
  40 {
  41 }
  42
  43 wxMask::~wxMask(void)
  44 {
  45     if (m_bitmap) gdk_bitmap_unref( m_bitmap );
  46 }
  47
  48 GdkBitmap *wxMask::GetBitmap(void) const
  49 {
  50     return m_bitmap;
  51 }
  52
  53 //-----------------------------------------------------------------------------
  54 // wxBitmap
  55 //-----------------------------------------------------------------------------
  56
  57 class wxBitmapRefData: public wxObjectRefData
  58 {
  59 public:
  60   wxBitmapRefData(void);
  61   ~wxBitmapRefData(void);
  62
  63   GdkPixmap      *m_pixmap;
  64   GdkBitmap      *m_bitmap;
  65   wxMask         *m_mask;
  66   int             m_width;
  67   int             m_height;
  68   int             m_bpp;
  69   wxPalette      *m_palette;
  70 };
  71
  72 wxBitmapRefData::wxBitmapRefData(void)
  73 {
  74     m_pixmap = (GdkPixmap *) NULL;
  75     m_bitmap = (GdkBitmap *) NULL;
  76     m_mask = (wxMask *) NULL;
  77     m_width = 0;
  78     m_height = 0;
  79     m_bpp = 0;
  80     m_palette = (wxPalette *) NULL;
  81 }
  82
  83 wxBitmapRefData::~wxBitmapRefData(void)
  84 {
  85     if (m_pixmap) gdk_pixmap_unref( m_pixmap );
  86     if (m_bitmap) gdk_bitmap_unref( m_bitmap );
  87     if (m_mask) delete m_mask;
  88     if (m_palette) delete m_palette;
  89 }
  90
  91 //-----------------------------------------------------------------------------
  92
  93 #define M_BMPDATA ((wxBitmapRefData *)m_refData)
  94
  95 IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
  96
  97 wxBitmap::wxBitmap(void)
  98 {
  99     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 100 }
 101
 102 wxBitmap::wxBitmap( int width, int height, int depth )
 103 {
 104     wxCHECK_RET( (width > 0) && (height > 0), "invalid bitmap size" )
 105     wxCHECK_RET( (depth > 0) || (depth == -1), "invalid bitmap depth" )
 106
 107     m_refData = new wxBitmapRefData();
 108
 109     GdkWindow *parent = (GdkWindow*) &gdk_root_parent;
 110
 111     M_BMPDATA->m_mask = (wxMask *) NULL;
 112     M_BMPDATA->m_pixmap = gdk_pixmap_new( parent, width, height, depth );
 113     M_BMPDATA->m_width = width;
 114     M_BMPDATA->m_height = height;
 115     M_BMPDATA->m_bpp = gdk_window_get_visual( parent )->depth;
 116
 117     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 118 }
 119
 120 wxBitmap::wxBitmap( const char **bits )
 121 {
 122     wxCHECK_RET( bits != NULL, "invalid bitmap data" )
 123
 124     m_refData = new wxBitmapRefData();
 125
 126     GdkBitmap *mask = (GdkBitmap*) NULL;
 127     GdkWindow *parent = (GdkWindow*) &gdk_root_parent;
 128
 129     M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm_d( parent, &mask, NULL, (gchar **) bits );
 130
 131     if (mask)
 132     {
 133         M_BMPDATA->m_mask = new wxMask();
 134         M_BMPDATA->m_mask->m_bitmap = mask;
 135     }
 136
 137     gdk_window_get_size( M_BMPDATA->m_pixmap, &(M_BMPDATA->m_width), &(M_BMPDATA->m_height) );
 138
 139     M_BMPDATA->m_bpp = gdk_window_get_visual( parent )->depth;  // ?
 140     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 141 }
 142
 143 wxBitmap::wxBitmap( char **bits )
 144 {
 145     wxCHECK_RET( bits != NULL, "invalid bitmap data" )
 146
 147     m_refData = new wxBitmapRefData();
 148
 149     GdkBitmap *mask = (GdkBitmap*) NULL;
 150     GdkWindow *parent = (GdkWindow*) &gdk_root_parent;
 151
 152     M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm_d( parent, &mask, NULL, (gchar **) bits );
 153
 154     if (mask)
 155     {
 156         M_BMPDATA->m_mask = new wxMask();
 157         M_BMPDATA->m_mask->m_bitmap = mask;
 158     }
 159
 160     gdk_window_get_size( M_BMPDATA->m_pixmap, &(M_BMPDATA->m_width), &(M_BMPDATA->m_height) );
 161
 162     M_BMPDATA->m_bpp = gdk_window_get_visual( parent )->depth;  // ?
 163     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 164 }
 165
 166 wxBitmap::wxBitmap( const wxBitmap& bmp )
 167 {
 168     Ref( bmp );
 169
 170     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 171 }
 172
 173 wxBitmap::wxBitmap( const wxBitmap* bmp )
 174 {
 175     if (bmp) Ref( *bmp );
 176
 177     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 178 }
 179
 180 wxBitmap::wxBitmap( const wxString &filename, int type )
 181 {
 182     LoadFile( filename, type );
 183
 184     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 185 }
 186
 187 wxBitmap::wxBitmap( const char bits[], int width, int height, int WXUNUSED(depth))
 188 {
 189     m_refData = new wxBitmapRefData();
 190
 191     M_BMPDATA->m_mask = (wxMask *) NULL;
 192     M_BMPDATA->m_bitmap =
 193       gdk_bitmap_create_from_data( (GdkWindow*) &gdk_root_parent, (gchar *) bits, width, height );
 194     M_BMPDATA->m_width = width;
 195     M_BMPDATA->m_height = height;
 196     M_BMPDATA->m_bpp = 1;
 197
 198     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 199 }
 200
 201 wxBitmap::~wxBitmap(void)
 202 {
 203     if (wxTheBitmapList) wxTheBitmapList->DeleteObject(this);
 204 }
 205
 206 wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )
 207 {
 208     if (*this == bmp) return (*this);
 209     Ref( bmp );
 210     return *this;
 211 }
 212
 213 bool wxBitmap::operator == ( const wxBitmap& bmp )
 214 {
 215     return m_refData == bmp.m_refData;
 216 }
 217
 218 bool wxBitmap::operator != ( const wxBitmap& bmp )
 219 {
 220     return m_refData != bmp.m_refData;
 221 }
 222
 223 bool wxBitmap::Ok(void) const
 224 {
 225     return (m_refData != NULL);
 226 }
 227
 228 int wxBitmap::GetHeight(void) const
 229 {
 230     wxCHECK_MSG( Ok(), -1, "invalid bitmap" );
 231
 232     return M_BMPDATA->m_height;
 233 }
 234
 235 int wxBitmap::GetWidth(void) const
 236 {
 237     wxCHECK_MSG( Ok(), -1, "invalid bitmap" );
 238
 239     return M_BMPDATA->m_width;
 240 }
 241
 242 int wxBitmap::GetDepth(void) const
 243 {
 244     wxCHECK_MSG( Ok(), -1, "invalid bitmap" );
 245
 246     return M_BMPDATA->m_bpp;
 247 }
 248
 249 void wxBitmap::SetHeight( int height )
 250 {
 251     if (!Ok()) return;
 252
 253     wxFAIL_MSG( "wxBitmap::SetHeight not implemented" );
 254
 255     M_BMPDATA->m_height = height;
 256 }
 257
 258 void wxBitmap::SetWidth( int width )
 259 {
 260     if (!Ok()) return;
 261
 262     wxFAIL_MSG( "wxBitmap::SetWidth not implemented" );
 263
 264     M_BMPDATA->m_width = width;
 265 }
 266
 267 void wxBitmap::SetDepth( int depth )
 268 {
 269     if (!Ok()) return;
 270
 271     wxFAIL_MSG( "wxBitmap::SetDepth not implemented" );
 272
 273     M_BMPDATA->m_bpp = depth;
 274 }
 275
 276 wxMask *wxBitmap::GetMask(void) const
 277 {
 278     wxCHECK_MSG( Ok(), (wxMask *) NULL, "invalid bitmap" );
 279
 280     return M_BMPDATA->m_mask;
 281 }
 282
 283 void wxBitmap::SetMask( wxMask *mask )
 284 {
 285     wxCHECK_RET( Ok(), "invalid bitmap" );
 286
 287     if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
 288
 289     M_BMPDATA->m_mask = mask;
 290 }
 291
 292 bool wxBitmap::SaveFile( const wxString &name, int type, wxPalette *WXUNUSED(palette) )
 293 {
 294     wxCHECK_MSG( Ok(), FALSE, "invalid bitmap" );
 295
 296     if (type == wxBITMAP_TYPE_PNG)
 297     {
 298         wxImage image = ConvertToImage();
 299         if (image.Ok()) return image.SaveFile( name, type );
 300     }
 301
 302     return FALSE;
 303 }
 304
 305 bool wxBitmap::LoadFile( const wxString &name, int type )
 306 {
 307     UnRef();
 308
 309     if (!wxFileExists(name)) return FALSE;
 310
 311     if (type == wxBITMAP_TYPE_XPM)
 312     {
 313         m_refData = new wxBitmapRefData();
 314
 315         GdkBitmap *mask = (GdkBitmap*) NULL;
 316         GdkWindow *parent = (GdkWindow*) &gdk_root_parent;
 317
 318         M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm( parent, &mask, NULL, name );
 319
 320         if (mask)
 321         {
 322            M_BMPDATA->m_mask = new wxMask();
 323            M_BMPDATA->m_mask->m_bitmap = mask;
 324         }
 325
 326         gdk_window_get_size( M_BMPDATA->m_pixmap, &(M_BMPDATA->m_width), &(M_BMPDATA->m_height) );
 327         M_BMPDATA->m_bpp = gdk_window_get_visual( parent )->depth;
 328     }
 329     else if (type == wxBITMAP_TYPE_PNG)
 330     {
 331         wxImage image;
 332         image.LoadFile( name, type );
 333         if (image.Ok()) *this = wxBitmap( image );
 334     }
 335     else if (type == wxBITMAP_TYPE_BMP)
 336     {
 337         wxImage image;
 338         image.LoadFile( name, type );
 339         if (image.Ok()) *this = wxBitmap( image );
 340     }
 341     else
 342         return FALSE;
 343
 344     return TRUE;
 345 }
 346
 347 wxPalette *wxBitmap::GetPalette(void) const
 348 {
 349     if (!Ok()) return (wxPalette *) NULL;
 350
 351     return M_BMPDATA->m_palette;
 352 }
 353
 354 GdkPixmap *wxBitmap::GetPixmap(void) const
 355 {
 356     wxCHECK_MSG( Ok(), (GdkPixmap *) NULL, "invalid bitmap" );
 357
 358     return M_BMPDATA->m_pixmap;
 359 }
 360
 361 GdkBitmap *wxBitmap::GetBitmap(void) const
 362 {
 363     wxCHECK_MSG( Ok(), (GdkBitmap *) NULL, "invalid bitmap" );
 364
 365     return M_BMPDATA->m_bitmap;
 366 }
 367
 368 wxBitmap::wxBitmap( const wxImage &image )
 369 {
 370     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 371
 372     if (!image.Ok()) return;
 373
 374     m_refData = new wxBitmapRefData();
 375
 376     M_BMPDATA->m_height = image.GetHeight();
 377     M_BMPDATA->m_width = image.GetWidth();
 378     int width = image.GetWidth();
 379     int height = image.GetHeight();
 380
 381     // Create picture
 382
 383     GdkImage *data_image =
 384       gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), width, height );
 385
 386     M_BMPDATA->m_pixmap =
 387       gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, -1 );
 388
 389     // Create mask
 390
 391     GdkImage *mask_image = (GdkImage*) NULL;
 392
 393     if (image.HasMask())
 394     {
 395         unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
 396
 397         mask_image =  gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
 398
 399         M_BMPDATA->m_mask = new wxMask();
 400         M_BMPDATA->m_mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
 401     }
 402
 403     // Retrieve depth
 404
 405     GdkVisual *visual = gdk_window_get_visual( M_BMPDATA->m_pixmap );
 406     if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
 407     int bpp = visual->depth;
 408     if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
 409     if (bpp < 8) bpp = 8;
 410
 411     // Render
 412
 413     enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
 414     byte_order b_o = RGB;
 415
 416     if (bpp >= 24)
 417     {
 418         GdkVisual *visual = gdk_visual_get_system();
 419         if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask))      b_o = RGB;
 420         else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask))  b_o = RGB;
 421         else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask))   b_o = BRG;
 422         else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
 423         else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask))   b_o = GRB;
 424         else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask))  b_o = GBR;
 425     }
 426
 427     int r_mask = image.GetMaskRed();
 428     int g_mask = image.GetMaskGreen();
 429     int b_mask = image.GetMaskBlue();
 430
 431     unsigned char* data = image.GetData();
 432
 433     int index = 0;
 434     for (int y = 0; y < height; y++)
 435     {
 436         for (int x = 0; x < width; x++)
 437         {
 438             int r = data[index];
 439             index++;
 440             int g = data[index];
 441             index++;
 442             int b = data[index];
 443             index++;
 444
 445             if (image.HasMask())
 446             {
 447                 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
 448                     gdk_image_put_pixel( mask_image, x, y, 1 );
 449                 else
 450                     gdk_image_put_pixel( mask_image, x, y, 0 );
 451             }
 452
 453             switch (bpp)
 454             {
 455                 case 8:
 456                 {
 457                     GdkColormap *cmap = gtk_widget_get_default_colormap();
 458                     GdkColor *colors = cmap->colors;
 459                     int max = 3 * (65536);
 460                     int index = -1;
 461
 462                     for (int i = 0; i < cmap->size; i++)
 463                     {
 464                         int rdiff = (r << 8) - colors[i].red;
 465                         int gdiff = (g << 8) - colors[i].green;
 466                         int bdiff = (b << 8) - colors[i].blue;
 467                         int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
 468                         if (sum < max) { index = i; max = sum; }
 469                     }
 470
 471                     gdk_image_put_pixel( data_image, x, y, index );
 472
 473                     break;
 474                 }
 475                 case 15:
 476                 {
 477                     guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
 478                     gdk_image_put_pixel( data_image, x, y, pixel );
 479                     break;
 480                 }
 481                 case 16:
 482                 {
 483                     guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
 484                     gdk_image_put_pixel( data_image, x, y, pixel );
 485                     break;
 486                 }
 487                 case 32:
 488                 case 24:
 489                 {
 490                     guint32 pixel = 0;
 491                     switch (b_o)
 492                     {
 493                         case RGB: pixel = (r << 16) | (g << 8) | b; break;
 494                         case RBG: pixel = (r << 16) | (b << 8) | g; break;
 495                         case BRG: pixel = (b << 16) | (r << 8) | g; break;
 496                         case BGR: pixel = (b << 16) | (g << 8) | r; break;
 497                         case GRB: pixel = (g << 16) | (r << 8) | b; break;
 498                         case GBR: pixel = (g << 16) | (b << 8) | r; break;
 499                     }
 500                     gdk_image_put_pixel( data_image, x, y, pixel );
 501                 }
 502                 default: break;
 503             }
 504         } // for
 505     }  // for
 506
 507     // Blit picture
 508
 509     GdkGC *data_gc = gdk_gc_new( M_BMPDATA->m_pixmap );
 510
 511     gdk_draw_image( M_BMPDATA->m_pixmap, data_gc, data_image, 0, 0, 0, 0, width, height );
 512
 513     gdk_image_destroy( data_image );
 514     gdk_gc_unref( data_gc );
 515
 516     // Blit mask
 517
 518     if (image.HasMask())
 519     {
 520         GdkGC *mask_gc = gdk_gc_new( M_BMPDATA->m_mask->m_bitmap );
 521
 522         gdk_draw_image( M_BMPDATA->m_mask->m_bitmap, mask_gc, mask_image, 0, 0, 0, 0, width, height );
 523
 524         gdk_image_destroy( mask_image );
 525         gdk_gc_unref( mask_gc );
 526     }
 527 }
 528
 529 wxImage wxBitmap::ConvertToImage() const
 530 {
 531     wxImage image;
 532
 533     wxCHECK_MSG( Ok(), image, "invalid bitmap" );
 534
 535     GdkImage *gdk_image = gdk_image_get( M_BMPDATA->m_pixmap, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height );
 536
 537     if (!gdk_image) return image;
 538
 539     image.Create( M_BMPDATA->m_width, M_BMPDATA->m_height );
 540     char unsigned *data = image.GetData();
 541
 542     GdkVisual *visual = gdk_window_get_visual( M_BMPDATA->m_pixmap );
 543     if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
 544     int bpp = visual->depth;
 545     if ((bpp == 16) && (visual->red_mask != 0xf800)) bpp = 15;
 546
 547     GdkColormap *cmap = gtk_widget_get_default_colormap();
 548
 549     long pos = 0;
 550     for (int j = 0; j < M_BMPDATA->m_height; j++)
 551     {
 552         for (int i = 0; i < M_BMPDATA->m_width; i++)
 553         {
 554             int pixel = gdk_image_get_pixel( gdk_image, i, j );
 555             if (bpp <= 8)
 556             {
 557                 data[pos] = cmap->colors[pixel].red >> 8;
 558                 data[pos+1] = cmap->colors[pixel].green >> 8;
 559                 data[pos+2] = cmap->colors[pixel].blue >> 8;
 560             } else if (bpp == 15)
 561             {
 562                 data[pos] = (pixel >> 7) & 0xf8;
 563                 data[pos+1] = (pixel >> 2) & 0xf8;
 564                 data[pos+2] = (pixel << 3) & 0xf8;
 565             } else if (bpp == 16)
 566             {
 567                 data[pos] = (pixel >> 8) & 0xf8;
 568                 data[pos+1] = (pixel >> 3) & 0xfc;
 569                 data[pos+2] = (pixel << 3) & 0xf8;
 570             } else
 571             {
 572                 data[pos] = (pixel >> 16) & 0xff;
 573                 data[pos+1] = (pixel >> 8) & 0xff;
 574                 data[pos+2] = pixel & 0xff;
 575             }
 576
 577             pos += 3;
 578         }
 579     }
 580
 581     gdk_image_destroy( gdk_image );
 582
 583     return image;
 584 }
 585
 586
 587