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 "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( 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 &name, int type, wxPalette *WXUNUSED(palette) )
 291 {
 292     if (!Ok())
 293     {
 294         wxFAIL_MSG( "invalid bitmap" );
 295         return FALSE;
 296     }
 297
 298     if (type == wxBITMAP_TYPE_PNG)
 299     {
 300         wxImage image = ConvertToImage();
 301         if (image.Ok()) return image.SaveFile( name, type );
 302     }
 303
 304     return FALSE;
 305 }
 306
 307 bool wxBitmap::LoadFile( const wxString &name, int type )
 308 {
 309     UnRef();
 310
 311     if (!wxFileExists(name)) return FALSE;
 312
 313     if (type == wxBITMAP_TYPE_XPM)
 314     {
 315         m_refData = new wxBitmapRefData();
 316
 317         GdkBitmap *mask = (GdkBitmap*) NULL;
 318         GdkWindow *parent = (GdkWindow*) &gdk_root_parent;
 319
 320         M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm( parent, &mask, NULL, name );
 321
 322         if (mask)
 323         {
 324            M_BMPDATA->m_mask = new wxMask();
 325            M_BMPDATA->m_mask->m_bitmap = mask;
 326         }
 327
 328         gdk_window_get_size( M_BMPDATA->m_pixmap, &(M_BMPDATA->m_width), &(M_BMPDATA->m_height) );
 329         M_BMPDATA->m_bpp = gdk_window_get_visual( parent )->depth;
 330     }
 331     else if (type == wxBITMAP_TYPE_PNG)
 332     {
 333         wxImage image;
 334         image.LoadFile( name, type );
 335         if (image.Ok()) *this = wxBitmap( image );
 336     }
 337     else if (type == wxBITMAP_TYPE_BMP)
 338     {
 339         wxImage image;
 340         image.LoadFile( name, type );
 341         if (image.Ok()) *this = wxBitmap( image );
 342     }
 343     else
 344         return FALSE;
 345
 346     return TRUE;
 347 }
 348
 349 wxPalette *wxBitmap::GetPalette(void) const
 350 {
 351     if (!Ok()) return (wxPalette *) NULL;
 352     return M_BMPDATA->m_palette;
 353 }
 354
 355 GdkPixmap *wxBitmap::GetPixmap(void) const
 356 {
 357     if (!Ok())
 358     {
 359         wxFAIL_MSG( "invalid bitmap" );
 360         return (GdkPixmap *) NULL;
 361     }
 362
 363     return M_BMPDATA->m_pixmap;
 364 }
 365
 366 GdkBitmap *wxBitmap::GetBitmap(void) const
 367 {
 368     if (!Ok())
 369     {
 370       wxFAIL_MSG( "invalid bitmap" );
 371       return (GdkBitmap *) NULL;
 372     }
 373
 374     return M_BMPDATA->m_bitmap;
 375 }
 376
 377 wxBitmap::wxBitmap( const wxImage &image )
 378 {
 379     if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
 380
 381     if (!image.Ok()) return;
 382
 383     m_refData = new wxBitmapRefData();
 384
 385     M_BMPDATA->m_height = image.GetHeight();
 386     M_BMPDATA->m_width = image.GetWidth();
 387     int width = image.GetWidth();
 388     int height = image.GetHeight();
 389
 390     // Create picture
 391
 392     GdkImage *data_image =
 393       gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), width, height );
 394
 395     M_BMPDATA->m_pixmap =
 396       gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, -1 );
 397
 398     // Create mask
 399
 400     GdkImage *mask_image = (GdkImage*) NULL;
 401
 402     if (image.HasMask())
 403     {
 404         unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
 405
 406         mask_image =  gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
 407
 408         M_BMPDATA->m_mask = new wxMask();
 409         M_BMPDATA->m_mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
 410     }
 411
 412     // Retrieve depth
 413
 414     M_BMPDATA->m_bpp = data_image->depth;
 415
 416     int render_depth = 8;
 417     if (M_BMPDATA->m_bpp > 8) render_depth = M_BMPDATA->m_bpp;
 418
 419     // Render
 420
 421     enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
 422     byte_order b_o = RGB;
 423
 424     if (render_depth >= 24)
 425     {
 426         GdkVisual *visual = gdk_visual_get_system();
 427         if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask))      b_o = RGB;
 428         else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask))  b_o = RGB;
 429         else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask))   b_o = BRG;
 430         else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
 431         else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask))   b_o = GRB;
 432         else if ((visual->green_mask > visual->blue_mask) && (visual->blue_mask > visual->red_mask))  b_o = GBR;
 433     }
 434
 435     int r_mask = image.GetMaskRed();
 436     int g_mask = image.GetMaskGreen();
 437     int b_mask = image.GetMaskBlue();
 438
 439     unsigned char* data = image.GetData();
 440
 441     int index = 0;
 442     for (int y = 0; y < height; y++)
 443     {
 444         for (int x = 0; x < width; x++)
 445         {
 446             int r = data[index];
 447             index++;
 448             int g = data[index];
 449             index++;
 450             int b = data[index];
 451             index++;
 452
 453             if (image.HasMask())
 454             {
 455                 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
 456                     gdk_image_put_pixel( mask_image, x, y, 1 );
 457                 else
 458                     gdk_image_put_pixel( mask_image, x, y, 0 );
 459             }
 460
 461             switch (render_depth)
 462             {
 463                 case 8:
 464                 {
 465                     GdkColormap *cmap = gtk_widget_get_default_colormap();
 466                     GdkColor *colors = cmap->colors;
 467                     int max = 3 * (65536);
 468                     int index = -1;
 469
 470                     for (int i = 0; i < cmap->size; i++)
 471                     {
 472                         int rdiff = (r << 8) - colors[i].red;
 473                         int gdiff = (g << 8) - colors[i].green;
 474                         int bdiff = (b << 8) - colors[i].blue;
 475                         int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
 476                         if (sum < max) { index = i; max = sum; }
 477                     }
 478
 479                     gdk_image_put_pixel( data_image, x, y, index );
 480
 481                     break;
 482                 }
 483                 case 15:
 484                 {
 485                     guint32 pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
 486                     gdk_image_put_pixel( data_image, x, y, pixel );
 487                     break;
 488                 }
 489                 case 16:
 490                 {
 491                     guint32 pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
 492                     gdk_image_put_pixel( data_image, x, y, pixel );
 493                     break;
 494                 }
 495                 case 32:
 496                 case 24:
 497                 {
 498                     guint32 pixel = 0;
 499                     switch (b_o)
 500                     {
 501                         case RGB: pixel = (r << 16) | (g << 8) | b; break;
 502                         case RBG: pixel = (r << 16) | (b << 8) | g; break;
 503                         case BRG: pixel = (b << 16) | (r << 8) | g; break;
 504                         case BGR: pixel = (b << 16) | (g << 8) | r; break;
 505                         case GRB: pixel = (g << 16) | (r << 8) | b; break;
 506                         case GBR: pixel = (g << 16) | (b << 8) | r; break;
 507                     }
 508                     gdk_image_put_pixel( data_image, x, y, pixel );
 509                 }
 510                 default: break;
 511             }
 512         } // for
 513     }  // for
 514
 515     // Blit picture
 516
 517     GdkGC *data_gc = gdk_gc_new( M_BMPDATA->m_pixmap );
 518
 519     gdk_draw_image( M_BMPDATA->m_pixmap, data_gc, data_image, 0, 0, 0, 0, width, height );
 520
 521     gdk_image_destroy( data_image );
 522     gdk_gc_unref( data_gc );
 523
 524     // Blit mask
 525
 526     if (image.HasMask())
 527     {
 528         GdkGC *mask_gc = gdk_gc_new( M_BMPDATA->m_mask->m_bitmap );
 529
 530         gdk_draw_image( M_BMPDATA->m_mask->m_bitmap, mask_gc, mask_image, 0, 0, 0, 0, width, height );
 531
 532         gdk_image_destroy( mask_image );
 533         gdk_gc_unref( mask_gc );
 534     }
 535 }
 536
 537 wxImage wxBitmap::ConvertToImage() const
 538 {
 539     wxImage image;
 540
 541     if (!Ok())
 542     {
 543         wxFAIL_MSG( "invalid bitmap" );
 544         return image;
 545     }
 546
 547     GdkImage *gdk_image = gdk_image_get( M_BMPDATA->m_pixmap, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height );
 548
 549     if (!gdk_image) return image;
 550
 551     image.Create( M_BMPDATA->m_width, M_BMPDATA->m_height );
 552     char unsigned *data = image.GetData();
 553
 554     GdkVisual *visual = gdk_window_get_visual( M_BMPDATA->m_pixmap );
 555     if (visual == NULL) visual = gdk_window_get_visual( (GdkWindow*) &gdk_root_parent );
 556     int bpp = visual->depth;
 557
 558     GdkColormap *cmap = gtk_widget_get_default_colormap();
 559
 560     long pos = 0;
 561     for (int j = 0; j < M_BMPDATA->m_height; j++)
 562     {
 563         for (int i = 0; i < M_BMPDATA->m_width; i++)
 564         {
 565             int pixel = gdk_image_get_pixel( gdk_image, i, j );
 566             if (bpp <= 8)
 567             {
 568                 data[pos] = cmap->colors[pixel].red >> 8;
 569                 data[pos+1] = cmap->colors[pixel].green >> 8;
 570                 data[pos+2] = cmap->colors[pixel].blue >> 8;
 571             } else if (bpp == 15)
 572             {
 573                 data[pos] = (pixel >> 7) & 0xf8;
 574                 data[pos+1] = (pixel >> 2) & 0xf8;
 575                 data[pos+2] = (pixel << 3) & 0xf8;
 576             } else if (bpp == 16)
 577             {
 578                 data[pos] = (pixel >> 8) & 0xf8;
 579                 data[pos+1] = (pixel >> 3) & 0xfc;
 580                 data[pos+2] = (pixel << 3) & 0xf8;
 581             } else
 582             {
 583                 data[pos] = (pixel >> 16) & 0xff;
 584                 data[pos+1] = (pixel >> 8) & 0xff;
 585                 data[pos+2] = pixel & 0xff;
 586             }
 587
 588             pos += 3;
 589         }
 590     }
 591
 592     gdk_image_destroy( gdk_image );
 593
 594     return image;
 595 }
 596
 597
 598