src/gtk1/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 "gdk/gdkprivate.h"
  17 #include "gdk/gdkx.h"
  18
  19 //-----------------------------------------------------------------------------
  20 // wxMask
  21 //-----------------------------------------------------------------------------
  22
  23 IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
  24
  25 wxMask::wxMask(void)
  26 {
  27   m_bitmap = (GdkBitmap *) NULL;
  28 }
  29
  30 wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour) )
  31 {
  32 }
  33
  34 wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex) )
  35 {
  36 }
  37
  38 wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap) )
  39 {
  40 }
  41
  42 wxMask::~wxMask(void)
  43 {
  44   if (m_bitmap) gdk_bitmap_unref( m_bitmap );
  45 }
  46
  47 GdkBitmap *wxMask::GetBitmap(void) const
  48 {
  49   return m_bitmap;
  50 }
  51
  52 //-----------------------------------------------------------------------------
  53 // wxBitmap
  54 //-----------------------------------------------------------------------------
  55
  56 class wxBitmapRefData: public wxObjectRefData
  57 {
  58   public:
  59
  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( 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
 141   if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 142 }
 143
 144 wxBitmap::wxBitmap( const wxBitmap& bmp )
 145 {
 146   Ref( bmp );
 147
 148   if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 149 }
 150
 151 wxBitmap::wxBitmap( const wxBitmap* bmp )
 152 {
 153   if (bmp) Ref( *bmp );
 154
 155   if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 156 }
 157
 158 wxBitmap::wxBitmap( const wxString &filename, int type )
 159 {
 160   LoadFile( filename, type );
 161
 162   if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 163 }
 164
 165 wxBitmap::wxBitmap( const char bits[], int width, int height, int WXUNUSED(depth))
 166 {
 167   m_refData = new wxBitmapRefData();
 168
 169   M_BMPDATA->m_mask = (wxMask *) NULL;
 170   M_BMPDATA->m_bitmap =
 171     gdk_bitmap_create_from_data( (GdkWindow*) &gdk_root_parent, (gchar *) bits, width, height );
 172   M_BMPDATA->m_width = width;
 173   M_BMPDATA->m_height = height;
 174   M_BMPDATA->m_bpp = 1;
 175
 176   if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 177 }
 178
 179 wxBitmap::~wxBitmap(void)
 180 {
 181   if (wxTheBitmapList) wxTheBitmapList->DeleteObject(this);
 182 }
 183
 184 wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )
 185 {
 186   if (*this == bmp) return (*this);
 187   Ref( bmp );
 188   return *this;
 189 }
 190
 191 bool wxBitmap::operator == ( const wxBitmap& bmp )
 192 {
 193   return m_refData == bmp.m_refData;
 194 }
 195
 196 bool wxBitmap::operator != ( const wxBitmap& bmp )
 197 {
 198   return m_refData != bmp.m_refData;
 199 }
 200
 201 bool wxBitmap::Ok(void) const
 202 {
 203   return (m_refData != NULL);
 204 }
 205
 206 int wxBitmap::GetHeight(void) const
 207 {
 208   if (!Ok())
 209   {
 210     wxFAIL_MSG( "invalid bitmap" );
 211     return -1;
 212   }
 213
 214   return M_BMPDATA->m_height;
 215 }
 216
 217 int wxBitmap::GetWidth(void) const
 218 {
 219   if (!Ok())
 220   {
 221     wxFAIL_MSG( "invalid bitmap" );
 222     return -1;
 223   }
 224
 225   return M_BMPDATA->m_width;
 226 }
 227
 228 int wxBitmap::GetDepth(void) const
 229 {
 230   if (!Ok())
 231   {
 232     wxFAIL_MSG( "invalid bitmap" );
 233     return -1;
 234   }
 235
 236   return M_BMPDATA->m_bpp;
 237 }
 238
 239 void wxBitmap::SetHeight( int height )
 240 {
 241   if (!Ok()) return;
 242
 243   wxFAIL_MSG( "wxBitmap::SetHeight not implemented" );
 244
 245   M_BMPDATA->m_height = height;
 246 }
 247
 248 void wxBitmap::SetWidth( int width )
 249 {
 250   if (!Ok()) return;
 251
 252   wxFAIL_MSG( "wxBitmap::SetWidth not implemented" );
 253
 254   M_BMPDATA->m_width = width;
 255 }
 256
 257 void wxBitmap::SetDepth( int depth )
 258 {
 259   if (!Ok()) return;
 260
 261   wxFAIL_MSG( "wxBitmap::SetDepth not implemented" );
 262
 263   M_BMPDATA->m_bpp = depth;
 264 }
 265
 266 wxMask *wxBitmap::GetMask(void) const
 267 {
 268   if (!Ok())
 269   {
 270     wxFAIL_MSG( "invalid bitmap" );
 271     return (wxMask *) NULL;
 272   }
 273
 274   return M_BMPDATA->m_mask;
 275 }
 276
 277 void wxBitmap::SetMask( wxMask *mask )
 278 {
 279   if (!Ok())
 280   {
 281     wxFAIL_MSG( "invalid bitmap" );
 282     return;
 283   }
 284
 285   if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
 286
 287   M_BMPDATA->m_mask = mask;
 288 }
 289
 290 bool wxBitmap::SaveFile( const wxString &WXUNUSED(name), int WXUNUSED(type),
 291   wxPalette *WXUNUSED(palette) )
 292 {
 293   if (!Ok())
 294   {
 295     wxFAIL_MSG( "invalid bitmap" );
 296     return FALSE;
 297   }
 298
 299   return FALSE;
 300 }
 301
 302 bool wxBitmap::LoadFile( const wxString &WXUNUSED(name), int WXUNUSED(type) )
 303 {
 304   if (!Ok())
 305   {
 306     wxFAIL_MSG( "invalid bitmap" );
 307     return FALSE;
 308   }
 309
 310   return FALSE;
 311 }
 312
 313 wxPalette *wxBitmap::GetPalette(void) const
 314 {
 315   if (!Ok()) return (wxPalette *) NULL;
 316   return M_BMPDATA->m_palette;
 317 }
 318
 319 GdkPixmap *wxBitmap::GetPixmap(void) const
 320 {
 321   if (!Ok())
 322   {
 323     wxFAIL_MSG( "invalid bitmap" );
 324     return (GdkPixmap *) NULL;
 325   }
 326
 327   return M_BMPDATA->m_pixmap;
 328 }
 329
 330 GdkBitmap *wxBitmap::GetBitmap(void) const
 331 {
 332   if (!Ok())
 333   {
 334     wxFAIL_MSG( "invalid bitmap" );
 335     return (GdkBitmap *) NULL;
 336   }
 337
 338   return M_BMPDATA->m_bitmap;
 339 }
 340
 341 wxBitmap::wxBitmap( const wxImage &image )
 342 {
 343   if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 344
 345   if (!image.Ok()) return;
 346
 347   m_refData = new wxBitmapRefData();
 348
 349   M_BMPDATA->m_height = image.GetHeight();
 350   M_BMPDATA->m_width = image.GetWidth();
 351   int width = image.GetWidth();
 352   int height = image.GetHeight();
 353
 354   // Create picture
 355
 356   GdkImage *data_image =
 357     gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), width, height );
 358
 359   M_BMPDATA->m_pixmap =
 360     gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, -1 );
 361
 362   // Create mask
 363
 364   GdkImage *mask_image = (GdkImage*) NULL;
 365
 366   if (image.HasMask())
 367   {
 368     unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
 369
 370     mask_image =  gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
 371
 372     M_BMPDATA->m_mask = new wxMask();
 373     M_BMPDATA->m_mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
 374   }
 375
 376   // Retrieve depth
 377
 378   M_BMPDATA->m_bpp = data_image->depth;
 379
 380   int render_depth = 8;
 381   if (M_BMPDATA->m_bpp > 8) render_depth = M_BMPDATA->m_bpp;
 382
 383   // Render
 384
 385   enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
 386   byte_order b_o;
 387
 388   if (render_depth >= 24)
 389   {
 390     GdkVisual *visual = gdk_visual_get_system();
 391     if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask))      b_o = RGB;
 392     else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask))  b_o = RGB;
 393     else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask))   b_o = BRG;
 394     else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
 395     else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask))   b_o = GRB;
 396     else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask))  b_o = GBR;
 397   }
 398
 399   int r_mask = image.GetMaskRed();
 400   int g_mask = image.GetMaskGreen();
 401   int b_mask = image.GetMaskBlue();
 402
 403   unsigned char* data = image.GetData();
 404
 405   int index = 0;
 406   for (int y = 0; y < height; y++)
 407     for (int x = 0; x < width; x++)
 408       {
 409         int r = data[index];
 410         index++;
 411         int g = data[index];
 412         index++;
 413         int b = data[index];
 414         index++;
 415
 416         if (image.HasMask())
 417         {
 418           if ((r == r_mask) && (b = b_mask) && (g = g_mask))
 419             gdk_image_put_pixel( mask_image, x, y, 0 );
 420           else
 421             gdk_image_put_pixel( mask_image, x, y, 1 );
 422         }
 423
 424         switch (render_depth)
 425         {
 426           case 8:
 427           {
 428             GdkColormap *cmap = gtk_widget_get_default_colormap();
 429             GdkColor *colors = cmap->colors;
 430             int max = 3 * (65536);
 431             int index = -1;
 432
 433             for (int i = 0; i < cmap->size; i++)
 434             {
 435               int rdiff = (r << 8) - colors[i].red;
 436               int gdiff = (g << 8) - colors[i].green;
 437               int bdiff = (b << 8) - colors[i].blue;
 438               int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
 439               if (sum < max) { index = i; max = sum; }
 440             }
 441
 442             gdk_image_put_pixel( data_image, x, y, index );
 443
 444             break;
 445           }
 446           case 15:
 447           {
 448             guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
 449             gdk_image_put_pixel( data_image, x, y, pixel );
 450             break;
 451           }
 452           case 16:
 453           {
 454             guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
 455             gdk_image_put_pixel( data_image, x, y, pixel );
 456             break;
 457           }
 458           case 32:
 459           case 24:
 460           {
 461             guint32 pixel = 0;
 462             switch (b_o)
 463             {
 464               case RGB: pixel = (r << 16) | (g << 8) | b; break;
 465               case RBG: pixel = (r << 16) | (b << 8) | g; break;
 466               case BRG: pixel = (b << 16) | (r << 8) | g; break;
 467               case BGR: pixel = (b << 16) | (g << 8) | r; break;
 468               case GRB: pixel = (g << 16) | (r << 8) | b; break;
 469               case GBR: pixel = (g << 16) | (b << 8) | r; break;
 470             }
 471             gdk_image_put_pixel( data_image, x, y, pixel );
 472           }
 473           default: break;
 474         }
 475       }
 476
 477   // Blit picture
 478
 479   GdkGC *data_gc = gdk_gc_new( M_BMPDATA->m_pixmap );
 480
 481   gdk_draw_image( M_BMPDATA->m_pixmap, data_gc, data_image, 0, 0, 0, 0, width, height );
 482
 483   gdk_image_destroy( data_image );
 484   gdk_gc_unref( data_gc );
 485
 486   // Blit mask
 487
 488   if (image.HasMask())
 489   {
 490     GdkGC *mask_gc = gdk_gc_new( M_BMPDATA->m_mask->m_bitmap );
 491
 492     gdk_draw_image( M_BMPDATA->m_mask->m_bitmap, mask_gc, mask_image, 0, 0, 0, 0, width, height );
 493
 494     gdk_image_destroy( mask_image );
 495     gdk_gc_unref( mask_gc );
 496   }
 497
 498 }
 499
 500 wxImage wxBitmap::ConvertToImage() const
 501 {
 502   wxImage image;
 503
 504   if (!Ok())
 505   {
 506     wxFAIL_MSG( "invalid bitmap" );
 507     return image;
 508   }
 509
 510   GdkImage *gdk_image = gdk_image_get( M_BMPDATA->m_pixmap, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height );
 511
 512   if (!gdk_image) return image;
 513
 514   image.Create( M_BMPDATA->m_width, M_BMPDATA->m_height );
 515   char unsigned *data = image.GetData();
 516
 517   int bpp = gdk_image->bpp;
 518   GdkColormap *cmap = gtk_widget_get_default_colormap();
 519
 520   long pos = 0;
 521   for (int j = 0; j < M_BMPDATA->m_height; j++)
 522   {
 523     for (int i = 0; i < M_BMPDATA->m_width; i++)
 524     {
 525       int pixel = gdk_image_get_pixel( gdk_image, i, j );
 526       if (bpp <= 8)
 527       {
 528         data[pos] = cmap->colors[pixel].red >> 8;
 529         data[pos+1] = cmap->colors[pixel].green >> 8;
 530         data[pos+2] = cmap->colors[pixel].blue >> 8;
 531       } else if (bpp == 15)
 532       {
 533         data[pos] = (pixel >> 7) & 0xf8;
 534         data[pos+1] = (pixel >> 3) & 0xf8;
 535         data[pos+2] = (pixel << 3) & 0xf8;
 536       } else if (bpp == 16)
 537       {
 538         data[pos] = (pixel >> 8) & 0xf8;
 539         data[pos+1] = (pixel >> 3) & 0xfc;
 540         data[pos+2] = (pixel << 3) & 0xf8;
 541       } else
 542       {
 543         data[pos] = (pixel >> 16) & 0xff;
 544         data[pos+1] = (pixel >> 8) & 0xff;
 545         data[pos+2] = pixel & 0xff;
 546       }
 547
 548       pos += 3;
 549     }
 550   }
 551
 552   gdk_image_destroy( gdk_image );
 553
 554   return image;
 555 }
 556
 557
 558