samples/image/image.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/image/image.cpp
   3 // Purpose:     sample showing operations with wxImage
   4 // Author:      Robert Roebling
   5 // Modified by:
   6 // Created:     1998
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998-2005 Robert Roebling
   9 // License:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16 #pragma hdrstop
  17 #endif
  18
  19 #ifndef WX_PRECOMP
  20     #include "wx/wx.h"
  21 #endif
  22
  23 #include "wx/image.h"
  24 #include "wx/file.h"
  25 #include "wx/filename.h"
  26 #include "wx/mstream.h"
  27 #include "wx/wfstream.h"
  28 #include "wx/quantize.h"
  29 #include "wx/stopwatch.h"
  30
  31 #if wxUSE_CLIPBOARD
  32     #include "wx/dataobj.h"
  33     #include "wx/clipbrd.h"
  34 #endif // wxUSE_CLIPBOARD
  35
  36 #include "smile.xbm"
  37 #include "smile.xpm"
  38
  39 #if defined(__WXMSW__)
  40     #ifdef wxHAVE_RAW_BITMAP
  41     #include "wx/rawbmp.h"
  42     #endif
  43 #endif
  44
  45 #if defined(__WXMAC__) || defined(__WXGTK__)
  46     #define wxHAVE_RAW_BITMAP
  47     #include "wx/rawbmp.h"
  48 #endif
  49
  50 // derived classes
  51
  52 class MyFrame;
  53 class MyApp;
  54
  55 // MyCanvas
  56
  57 class MyCanvas: public wxScrolledWindow
  58 {
  59 public:
  60     MyCanvas( wxWindow *parent, wxWindowID, const wxPoint &pos, const wxSize &size );
  61     ~MyCanvas();
  62     void OnPaint( wxPaintEvent &event );
  63     void CreateAntiAliasedBitmap();
  64
  65     wxBitmap  my_horse_png;
  66     wxBitmap  my_horse_jpeg;
  67     wxBitmap  my_horse_gif;
  68     wxBitmap  my_horse_bmp;
  69     wxBitmap  my_horse_bmp2;
  70     wxBitmap  my_horse_pcx;
  71     wxBitmap  my_horse_pnm;
  72     wxBitmap  my_horse_tiff;
  73     wxBitmap  my_horse_tga;
  74     wxBitmap  my_horse_xpm;
  75     wxBitmap  my_horse_ico32;
  76     wxBitmap  my_horse_ico16;
  77     wxBitmap  my_horse_ico;
  78     wxBitmap  my_horse_cur;
  79
  80     wxBitmap  my_smile_xbm;
  81     wxBitmap  my_square;
  82     wxBitmap  my_anti;
  83
  84     wxBitmap  my_horse_asciigrey_pnm;
  85     wxBitmap  my_horse_rawgrey_pnm;
  86
  87     wxBitmap  colorized_horse_jpeg;
  88     wxBitmap  my_cmyk_jpeg;
  89
  90     wxBitmap my_toucan;
  91     wxBitmap my_toucan_flipped_horiz;
  92     wxBitmap my_toucan_flipped_vert;
  93     wxBitmap my_toucan_flipped_both;
  94     wxBitmap my_toucan_grey;
  95     wxBitmap my_toucan_head;
  96     wxBitmap my_toucan_scaled_normal;
  97     wxBitmap my_toucan_scaled_high;
  98     wxBitmap my_toucan_blur;
  99
 100     int xH, yH ;
 101     int m_ani_images;
 102     wxBitmap *my_horse_ani;
 103
 104 private:
 105     wxBitmap m_bmpSmileXpm;
 106     wxIcon   m_iconSmileXpm;
 107
 108     DECLARE_EVENT_TABLE()
 109 };
 110
 111
 112 // MyFrame
 113
 114
 115 class MyFrame: public wxFrame
 116 {
 117 public:
 118     MyFrame();
 119
 120     void OnAbout( wxCommandEvent &event );
 121     void OnNewFrame( wxCommandEvent &event );
 122     void OnImageInfo( wxCommandEvent &event );
 123     void OnThumbnail( wxCommandEvent &event );
 124
 125 #ifdef wxHAVE_RAW_BITMAP
 126     void OnTestRawBitmap( wxCommandEvent &event );
 127 #endif // wxHAVE_RAW_BITMAP
 128     void OnQuit( wxCommandEvent &event );
 129
 130 #if wxUSE_CLIPBOARD
 131     void OnCopy(wxCommandEvent& event);
 132     void OnPaste(wxCommandEvent& event);
 133 #endif // wxUSE_CLIPBOARD
 134
 135     MyCanvas         *m_canvas;
 136
 137 private:
 138     // ask user for the file name and try to load an image from it
 139     //
 140     // return the file path on success, empty string if we failed to load the
 141     // image or were cancelled by user
 142     static wxString LoadUserImage(wxImage& image);
 143
 144
 145     DECLARE_DYNAMIC_CLASS(MyFrame)
 146     DECLARE_EVENT_TABLE()
 147 };
 148
 149 // ----------------------------------------------------------------------------
 150 // Frame used for showing a standalone image
 151 // ----------------------------------------------------------------------------
 152
 153 enum
 154 {
 155     ID_ROTATE_LEFT = 100,
 156     ID_ROTATE_RIGHT,
 157     ID_RESIZE
 158 };
 159
 160 class MyImageFrame : public wxFrame
 161 {
 162 public:
 163     MyImageFrame(wxFrame *parent, const wxString& desc, const wxBitmap& bitmap)
 164         : wxFrame(parent, wxID_ANY,
 165                   wxString::Format(_T("Image from %s"), desc.c_str()),
 166                   wxDefaultPosition, wxDefaultSize,
 167                   wxDEFAULT_FRAME_STYLE | wxFULL_REPAINT_ON_RESIZE),
 168                   m_bitmap(bitmap)
 169     {
 170         wxMenu *menu = new wxMenu;
 171         menu->Append(wxID_SAVE);
 172         menu->AppendSeparator();
 173         menu->Append(ID_RESIZE, _T("&Fit to window\tCtrl-F"));
 174         menu->AppendSeparator();
 175         menu->Append(ID_ROTATE_LEFT, _T("Rotate &left\tCtrl-L"));
 176         menu->Append(ID_ROTATE_RIGHT, _T("Rotate &right\tCtrl-R"));
 177
 178         wxMenuBar *mbar = new wxMenuBar;
 179         mbar->Append(menu, _T("&Image"));
 180         SetMenuBar(mbar);
 181
 182         CreateStatusBar();
 183
 184         SetClientSize(bitmap.GetWidth(), bitmap.GetHeight());
 185
 186         UpdateStatusBar();
 187     }
 188
 189     void OnEraseBackground(wxEraseEvent& WXUNUSED(event))
 190     {
 191         // do nothing here to be able to see how transparent images are shown
 192     }
 193
 194     void OnPaint(wxPaintEvent& WXUNUSED(event))
 195     {
 196         wxPaintDC dc(this);
 197         const wxSize size = GetClientSize();
 198         dc.DrawBitmap(m_bitmap,
 199                       (size.x - m_bitmap.GetWidth())/2,
 200                       (size.y - m_bitmap.GetHeight())/2,
 201                       true /* use mask */);
 202     }
 203
 204     void OnSave(wxCommandEvent& WXUNUSED(event))
 205     {
 206 #if wxUSE_FILEDLG
 207         wxImage image = m_bitmap.ConvertToImage();
 208
 209         wxString savefilename = wxFileSelector( wxT("Save Image"),
 210                                                 wxEmptyString,
 211                                                 wxEmptyString,
 212                                                 (const wxChar *)NULL,
 213                                                 wxT("BMP files (*.bmp)|*.bmp|")
 214                                                 wxT("PNG files (*.png)|*.png|")
 215                                                 wxT("JPEG files (*.jpg)|*.jpg|")
 216                                                 wxT("GIF files (*.gif)|*.gif|")
 217                                                 wxT("TIFF files (*.tif)|*.tif|")
 218                                                 wxT("PCX files (*.pcx)|*.pcx|")
 219                                                 wxT("ICO files (*.ico)|*.ico|")
 220                                                 wxT("CUR files (*.cur)|*.cur"),
 221                                                 wxFD_SAVE,
 222                                                 this);
 223
 224         if ( savefilename.empty() )
 225             return;
 226
 227         wxString extension;
 228         wxFileName::SplitPath(savefilename, NULL, NULL, &extension);
 229
 230         bool saved = false;
 231         if ( extension == _T("bmp") )
 232         {
 233             static const int bppvalues[] =
 234             {
 235                 wxBMP_1BPP,
 236                 wxBMP_1BPP_BW,
 237                 wxBMP_4BPP,
 238                 wxBMP_8BPP,
 239                 wxBMP_8BPP_GREY,
 240                 wxBMP_8BPP_RED,
 241                 wxBMP_8BPP_PALETTE,
 242                 wxBMP_24BPP
 243             };
 244
 245             const wxString bppchoices[] =
 246             {
 247                 _T("1 bpp color"),
 248                 _T("1 bpp B&W"),
 249                 _T("4 bpp color"),
 250                 _T("8 bpp color"),
 251                 _T("8 bpp greyscale"),
 252                 _T("8 bpp red"),
 253                 _T("8 bpp own palette"),
 254                 _T("24 bpp")
 255             };
 256
 257             int bppselection = wxGetSingleChoiceIndex(_T("Set BMP BPP"),
 258                                                       _T("Image sample: save file"),
 259                                                       WXSIZEOF(bppchoices),
 260                                                       bppchoices,
 261                                                       this);
 262             if ( bppselection != -1 )
 263             {
 264                 int format = bppvalues[bppselection];
 265                 image.SetOption(wxIMAGE_OPTION_BMP_FORMAT, format);
 266
 267                 if ( format == wxBMP_8BPP_PALETTE )
 268                 {
 269                     unsigned char *cmap = new unsigned char [256];
 270                     for ( int i = 0; i < 256; i++ )
 271                         cmap[i] = (unsigned char)i;
 272                     image.SetPalette(wxPalette(256, cmap, cmap, cmap));
 273
 274                     delete[] cmap;
 275                 }
 276             }
 277         }
 278         else if ( extension == _T("png") )
 279         {
 280             static const int pngvalues[] =
 281             {
 282                 wxPNG_TYPE_COLOUR,
 283                 wxPNG_TYPE_COLOUR,
 284                 wxPNG_TYPE_GREY,
 285                 wxPNG_TYPE_GREY,
 286                 wxPNG_TYPE_GREY_RED,
 287                 wxPNG_TYPE_GREY_RED,
 288             };
 289
 290             const wxString pngchoices[] =
 291             {
 292                 _T("Colour 8bpp"),
 293                 _T("Colour 16bpp"),
 294                 _T("Grey 8bpp"),
 295                 _T("Grey 16bpp"),
 296                 _T("Grey red 8bpp"),
 297                 _T("Grey red 16bpp"),
 298             };
 299
 300             int sel = wxGetSingleChoiceIndex(_T("Set PNG format"),
 301                                              _T("Image sample: save file"),
 302                                              WXSIZEOF(pngchoices),
 303                                              pngchoices,
 304                                              this);
 305             if ( sel != -1 )
 306             {
 307                 image.SetOption(wxIMAGE_OPTION_PNG_FORMAT, pngvalues[sel]);
 308                 image.SetOption(wxIMAGE_OPTION_PNG_BITDEPTH, sel % 2 ? 16 : 8);
 309             }
 310         }
 311         else if ( extension == _T("cur") )
 312         {
 313             image.Rescale(32,32);
 314             image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, 0);
 315             image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, 0);
 316             // This shows how you can save an image with explicitly
 317             // specified image format:
 318             saved = image.SaveFile(savefilename, wxBITMAP_TYPE_CUR);
 319         }
 320
 321         if ( !saved )
 322         {
 323             // This one guesses image format from filename extension
 324             // (it may fail if the extension is not recognized):
 325             image.SaveFile(savefilename);
 326         }
 327 #endif // wxUSE_FILEDLG
 328     }
 329
 330     void OnResize(wxCommandEvent& WXUNUSED(event))
 331     {
 332         wxImage img(m_bitmap.ConvertToImage());
 333
 334         const wxSize size = GetClientSize();
 335         img.Rescale(size.x, size.y, wxIMAGE_QUALITY_HIGH);
 336         m_bitmap = wxBitmap(img);
 337
 338         UpdateStatusBar();
 339         Refresh();
 340     }
 341
 342     void OnRotate(wxCommandEvent& event)
 343     {
 344         double angle = 5;
 345         if ( event.GetId() == ID_ROTATE_LEFT )
 346             angle = -angle;
 347
 348         wxImage img(m_bitmap.ConvertToImage());
 349         img = img.Rotate(angle, wxPoint(img.GetWidth() / 2, img.GetHeight() / 2));
 350         if ( !img.Ok() )
 351         {
 352             wxLogWarning(_T("Rotation failed"));
 353             return;
 354         }
 355
 356         m_bitmap = wxBitmap(img);
 357
 358         UpdateStatusBar();
 359         Refresh();
 360     }
 361
 362 private:
 363     void UpdateStatusBar()
 364     {
 365         wxLogStatus(this, _T("Image size: (%d, %d)"),
 366                     m_bitmap.GetWidth(),
 367                     m_bitmap.GetHeight());
 368     }
 369
 370     wxBitmap m_bitmap;
 371
 372     DECLARE_EVENT_TABLE()
 373 };
 374
 375 #ifdef wxHAVE_RAW_BITMAP
 376
 377 #include "wx/rawbmp.h"
 378
 379 class MyRawBitmapFrame : public wxFrame
 380 {
 381 public:
 382     enum
 383     {
 384         BORDER = 15,
 385         SIZE = 150,
 386         REAL_SIZE = SIZE - 2*BORDER
 387     };
 388
 389     MyRawBitmapFrame(wxFrame *parent)
 390         : wxFrame(parent, wxID_ANY, _T("Raw bitmaps (how exciting)")),
 391           m_bitmap(SIZE, SIZE, 24),
 392           m_alphaBitmap(SIZE, SIZE, 32)
 393     {
 394         SetClientSize(SIZE, SIZE*2+25);
 395
 396         InitAlphaBitmap();
 397         InitBitmap();
 398
 399     }
 400
 401     void InitAlphaBitmap()
 402     {
 403         // First, clear the whole bitmap by making it alpha
 404         {
 405             wxAlphaPixelData data( m_alphaBitmap, wxPoint(0,0), wxSize(SIZE, SIZE) );
 406             if ( !data )
 407             {
 408                 wxLogError(_T("Failed to gain raw access to bitmap data"));
 409                 return;
 410             }
 411             wxAlphaPixelData::Iterator p(data);
 412             for ( int y = 0; y < SIZE; ++y )
 413             {
 414                 wxAlphaPixelData::Iterator rowStart = p;
 415                 for ( int x = 0; x < SIZE; ++x )
 416                 {
 417                     p.Alpha() = 0;
 418                     ++p; // same as p.OffsetX(1)
 419                 }
 420                 p = rowStart;
 421                 p.OffsetY(data, 1);
 422             }
 423         }
 424
 425         // Then, draw colourful alpha-blended stripes
 426         wxAlphaPixelData data(m_alphaBitmap, wxPoint(BORDER, BORDER),
 427                               wxSize(REAL_SIZE, REAL_SIZE));
 428         if ( !data )
 429         {
 430             wxLogError(_T("Failed to gain raw access to bitmap data"));
 431             return;
 432         }
 433
 434         wxAlphaPixelData::Iterator p(data);
 435
 436         for ( int y = 0; y < REAL_SIZE; ++y )
 437         {
 438             wxAlphaPixelData::Iterator rowStart = p;
 439
 440             int r = y < REAL_SIZE/3 ? 255 : 0,
 441                 g = (REAL_SIZE/3 <= y) && (y < 2*(REAL_SIZE/3)) ? 255 : 0,
 442                 b = 2*(REAL_SIZE/3) <= y ? 255 : 0;
 443
 444             for ( int x = 0; x < REAL_SIZE; ++x )
 445             {
 446                 // note that RGB must be premultiplied by alpha
 447                 unsigned a = (wxAlphaPixelData::Iterator::ChannelType)((x*255.)/REAL_SIZE);
 448                 p.Red() = r * a / 256;
 449                 p.Green() = g * a / 256;
 450                 p.Blue() = b * a / 256;
 451                 p.Alpha() = a;
 452
 453                 ++p; // same as p.OffsetX(1)
 454             }
 455
 456             p = rowStart;
 457             p.OffsetY(data, 1);
 458         }
 459     }
 460
 461     void InitBitmap()
 462     {
 463         // draw some colourful stripes without alpha
 464         wxNativePixelData data(m_bitmap);
 465         if ( !data )
 466         {
 467             wxLogError(_T("Failed to gain raw access to bitmap data"));
 468             return;
 469         }
 470
 471         wxNativePixelData::Iterator p(data);
 472         for ( int y = 0; y < SIZE; ++y )
 473         {
 474             wxNativePixelData::Iterator rowStart = p;
 475
 476             int r = y < SIZE/3 ? 255 : 0,
 477                 g = (SIZE/3 <= y) && (y < 2*(SIZE/3)) ? 255 : 0,
 478                 b = 2*(SIZE/3) <= y ? 255 : 0;
 479
 480             for ( int x = 0; x < SIZE; ++x )
 481             {
 482                 p.Red() = r;
 483                 p.Green() = g;
 484                 p.Blue() = b;
 485                 ++p; // same as p.OffsetX(1)
 486             }
 487
 488             p = rowStart;
 489             p.OffsetY(data, 1);
 490         }
 491     }
 492
 493     void OnPaint(wxPaintEvent& WXUNUSED(event))
 494     {
 495         wxPaintDC dc( this );
 496         dc.DrawText(_T("This is alpha and raw bitmap test"), 0, BORDER);
 497         dc.DrawText(_T("This is alpha and raw bitmap test"), 0, SIZE/2 - BORDER);
 498         dc.DrawText(_T("This is alpha and raw bitmap test"), 0, SIZE - 2*BORDER);
 499         dc.DrawBitmap( m_alphaBitmap, 0, 0, true /* use mask */ );
 500
 501         dc.DrawText(_T("Raw bitmap access without alpha"), 0, SIZE+5);
 502         dc.DrawBitmap( m_bitmap, 0, SIZE+5+dc.GetCharHeight());
 503     }
 504
 505 private:
 506     wxBitmap m_bitmap;
 507     wxBitmap m_alphaBitmap;
 508
 509     DECLARE_EVENT_TABLE()
 510 };
 511
 512 #endif // wxHAVE_RAW_BITMAP
 513
 514 // MyApp
 515
 516 class MyApp: public wxApp
 517 {
 518 public:
 519     virtual bool OnInit();
 520 };
 521
 522 // main program
 523
 524 IMPLEMENT_APP(MyApp)
 525
 526 // MyCanvas
 527
 528 BEGIN_EVENT_TABLE(MyImageFrame, wxFrame)
 529     EVT_ERASE_BACKGROUND(MyImageFrame::OnEraseBackground)
 530     EVT_PAINT(MyImageFrame::OnPaint)
 531
 532     EVT_MENU(wxID_SAVE, MyImageFrame::OnSave)
 533     EVT_MENU_RANGE(ID_ROTATE_LEFT, ID_ROTATE_RIGHT, MyImageFrame::OnRotate)
 534     EVT_MENU(ID_RESIZE, MyImageFrame::OnResize)
 535 END_EVENT_TABLE()
 536
 537 #ifdef wxHAVE_RAW_BITMAP
 538
 539 BEGIN_EVENT_TABLE(MyRawBitmapFrame, wxFrame)
 540     EVT_PAINT(MyRawBitmapFrame::OnPaint)
 541 END_EVENT_TABLE()
 542
 543 #endif // wxHAVE_RAW_BITMAP
 544
 545 BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
 546     EVT_PAINT(MyCanvas::OnPaint)
 547 END_EVENT_TABLE()
 548
 549 MyCanvas::MyCanvas( wxWindow *parent, wxWindowID id,
 550                     const wxPoint &pos, const wxSize &size )
 551     : wxScrolledWindow( parent, id, pos, size, wxSUNKEN_BORDER )
 552     , m_bmpSmileXpm(smile_xpm)
 553     , m_iconSmileXpm(smile_xpm)
 554 {
 555     my_horse_ani = NULL;
 556     m_ani_images = 0 ;
 557
 558     SetBackgroundColour(* wxWHITE);
 559
 560     wxBitmap bitmap( 100, 100 );
 561
 562     wxMemoryDC dc;
 563     dc.SelectObject( bitmap );
 564     dc.SetBrush( wxBrush( wxT("orange"), wxSOLID ) );
 565     dc.SetPen( *wxBLACK_PEN );
 566     dc.DrawRectangle( 0, 0, 100, 100 );
 567     dc.SetBrush( *wxWHITE_BRUSH );
 568     dc.DrawRectangle( 20, 20, 60, 60 );
 569     dc.SelectObject( wxNullBitmap );
 570
 571     // try to find the directory with our images
 572     wxString dir;
 573     if ( wxFile::Exists(wxT("./horse.png")) )
 574         dir = wxT("./");
 575     else if ( wxFile::Exists(wxT("../horse.png")) )
 576         dir = wxT("../");
 577     else
 578         wxLogWarning(wxT("Can't find image files in either '.' or '..'!"));
 579
 580     wxImage image = bitmap.ConvertToImage();
 581
 582 #if wxUSE_LIBPNG
 583     if ( !image.SaveFile( dir + _T("test.png"), wxBITMAP_TYPE_PNG ))
 584         wxLogError(wxT("Can't save file"));
 585
 586     image.Destroy();
 587
 588     if ( image.LoadFile( dir + _T("test.png") ) )
 589         my_square = wxBitmap( image );
 590
 591     image.Destroy();
 592
 593     if ( !image.LoadFile( dir + _T("horse.png")) )
 594         wxLogError(wxT("Can't load PNG image"));
 595     else
 596         my_horse_png = wxBitmap( image );
 597
 598     if ( !image.LoadFile( dir + _T("toucan.png")) )
 599         wxLogError(wxT("Can't load PNG image"));
 600     else
 601         my_toucan = wxBitmap(image);
 602
 603     my_toucan_flipped_horiz = wxBitmap(image.Mirror(true));
 604     my_toucan_flipped_vert = wxBitmap(image.Mirror(false));
 605     my_toucan_flipped_both = wxBitmap(image.Mirror(true).Mirror(false));
 606     my_toucan_grey = wxBitmap(image.ConvertToGreyscale());
 607     my_toucan_head = wxBitmap(image.GetSubImage(wxRect(40, 7, 80, 60)));
 608     my_toucan_scaled_normal = wxBitmap(image.Scale(110,90,wxIMAGE_QUALITY_NORMAL));
 609     my_toucan_scaled_high = wxBitmap(image.Scale(110,90,wxIMAGE_QUALITY_HIGH));
 610     my_toucan_blur = wxBitmap(image.Blur(10));
 611
 612 #endif // wxUSE_LIBPNG
 613
 614 #if wxUSE_LIBJPEG
 615     image.Destroy();
 616
 617     if ( !image.LoadFile( dir + _T("horse.jpg")) )
 618         wxLogError(wxT("Can't load JPG image"));
 619     else
 620     {
 621         my_horse_jpeg = wxBitmap( image );
 622
 623         // Colorize by rotating green hue to red
 624         wxImage::HSVValue greenHSV = wxImage::RGBtoHSV(wxImage::RGBValue(0, 255, 0));
 625         wxImage::HSVValue redHSV = wxImage::RGBtoHSV(wxImage::RGBValue(255, 0, 0));
 626         image.RotateHue(redHSV.hue - greenHSV.hue);
 627         colorized_horse_jpeg = wxBitmap( image );
 628     }
 629
 630     if ( !image.LoadFile( dir + _T("cmyk.jpg")) )
 631         wxLogError(_T("Can't load CMYK JPG image"));
 632     else
 633         my_cmyk_jpeg = wxBitmap(image);
 634 #endif // wxUSE_LIBJPEG
 635
 636 #if wxUSE_GIF
 637     image.Destroy();
 638
 639     if ( !image.LoadFile( dir + _T("horse.gif" )) )
 640         wxLogError(wxT("Can't load GIF image"));
 641     else
 642         my_horse_gif = wxBitmap( image );
 643 #endif
 644
 645 #if wxUSE_PCX
 646     image.Destroy();
 647
 648     if ( !image.LoadFile( dir + _T("horse.pcx"), wxBITMAP_TYPE_PCX ) )
 649         wxLogError(wxT("Can't load PCX image"));
 650     else
 651         my_horse_pcx = wxBitmap( image );
 652 #endif
 653
 654     image.Destroy();
 655
 656     if ( !image.LoadFile( dir + _T("horse.bmp"), wxBITMAP_TYPE_BMP ) )
 657         wxLogError(wxT("Can't load BMP image"));
 658     else
 659         my_horse_bmp = wxBitmap( image );
 660
 661 #if wxUSE_XPM
 662     image.Destroy();
 663
 664     if ( !image.LoadFile( dir + _T("horse.xpm"), wxBITMAP_TYPE_XPM ) )
 665         wxLogError(wxT("Can't load XPM image"));
 666     else
 667         my_horse_xpm = wxBitmap( image );
 668
 669     if ( !image.SaveFile( dir + _T("test.xpm"), wxBITMAP_TYPE_XPM ))
 670         wxLogError(wxT("Can't save file"));
 671 #endif
 672
 673 #if wxUSE_PNM
 674     image.Destroy();
 675
 676     if ( !image.LoadFile( dir + _T("horse.pnm"), wxBITMAP_TYPE_PNM ) )
 677         wxLogError(wxT("Can't load PNM image"));
 678     else
 679         my_horse_pnm = wxBitmap( image );
 680
 681     image.Destroy();
 682
 683     if ( !image.LoadFile( dir + _T("horse_ag.pnm"), wxBITMAP_TYPE_PNM ) )
 684         wxLogError(wxT("Can't load PNM image"));
 685     else
 686         my_horse_asciigrey_pnm = wxBitmap( image );
 687
 688     image.Destroy();
 689
 690     if ( !image.LoadFile( dir + _T("horse_rg.pnm"), wxBITMAP_TYPE_PNM ) )
 691         wxLogError(wxT("Can't load PNM image"));
 692     else
 693         my_horse_rawgrey_pnm = wxBitmap( image );
 694 #endif
 695
 696 #if wxUSE_LIBTIFF
 697     image.Destroy();
 698
 699     if ( !image.LoadFile( dir + _T("horse.tif"), wxBITMAP_TYPE_TIF ) )
 700         wxLogError(wxT("Can't load TIFF image"));
 701     else
 702         my_horse_tiff = wxBitmap( image );
 703 #endif
 704
 705 #if wxUSE_LIBTIFF
 706     image.Destroy();
 707
 708     if ( !image.LoadFile( dir + _T("horse.tga"), wxBITMAP_TYPE_TGA ) )
 709         wxLogError(wxT("Can't load TGA image"));
 710     else
 711         my_horse_tga = wxBitmap( image );
 712 #endif
 713
 714     CreateAntiAliasedBitmap();
 715
 716     my_smile_xbm = wxBitmap( (const char*)smile_bits, smile_width,
 717                                  smile_height, 1 );
 718
 719     // demonstrates XPM automatically using the mask when saving
 720     if ( m_bmpSmileXpm.Ok() )
 721         m_bmpSmileXpm.SaveFile(_T("saved.xpm"), wxBITMAP_TYPE_XPM);
 722
 723 #if wxUSE_ICO_CUR
 724     image.Destroy();
 725
 726     if ( !image.LoadFile( dir + _T("horse.ico"), wxBITMAP_TYPE_ICO, 0 ) )
 727         wxLogError(wxT("Can't load first ICO image"));
 728     else
 729         my_horse_ico32 = wxBitmap( image );
 730
 731     image.Destroy();
 732
 733     if ( !image.LoadFile( dir + _T("horse.ico"), wxBITMAP_TYPE_ICO, 1 ) )
 734         wxLogError(wxT("Can't load second ICO image"));
 735     else
 736         my_horse_ico16 = wxBitmap( image );
 737
 738     image.Destroy();
 739
 740     if ( !image.LoadFile( dir + _T("horse.ico") ) )
 741         wxLogError(wxT("Can't load best ICO image"));
 742     else
 743         my_horse_ico = wxBitmap( image );
 744
 745     image.Destroy();
 746
 747     if ( !image.LoadFile( dir + _T("horse.cur"), wxBITMAP_TYPE_CUR ) )
 748         wxLogError(wxT("Can't load best ICO image"));
 749     else
 750     {
 751         my_horse_cur = wxBitmap( image );
 752         xH = 30 + image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X) ;
 753         yH = 2420 + image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y) ;
 754     }
 755
 756     m_ani_images = wxImage::GetImageCount ( dir + _T("horse3.ani"), wxBITMAP_TYPE_ANI );
 757     if (m_ani_images==0)
 758         wxLogError(wxT("No ANI-format images found"));
 759     else
 760         my_horse_ani = new wxBitmap [m_ani_images];
 761     int i ;
 762     for (i=0; i < m_ani_images; i++)
 763     {
 764         image.Destroy();
 765         if (!image.LoadFile( dir + _T("horse3.ani"), wxBITMAP_TYPE_ANI, i ))
 766         {
 767             wxString tmp = wxT("Can't load image number ");
 768             tmp << i ;
 769             wxLogError(tmp);
 770         }
 771         else
 772             my_horse_ani [i] = wxBitmap( image );
 773     }
 774 #endif // wxUSE_ICO_CUR
 775
 776     image.Destroy();
 777
 778     // test image loading from stream
 779     wxFile file(dir + _T("horse.bmp"));
 780     if ( file.IsOpened() )
 781     {
 782         wxFileOffset len = file.Length();
 783         size_t dataSize = (size_t)len;
 784         void *data = malloc(dataSize);
 785         if ( file.Read(data, dataSize) != len )
 786             wxLogError(_T("Reading bitmap file failed"));
 787         else
 788         {
 789             wxMemoryInputStream mis(data, dataSize);
 790             if ( !image.LoadFile(mis) )
 791                 wxLogError(wxT("Can't load BMP image from stream"));
 792             else
 793                 my_horse_bmp2 = wxBitmap( image );
 794         }
 795
 796         free(data);
 797     }
 798 }
 799
 800 MyCanvas::~MyCanvas()
 801 {
 802     delete [] my_horse_ani;
 803 }
 804
 805 void MyCanvas::OnPaint( wxPaintEvent &WXUNUSED(event) )
 806 {
 807     wxPaintDC dc( this );
 808     PrepareDC( dc );
 809
 810     dc.DrawText( _T("Loaded image"), 30, 10 );
 811     if (my_square.Ok())
 812         dc.DrawBitmap( my_square, 30, 30 );
 813
 814     dc.DrawText( _T("Drawn directly"), 150, 10 );
 815     dc.SetBrush( wxBrush( wxT("orange"), wxSOLID ) );
 816     dc.SetPen( *wxBLACK_PEN );
 817     dc.DrawRectangle( 150, 30, 100, 100 );
 818     dc.SetBrush( *wxWHITE_BRUSH );
 819     dc.DrawRectangle( 170, 50, 60, 60 );
 820
 821     if (my_anti.Ok())
 822         dc.DrawBitmap( my_anti, 280, 30 );
 823
 824     dc.DrawText( _T("PNG handler"), 30, 135 );
 825     if (my_horse_png.Ok())
 826     {
 827         dc.DrawBitmap( my_horse_png, 30, 150 );
 828         wxRect rect(0,0,100,100);
 829         wxBitmap sub( my_horse_png.GetSubBitmap(rect) );
 830         dc.DrawText( _T("GetSubBitmap()"), 280, 175 );
 831         dc.DrawBitmap( sub, 280, 195 );
 832     }
 833
 834     dc.DrawText( _T("JPEG handler"), 30, 365 );
 835     if (my_horse_jpeg.Ok())
 836         dc.DrawBitmap( my_horse_jpeg, 30, 380 );
 837
 838     dc.DrawText( _T("Green rotated to red"), 280, 365 );
 839     if (colorized_horse_jpeg.Ok())
 840         dc.DrawBitmap( colorized_horse_jpeg, 280, 380 );
 841
 842     dc.DrawText( _T("CMYK JPEG image"), 530, 365 );
 843     if (my_cmyk_jpeg.Ok())
 844         dc.DrawBitmap( my_cmyk_jpeg, 530, 380 );
 845
 846     dc.DrawText( _T("GIF handler"), 30, 595 );
 847     if (my_horse_gif.Ok())
 848         dc.DrawBitmap( my_horse_gif, 30, 610 );
 849
 850     dc.DrawText( _T("PCX handler"), 30, 825 );
 851     if (my_horse_pcx.Ok())
 852         dc.DrawBitmap( my_horse_pcx, 30, 840 );
 853
 854     dc.DrawText( _T("BMP handler"), 30, 1055 );
 855     if (my_horse_bmp.Ok())
 856         dc.DrawBitmap( my_horse_bmp, 30, 1070 );
 857
 858     dc.DrawText( _T("BMP read from memory"), 280, 1055 );
 859     if (my_horse_bmp2.Ok())
 860         dc.DrawBitmap( my_horse_bmp2, 280, 1070 );
 861
 862     dc.DrawText( _T("PNM handler"), 30, 1285 );
 863     if (my_horse_pnm.Ok())
 864         dc.DrawBitmap( my_horse_pnm, 30, 1300 );
 865
 866     dc.DrawText( _T("PNM handler (ascii grey)"), 280, 1285 );
 867     if (my_horse_asciigrey_pnm.Ok())
 868         dc.DrawBitmap( my_horse_asciigrey_pnm, 280, 1300 );
 869
 870     dc.DrawText( _T("PNM handler (raw grey)"), 530, 1285 );
 871     if (my_horse_rawgrey_pnm.Ok())
 872         dc.DrawBitmap( my_horse_rawgrey_pnm, 530, 1300 );
 873
 874     dc.DrawText( _T("TIFF handler"), 30, 1515 );
 875     if (my_horse_tiff.Ok())
 876         dc.DrawBitmap( my_horse_tiff, 30, 1530 );
 877
 878     dc.DrawText( _T("TGA handler"), 30, 1745 );
 879     if (my_horse_tga.Ok())
 880         dc.DrawBitmap( my_horse_tga, 30, 1760 );
 881
 882     dc.DrawText( _T("XPM handler"), 30, 1975 );
 883     if (my_horse_xpm.Ok())
 884         dc.DrawBitmap( my_horse_xpm, 30, 2000 );
 885
 886     // toucans
 887     {
 888         int x = 750, y = 10, yy = 170;
 889
 890         dc.DrawText(wxT("Original toucan"), x+50, y);
 891         dc.DrawBitmap(my_toucan, x, y+15, true);
 892         y += yy;
 893         dc.DrawText(wxT("Flipped horizontally"), x+50, y);
 894         dc.DrawBitmap(my_toucan_flipped_horiz, x, y+15, true);
 895         y += yy;
 896         dc.DrawText(wxT("Flipped vertically"), x+50, y);
 897         dc.DrawBitmap(my_toucan_flipped_vert, x, y+15, true);
 898         y += yy;
 899         dc.DrawText(wxT("Flipped both h&v"), x+50, y);
 900         dc.DrawBitmap(my_toucan_flipped_both, x, y+15, true);
 901
 902         y += yy;
 903         dc.DrawText(wxT("In greyscale"), x+50, y);
 904         dc.DrawBitmap(my_toucan_grey, x, y+15, true);
 905
 906         y += yy;
 907         dc.DrawText(wxT("Toucan's head"), x+50, y);
 908         dc.DrawBitmap(my_toucan_head, x, y+15, true);
 909
 910         y += yy;
 911         dc.DrawText(wxT("Scaled with normal quality"), x+50, y);
 912         dc.DrawBitmap(my_toucan_scaled_normal, x, y+15, true);
 913
 914         y += yy;
 915         dc.DrawText(wxT("Scaled with high quality"), x+50, y);
 916         dc.DrawBitmap(my_toucan_scaled_high, x, y+15, true);
 917
 918         y += yy;
 919         dc.DrawText(wxT("Blured"), x+50, y);
 920         dc.DrawBitmap(my_toucan_blur, x, y+15, true);
 921     }
 922
 923     if (my_smile_xbm.Ok())
 924     {
 925         int x = 300, y = 1800;
 926
 927         dc.DrawText( _T("XBM bitmap"), x, y );
 928         dc.DrawText( _T("(green on red)"), x, y + 15 );
 929         dc.SetTextForeground( _T("GREEN") );
 930         dc.SetTextBackground( _T("RED") );
 931         dc.DrawBitmap( my_smile_xbm, x, y + 30 );
 932
 933         dc.SetTextForeground( *wxBLACK );
 934         dc.DrawText( _T("After wxImage conversion"), x + 120, y );
 935         dc.DrawText( _T("(red on white)"), x + 120, y + 15 );
 936         dc.SetTextForeground( wxT("RED") );
 937         wxImage i = my_smile_xbm.ConvertToImage();
 938         i.SetMaskColour( 255, 255, 255 );
 939         i.Replace( 0, 0, 0,
 940                wxRED_PEN->GetColour().Red(),
 941                wxRED_PEN->GetColour().Green(),
 942                wxRED_PEN->GetColour().Blue() );
 943         dc.DrawBitmap( wxBitmap(i), x + 120, y + 30, true );
 944         dc.SetTextForeground( *wxBLACK );
 945     }
 946
 947
 948     wxBitmap mono( 60,50,1 );
 949     wxMemoryDC memdc;
 950     memdc.SelectObject( mono );
 951     memdc.SetPen( *wxBLACK_PEN );
 952     memdc.SetBrush( *wxWHITE_BRUSH );
 953     memdc.DrawRectangle( 0,0,60,50 );
 954     memdc.SetTextForeground( *wxBLACK );
 955 #ifndef __WXGTK20__
 956     // I cannot convince GTK2 to draw into mono bitmaps
 957     memdc.DrawText( _T("Hi!"), 5, 5 );
 958 #endif
 959     memdc.SetBrush( *wxBLACK_BRUSH );
 960     memdc.DrawRectangle( 33,5,20,20 );
 961     memdc.SetPen( *wxRED_PEN );
 962     memdc.DrawLine( 5, 42, 50, 42 );
 963     memdc.SelectObject( wxNullBitmap );
 964
 965     if (mono.Ok())
 966     {
 967         int x = 300, y = 1900;
 968
 969         dc.DrawText( _T("Mono bitmap"), x, y );
 970         dc.DrawText( _T("(red on green)"), x, y + 15 );
 971         dc.SetTextForeground( wxT("RED") );
 972         dc.SetTextBackground( wxT("GREEN") );
 973         dc.DrawBitmap( mono, x, y + 30 );
 974
 975         dc.SetTextForeground( *wxBLACK );
 976         dc.DrawText( _T("After wxImage conversion"), x + 120, y );
 977         dc.DrawText( _T("(red on white)"), x + 120, y + 15 );
 978         dc.SetTextForeground( wxT("RED") );
 979         wxImage i = mono.ConvertToImage();
 980         i.SetMaskColour( 255,255,255 );
 981         i.Replace( 0,0,0,
 982                wxRED_PEN->GetColour().Red(),
 983                wxRED_PEN->GetColour().Green(),
 984                wxRED_PEN->GetColour().Blue() );
 985         dc.DrawBitmap( wxBitmap(i), x + 120, y + 30, true );
 986         dc.SetTextForeground( *wxBLACK );
 987     }
 988
 989     // For testing transparency
 990     dc.SetBrush( *wxRED_BRUSH );
 991     dc.DrawRectangle( 20, 2220, 560, 68 );
 992
 993     dc.DrawText(_T("XPM bitmap"), 30, 2230 );
 994     if ( m_bmpSmileXpm.Ok() )
 995         dc.DrawBitmap(m_bmpSmileXpm, 30, 2250, true);
 996
 997     dc.DrawText(_T("XPM icon"), 110, 2230 );
 998     if ( m_iconSmileXpm.Ok() )
 999         dc.DrawIcon(m_iconSmileXpm, 110, 2250);
1000
1001     // testing icon -> bitmap conversion
1002     wxBitmap to_blit( m_iconSmileXpm );
1003     if (to_blit.Ok())
1004     {
1005         dc.DrawText( _T("SubBitmap"), 170, 2230 );
1006         wxBitmap sub = to_blit.GetSubBitmap( wxRect(0,0,15,15) );
1007         if (sub.Ok())
1008             dc.DrawBitmap( sub, 170, 2250, true );
1009
1010         dc.DrawText( _T("Enlarged"), 250, 2230 );
1011         dc.SetUserScale( 1.5, 1.5 );
1012         dc.DrawBitmap( to_blit, (int)(250/1.5), (int)(2250/1.5), true );
1013         dc.SetUserScale( 2, 2 );
1014         dc.DrawBitmap( to_blit, (int)(300/2), (int)(2250/2), true );
1015         dc.SetUserScale( 1.0, 1.0 );
1016
1017         dc.DrawText( _T("Blit"), 400, 2230);
1018         wxMemoryDC blit_dc;
1019         blit_dc.SelectObject( to_blit );
1020         dc.Blit( 400, 2250, to_blit.GetWidth(), to_blit.GetHeight(), &blit_dc, 0, 0, wxCOPY, true );
1021         dc.SetUserScale( 1.5, 1.5 );
1022         dc.Blit( (int)(450/1.5), (int)(2250/1.5), to_blit.GetWidth(), to_blit.GetHeight(), &blit_dc, 0, 0, wxCOPY, true );
1023         dc.SetUserScale( 2, 2 );
1024         dc.Blit( (int)(500/2), (int)(2250/2), to_blit.GetWidth(), to_blit.GetHeight(), &blit_dc, 0, 0, wxCOPY, true );
1025         dc.SetUserScale( 1.0, 1.0 );
1026     }
1027
1028     dc.DrawText( _T("ICO handler (1st image)"), 30, 2290 );
1029     if (my_horse_ico32.Ok())
1030         dc.DrawBitmap( my_horse_ico32, 30, 2330, true );
1031
1032     dc.DrawText( _T("ICO handler (2nd image)"), 230, 2290 );
1033     if (my_horse_ico16.Ok())
1034         dc.DrawBitmap( my_horse_ico16, 230, 2330, true );
1035
1036     dc.DrawText( _T("ICO handler (best image)"), 430, 2290 );
1037     if (my_horse_ico.Ok())
1038         dc.DrawBitmap( my_horse_ico, 430, 2330, true );
1039
1040     dc.DrawText( _T("CUR handler"), 30, 2390 );
1041     if (my_horse_cur.Ok())
1042     {
1043         dc.DrawBitmap( my_horse_cur, 30, 2420, true );
1044         dc.SetPen (*wxRED_PEN);
1045         dc.DrawLine (xH-10,yH,xH+10,yH);
1046         dc.DrawLine (xH,yH-10,xH,yH+10);
1047     }
1048
1049     dc.DrawText( _T("ANI handler"), 230, 2390 );
1050     for ( int i=0; i < m_ani_images; i++ )
1051     {
1052         if (my_horse_ani[i].Ok())
1053         {
1054             dc.DrawBitmap( my_horse_ani[i], 230 + i * 2 * my_horse_ani[i].GetWidth() , 2420, true );
1055         }
1056     }
1057 }
1058
1059 void MyCanvas::CreateAntiAliasedBitmap()
1060 {
1061   wxBitmap bitmap( 300, 300 );
1062
1063   wxMemoryDC dc;
1064
1065   dc.SelectObject( bitmap );
1066
1067   dc.Clear();
1068
1069   dc.SetFont( wxFont( 24, wxDECORATIVE, wxNORMAL, wxNORMAL) );
1070   dc.SetTextForeground( wxT("RED") );
1071   dc.DrawText( _T("This is anti-aliased Text."), 20, 5 );
1072   dc.DrawText( _T("And a Rectangle."), 20, 45 );
1073
1074   dc.SetBrush( *wxRED_BRUSH );
1075   dc.SetPen( *wxTRANSPARENT_PEN );
1076   dc.DrawRoundedRectangle( 20, 85, 200, 180, 20 );
1077
1078   wxImage original= bitmap.ConvertToImage();
1079   wxImage anti( 150, 150 );
1080
1081   /* This is quite slow, but safe. Use wxImage::GetData() for speed instead. */
1082
1083   for (int y = 1; y < 149; y++)
1084     for (int x = 1; x < 149; x++)
1085     {
1086        int red = original.GetRed( x*2, y*2 ) +
1087                  original.GetRed( x*2-1, y*2 ) +
1088                  original.GetRed( x*2, y*2+1 ) +
1089                  original.GetRed( x*2+1, y*2+1 );
1090        red = red/4;
1091
1092        int green = original.GetGreen( x*2, y*2 ) +
1093                    original.GetGreen( x*2-1, y*2 ) +
1094                    original.GetGreen( x*2, y*2+1 ) +
1095                    original.GetGreen( x*2+1, y*2+1 );
1096        green = green/4;
1097
1098        int blue = original.GetBlue( x*2, y*2 ) +
1099                   original.GetBlue( x*2-1, y*2 ) +
1100                   original.GetBlue( x*2, y*2+1 ) +
1101                   original.GetBlue( x*2+1, y*2+1 );
1102        blue = blue/4;
1103        anti.SetRGB( x, y, (unsigned char)red, (unsigned char)green, (unsigned char)blue );
1104     }
1105   my_anti = wxBitmap(anti);
1106 }
1107
1108 // MyFrame
1109
1110 enum
1111 {
1112     ID_QUIT  = wxID_EXIT,
1113     ID_ABOUT = wxID_ABOUT,
1114     ID_NEW = 100,
1115     ID_INFO,
1116     ID_SHOWRAW,
1117     ID_SHOWTHUMBNAIL
1118 };
1119
1120 IMPLEMENT_DYNAMIC_CLASS( MyFrame, wxFrame )
1121
1122 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
1123   EVT_MENU    (ID_ABOUT, MyFrame::OnAbout)
1124   EVT_MENU    (ID_QUIT,  MyFrame::OnQuit)
1125   EVT_MENU    (ID_NEW,   MyFrame::OnNewFrame)
1126   EVT_MENU    (ID_INFO,  MyFrame::OnImageInfo)
1127   EVT_MENU    (ID_SHOWTHUMBNAIL, MyFrame::OnThumbnail)
1128 #ifdef wxHAVE_RAW_BITMAP
1129   EVT_MENU    (ID_SHOWRAW, MyFrame::OnTestRawBitmap)
1130 #endif
1131
1132 #if wxUSE_CLIPBOARD
1133     EVT_MENU(wxID_COPY, MyFrame::OnCopy)
1134     EVT_MENU(wxID_PASTE, MyFrame::OnPaste)
1135 #endif // wxUSE_CLIPBOARD
1136 END_EVENT_TABLE()
1137
1138 MyFrame::MyFrame()
1139        : wxFrame( (wxFrame *)NULL, wxID_ANY, _T("wxImage sample"),
1140                   wxPoint(20, 20), wxSize(950, 700) )
1141 {
1142   wxMenuBar *menu_bar = new wxMenuBar();
1143
1144   wxMenu *menuImage = new wxMenu;
1145   menuImage->Append( ID_NEW, _T("&Show any image...\tCtrl-O"));
1146   menuImage->Append( ID_INFO, _T("Show image &information...\tCtrl-I"));
1147 #ifdef wxHAVE_RAW_BITMAP
1148   menuImage->AppendSeparator();
1149   menuImage->Append( ID_SHOWRAW, _T("Test &raw bitmap...\tCtrl-R"));
1150 #endif
1151   menuImage->AppendSeparator();
1152   menuImage->Append( ID_SHOWTHUMBNAIL, _T("Test &thumbnail...\tCtrl-T"),
1153                     "Test scaling the image during load (try with JPEG)");
1154   menuImage->AppendSeparator();
1155   menuImage->Append( ID_ABOUT, _T("&About..."));
1156   menuImage->AppendSeparator();
1157   menuImage->Append( ID_QUIT, _T("E&xit\tCtrl-Q"));
1158   menu_bar->Append(menuImage, _T("&Image"));
1159
1160 #if wxUSE_CLIPBOARD
1161   wxMenu *menuClipboard = new wxMenu;
1162   menuClipboard->Append(wxID_COPY, _T("&Copy test image\tCtrl-C"));
1163   menuClipboard->Append(wxID_PASTE, _T("&Paste image\tCtrl-V"));
1164   menu_bar->Append(menuClipboard, _T("&Clipboard"));
1165 #endif // wxUSE_CLIPBOARD
1166
1167   SetMenuBar( menu_bar );
1168
1169 #if wxUSE_STATUSBAR
1170   CreateStatusBar(2);
1171   int widths[] = { -1, 100 };
1172   SetStatusWidths( 2, widths );
1173 #endif // wxUSE_STATUSBAR
1174
1175   m_canvas = new MyCanvas( this, wxID_ANY, wxPoint(0,0), wxSize(10,10) );
1176
1177   // 500 width * 2750 height
1178   m_canvas->SetScrollbars( 10, 10, 50, 275 );
1179 }
1180
1181 void MyFrame::OnQuit( wxCommandEvent &WXUNUSED(event) )
1182 {
1183   Close( true );
1184 }
1185
1186 void MyFrame::OnAbout( wxCommandEvent &WXUNUSED(event) )
1187 {
1188   (void)wxMessageBox( _T("wxImage demo\n")
1189                       _T("Robert Roebling (c) 1998,2000"),
1190                       _T("About wxImage Demo"), wxICON_INFORMATION | wxOK );
1191 }
1192
1193 wxString MyFrame::LoadUserImage(wxImage& image)
1194 {
1195     wxString filename;
1196
1197 #if wxUSE_FILEDLG
1198     filename = wxFileSelector(_T("Select image file"));
1199     if ( !filename.empty() )
1200     {
1201         if ( !image.LoadFile(filename) )
1202         {
1203             wxLogError(_T("Couldn't load image from '%s'."), filename.c_str());
1204
1205             return wxEmptyString;
1206         }
1207     }
1208 #endif // wxUSE_FILEDLG
1209
1210     return filename;
1211 }
1212
1213 void MyFrame::OnNewFrame( wxCommandEvent &WXUNUSED(event) )
1214 {
1215     wxImage image;
1216     wxString filename = LoadUserImage(image);
1217     if ( !filename.empty() )
1218         (new MyImageFrame(this, filename, wxBitmap(image)))->Show();
1219 }
1220
1221 void MyFrame::OnImageInfo( wxCommandEvent &WXUNUSED(event) )
1222 {
1223     wxImage image;
1224     if ( !LoadUserImage(image).empty() )
1225     {
1226         // TODO: show more information about the file
1227         wxString info = wxString::Format("Image size: %dx%d",
1228                                          image.GetWidth(),
1229                                          image.GetHeight());
1230
1231         int xres = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX),
1232             yres = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY);
1233         if ( xres || yres )
1234         {
1235             info += wxString::Format("\nResolution: %dx%d", xres, yres);
1236             switch ( image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT) )
1237             {
1238                 default:
1239                     wxFAIL_MSG( "unknown image resolution units" );
1240                     // fall through
1241
1242                 case wxIMAGE_RESOLUTION_NONE:
1243                     info += " in default units";
1244                     break;
1245
1246                 case wxIMAGE_RESOLUTION_INCHES:
1247                     info += " in";
1248                     break;
1249
1250                 case wxIMAGE_RESOLUTION_CM:
1251                     info += " cm";
1252                     break;
1253             }
1254         }
1255
1256         wxLogMessage("%s", info);
1257     }
1258 }
1259
1260 #ifdef wxHAVE_RAW_BITMAP
1261
1262 void MyFrame::OnTestRawBitmap( wxCommandEvent &WXUNUSED(event) )
1263 {
1264     (new MyRawBitmapFrame(this))->Show();
1265 }
1266
1267 #endif // wxHAVE_RAW_BITMAP
1268
1269 #if wxUSE_CLIPBOARD
1270
1271 void MyFrame::OnCopy(wxCommandEvent& WXUNUSED(event))
1272 {
1273     wxBitmapDataObject *dobjBmp = new wxBitmapDataObject;
1274     dobjBmp->SetBitmap(m_canvas->my_horse_png);
1275
1276     wxTheClipboard->Open();
1277
1278     if ( !wxTheClipboard->SetData(dobjBmp) )
1279     {
1280         wxLogError(_T("Failed to copy bitmap to clipboard"));
1281     }
1282
1283     wxTheClipboard->Close();
1284 }
1285
1286 void MyFrame::OnPaste(wxCommandEvent& WXUNUSED(event))
1287 {
1288     wxBitmapDataObject dobjBmp;
1289
1290     wxTheClipboard->Open();
1291     if ( !wxTheClipboard->GetData(dobjBmp) )
1292     {
1293         wxLogMessage(_T("No bitmap data in the clipboard"));
1294     }
1295     else
1296     {
1297         (new MyImageFrame(this, _T("Clipboard"), dobjBmp.GetBitmap()))->Show();
1298     }
1299     wxTheClipboard->Close();
1300 }
1301
1302 #endif // wxUSE_CLIPBOARD
1303
1304 //-----------------------------------------------------------------------------
1305 // MyApp
1306 //-----------------------------------------------------------------------------
1307
1308 bool MyApp::OnInit()
1309 {
1310     if ( !wxApp::OnInit() )
1311         return false;
1312
1313     wxInitAllImageHandlers();
1314
1315     wxFrame *frame = new MyFrame();
1316     frame->Show( true );
1317
1318     return true;
1319 }
1320
1321 void MyFrame::OnThumbnail( wxCommandEvent &WXUNUSED(event) )
1322 {
1323 #if wxUSE_FILEDLG
1324     wxString filename = wxFileSelector(_T("Select image file"));
1325     if ( filename.empty() )
1326         return;
1327
1328     static const int THUMBNAIL_WIDTH = 320;
1329     static const int THUMBNAIL_HEIGHT = 240;
1330
1331     wxImage image;
1332     image.SetOption(wxIMAGE_OPTION_MAX_WIDTH, THUMBNAIL_WIDTH);
1333     image.SetOption(wxIMAGE_OPTION_MAX_HEIGHT, THUMBNAIL_HEIGHT);
1334
1335     wxStopWatch sw;
1336     if ( !image.LoadFile(filename) )
1337     {
1338         wxLogError(_T("Couldn't load image from '%s'."), filename.c_str());
1339         return;
1340     }
1341
1342     const long loadTime = sw.Time();
1343
1344     MyImageFrame * const
1345         frame = new MyImageFrame(this, filename, wxBitmap(image));
1346     frame->Show();
1347     wxLogStatus(frame, "Loaded \"%s\" in %ldms", filename, loadTime);
1348 #else
1349     wxLogError( _T("Couldn't create file selector dialog") );
1350     return;
1351 #endif // wxUSE_FILEDLG
1352 }
1353