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: Francesco Montorsi
   6 // Created:     1998
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998-2005 Robert Roebling
   9 //              (c) 2005-2009 Vadim Zeitlin
  10 // License:     wxWindows licence
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 // For compilers that support precompilation, includes "wx/wx.h".
  14 #include "wx/wxprec.h"
  15
  16 #ifdef __BORLANDC__
  17 #pragma hdrstop
  18 #endif
  19
  20 #ifndef WX_PRECOMP
  21     #include "wx/wx.h"
  22 #endif
  23
  24 #include "wx/image.h"
  25 #include "wx/file.h"
  26 #include "wx/filename.h"
  27 #include "wx/mstream.h"
  28 #include "wx/wfstream.h"
  29 #include "wx/quantize.h"
  30 #include "wx/stopwatch.h"
  31
  32 #if wxUSE_CLIPBOARD
  33     #include "wx/dataobj.h"
  34     #include "wx/clipbrd.h"
  35 #endif // wxUSE_CLIPBOARD
  36
  37 #if defined(__WXMSW__)
  38     #ifdef wxHAVE_RAW_BITMAP
  39     #include "wx/rawbmp.h"
  40     #endif
  41 #endif
  42
  43 #if defined(__WXMAC__) || defined(__WXGTK__)
  44     #define wxHAVE_RAW_BITMAP
  45     #include "wx/rawbmp.h"
  46 #endif
  47
  48 #include "canvas.h"
  49
  50 #ifndef __WXMSW__
  51     #include "../sample.xpm"
  52 #endif
  53
  54 // ============================================================================
  55 // declarations
  56 // ============================================================================
  57
  58 //-----------------------------------------------------------------------------
  59 // MyApp
  60 //-----------------------------------------------------------------------------
  61
  62 class MyApp: public wxApp
  63 {
  64 public:
  65     virtual bool OnInit();
  66 };
  67
  68 // ----------------------------------------------------------------------------
  69 // MyFrame
  70 // ----------------------------------------------------------------------------
  71
  72 class MyFrame: public wxFrame
  73 {
  74 public:
  75     MyFrame();
  76
  77     void OnAbout( wxCommandEvent &event );
  78     void OnNewFrame( wxCommandEvent &event );
  79     void OnImageInfo( wxCommandEvent &event );
  80     void OnThumbnail( wxCommandEvent &event );
  81
  82 #ifdef wxHAVE_RAW_BITMAP
  83     void OnTestRawBitmap( wxCommandEvent &event );
  84 #endif // wxHAVE_RAW_BITMAP
  85     void OnQuit( wxCommandEvent &event );
  86
  87 #if wxUSE_CLIPBOARD
  88     void OnCopy(wxCommandEvent& event);
  89     void OnPaste(wxCommandEvent& event);
  90 #endif // wxUSE_CLIPBOARD
  91
  92     MyCanvas         *m_canvas;
  93
  94 private:
  95     // ask user for the file name and try to load an image from it
  96     //
  97     // return the file path on success, empty string if we failed to load the
  98     // image or were cancelled by user
  99     static wxString LoadUserImage(wxImage& image);
 100
 101
 102     DECLARE_DYNAMIC_CLASS(MyFrame)
 103     DECLARE_EVENT_TABLE()
 104 };
 105
 106 // ----------------------------------------------------------------------------
 107 // Frame used for showing a standalone image
 108 // ----------------------------------------------------------------------------
 109
 110 enum
 111 {
 112     ID_ROTATE_LEFT = wxID_HIGHEST+1,
 113     ID_ROTATE_RIGHT,
 114     ID_RESIZE,
 115     ID_PAINT_BG
 116 };
 117
 118 class MyImageFrame : public wxFrame
 119 {
 120 public:
 121     MyImageFrame(wxFrame *parent, const wxString& desc, const wxImage& image)
 122     {
 123         Create(parent, desc, wxBitmap(image), image.GetImageCount(desc));
 124     }
 125
 126     MyImageFrame(wxFrame *parent, const wxString& desc, const wxBitmap& bitmap)
 127     {
 128         Create(parent, desc, bitmap);
 129     }
 130
 131 private:
 132     bool Create(wxFrame *parent,
 133                 const wxString& desc,
 134                 const wxBitmap& bitmap,
 135                 int numImages = 1)
 136     {
 137         if ( !wxFrame::Create(parent, wxID_ANY,
 138                               wxString::Format(wxT("Image from %s"), desc),
 139                               wxDefaultPosition, wxDefaultSize,
 140                               wxDEFAULT_FRAME_STYLE | wxFULL_REPAINT_ON_RESIZE) )
 141             return false;
 142
 143         m_bitmap = bitmap;
 144         m_zoom = 1.;
 145
 146         wxMenu *menu = new wxMenu;
 147         menu->Append(wxID_SAVE);
 148         menu->AppendSeparator();
 149         menu->AppendCheckItem(ID_PAINT_BG, wxT("&Paint background"),
 150                               "Uncheck this for transparent images");
 151         menu->AppendSeparator();
 152         menu->Append(ID_RESIZE, wxT("&Fit to window\tCtrl-F"));
 153         menu->Append(wxID_ZOOM_IN, "Zoom &in\tCtrl-+");
 154         menu->Append(wxID_ZOOM_OUT, "Zoom &out\tCtrl--");
 155         menu->Append(wxID_ZOOM_100, "Reset zoom to &100%\tCtrl-1");
 156         menu->AppendSeparator();
 157         menu->Append(ID_ROTATE_LEFT, wxT("Rotate &left\tCtrl-L"));
 158         menu->Append(ID_ROTATE_RIGHT, wxT("Rotate &right\tCtrl-R"));
 159
 160         wxMenuBar *mbar = new wxMenuBar;
 161         mbar->Append(menu, wxT("&Image"));
 162         SetMenuBar(mbar);
 163
 164         mbar->Check(ID_PAINT_BG, true);
 165
 166         CreateStatusBar(2);
 167         if ( numImages != 1 )
 168             SetStatusText(wxString::Format("%d images", numImages), 1);
 169
 170         SetClientSize(bitmap.GetWidth(), bitmap.GetHeight());
 171
 172         UpdateStatusBar();
 173
 174         Show();
 175
 176         return true;
 177     }
 178
 179     void OnEraseBackground(wxEraseEvent& WXUNUSED(event))
 180     {
 181         // do nothing here to be able to see how transparent images are shown
 182     }
 183
 184     void OnPaint(wxPaintEvent& WXUNUSED(event))
 185     {
 186         wxPaintDC dc(this);
 187
 188 #ifndef __WXOSX__
 189         // on OSX the immediate Update from within ClearBackground leads to a recursion
 190         if ( GetMenuBar()->IsChecked(ID_PAINT_BG) )
 191             ClearBackground();
 192 #endif
 193
 194         dc.SetUserScale(m_zoom, m_zoom);
 195
 196         const wxSize size = GetClientSize();
 197         dc.DrawBitmap
 198            (
 199                 m_bitmap,
 200                 dc.DeviceToLogicalX((size.x - m_zoom*m_bitmap.GetWidth())/2),
 201                 dc.DeviceToLogicalY((size.y - m_zoom*m_bitmap.GetHeight())/2),
 202                 true /* use mask */
 203            );
 204     }
 205
 206     void OnSave(wxCommandEvent& WXUNUSED(event))
 207     {
 208 #if wxUSE_FILEDLG
 209         wxImage image = m_bitmap.ConvertToImage();
 210
 211         wxString savefilename = wxFileSelector( wxT("Save Image"),
 212                                                 wxEmptyString,
 213                                                 wxEmptyString,
 214                                                 (const wxChar *)NULL,
 215                                                 wxT("BMP files (*.bmp)|*.bmp|")
 216 #if wxUSE_LIBPNG
 217                                                 wxT("PNG files (*.png)|*.png|")
 218 #endif
 219 #if wxUSE_LIBJPEG
 220                                                 wxT("JPEG files (*.jpg)|*.jpg|")
 221 #endif
 222 #if wxUSE_GIF
 223                                                 wxT("GIF files (*.gif)|*.gif|")
 224 #endif
 225 #if wxUSE_LIBTIFF
 226                                                 wxT("TIFF files (*.tif)|*.tif|")
 227 #endif
 228 #if wxUSE_PCX
 229                                                 wxT("PCX files (*.pcx)|*.pcx|")
 230 #endif
 231                                                 wxT("ICO files (*.ico)|*.ico|")
 232                                                 wxT("CUR files (*.cur)|*.cur"),
 233                                                 wxFD_SAVE,
 234                                                 this);
 235
 236         if ( savefilename.empty() )
 237             return;
 238
 239         wxString extension;
 240         wxFileName::SplitPath(savefilename, NULL, NULL, &extension);
 241
 242         bool saved = false;
 243         if ( extension == wxT("bmp") )
 244         {
 245             static const int bppvalues[] =
 246             {
 247                 wxBMP_1BPP,
 248                 wxBMP_1BPP_BW,
 249                 wxBMP_4BPP,
 250                 wxBMP_8BPP,
 251                 wxBMP_8BPP_GREY,
 252                 wxBMP_8BPP_RED,
 253                 wxBMP_8BPP_PALETTE,
 254                 wxBMP_24BPP
 255             };
 256
 257             const wxString bppchoices[] =
 258             {
 259                 wxT("1 bpp color"),
 260                 wxT("1 bpp B&W"),
 261                 wxT("4 bpp color"),
 262                 wxT("8 bpp color"),
 263                 wxT("8 bpp greyscale"),
 264                 wxT("8 bpp red"),
 265                 wxT("8 bpp own palette"),
 266                 wxT("24 bpp")
 267             };
 268
 269             int bppselection = wxGetSingleChoiceIndex(wxT("Set BMP BPP"),
 270                                                     wxT("Image sample: save file"),
 271                                                     WXSIZEOF(bppchoices),
 272                                                     bppchoices,
 273                                                     this);
 274             if ( bppselection != -1 )
 275             {
 276                 int format = bppvalues[bppselection];
 277                 image.SetOption(wxIMAGE_OPTION_BMP_FORMAT, format);
 278
 279                 if ( format == wxBMP_8BPP_PALETTE )
 280                 {
 281                     unsigned char *cmap = new unsigned char [256];
 282                     for ( int i = 0; i < 256; i++ )
 283                         cmap[i] = (unsigned char)i;
 284                     image.SetPalette(wxPalette(256, cmap, cmap, cmap));
 285
 286                     delete[] cmap;
 287                 }
 288             }
 289         }
 290 #if wxUSE_LIBPNG
 291         else if ( extension == wxT("png") )
 292         {
 293             static const int pngvalues[] =
 294             {
 295                 wxPNG_TYPE_COLOUR,
 296                 wxPNG_TYPE_COLOUR,
 297                 wxPNG_TYPE_GREY,
 298                 wxPNG_TYPE_GREY,
 299                 wxPNG_TYPE_GREY_RED,
 300                 wxPNG_TYPE_GREY_RED,
 301             };
 302
 303             const wxString pngchoices[] =
 304             {
 305                 wxT("Colour 8bpp"),
 306                 wxT("Colour 16bpp"),
 307                 wxT("Grey 8bpp"),
 308                 wxT("Grey 16bpp"),
 309                 wxT("Grey red 8bpp"),
 310                 wxT("Grey red 16bpp"),
 311             };
 312
 313             int sel = wxGetSingleChoiceIndex(wxT("Set PNG format"),
 314                                             wxT("Image sample: save file"),
 315                                             WXSIZEOF(pngchoices),
 316                                             pngchoices,
 317                                             this);
 318             if ( sel != -1 )
 319             {
 320                 image.SetOption(wxIMAGE_OPTION_PNG_FORMAT, pngvalues[sel]);
 321                 image.SetOption(wxIMAGE_OPTION_PNG_BITDEPTH, sel % 2 ? 16 : 8);
 322
 323                 // these values are taken from OptiPNG with -o3 switch
 324                 const wxString compressionChoices[] =
 325                 {
 326                     wxT("compression = 9, memory = 8, strategy = 0, filter = 0"),
 327                     wxT("compression = 9, memory = 9, strategy = 0, filter = 0"),
 328                     wxT("compression = 9, memory = 8, strategy = 1, filter = 0"),
 329                     wxT("compression = 9, memory = 9, strategy = 1, filter = 0"),
 330                     wxT("compression = 1, memory = 8, strategy = 2, filter = 0"),
 331                     wxT("compression = 1, memory = 9, strategy = 2, filter = 0"),
 332                     wxT("compression = 9, memory = 8, strategy = 0, filter = 5"),
 333                     wxT("compression = 9, memory = 9, strategy = 0, filter = 5"),
 334                     wxT("compression = 9, memory = 8, strategy = 1, filter = 5"),
 335                     wxT("compression = 9, memory = 9, strategy = 1, filter = 5"),
 336                     wxT("compression = 1, memory = 8, strategy = 2, filter = 5"),
 337                     wxT("compression = 1, memory = 9, strategy = 2, filter = 5"),
 338                 };
 339
 340                 int sel = wxGetSingleChoiceIndex(wxT("Select compression option (Cancel to use default)\n"),
 341                                                  wxT("PNG Compression Options"),
 342                                                  WXSIZEOF(compressionChoices),
 343                                                  compressionChoices,
 344                                                  this);
 345                 if (sel != -1)
 346                 {
 347                     const int zc[] = {9, 9, 9, 9, 1, 1, 9, 9, 9, 9, 1, 1};
 348                     const int zm[] = {8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9};
 349                     const int zs[] = {0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2};
 350                     const int f[]  = {0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
 351                                       0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8};
 352
 353                     image.SetOption(wxIMAGE_OPTION_PNG_COMPRESSION_LEVEL      , zc[sel]);
 354                     image.SetOption(wxIMAGE_OPTION_PNG_COMPRESSION_MEM_LEVEL  , zm[sel]);
 355                     image.SetOption(wxIMAGE_OPTION_PNG_COMPRESSION_STRATEGY   , zs[sel]);
 356                     image.SetOption(wxIMAGE_OPTION_PNG_FILTER                 , f[sel]);
 357                     image.SetOption(wxIMAGE_OPTION_PNG_COMPRESSION_BUFFER_SIZE, 1048576); // 1 MB
 358                 }
 359             }
 360         }
 361 #endif // wxUSE_LIBPNG
 362         else if ( extension == wxT("cur") )
 363         {
 364             image.Rescale(32,32);
 365             image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, 0);
 366             image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, 0);
 367             // This shows how you can save an image with explicitly
 368             // specified image format:
 369             saved = image.SaveFile(savefilename, wxBITMAP_TYPE_CUR);
 370         }
 371
 372         if ( !saved )
 373         {
 374             // This one guesses image format from filename extension
 375             // (it may fail if the extension is not recognized):
 376             image.SaveFile(savefilename);
 377         }
 378 #endif // wxUSE_FILEDLG
 379     }
 380
 381     void OnResize(wxCommandEvent& WXUNUSED(event))
 382     {
 383         wxImage img(m_bitmap.ConvertToImage());
 384
 385         const wxSize size = GetClientSize();
 386         img.Rescale(size.x, size.y, wxIMAGE_QUALITY_HIGH);
 387         m_bitmap = wxBitmap(img);
 388
 389         UpdateStatusBar();
 390     }
 391
 392     void OnZoom(wxCommandEvent& event)
 393     {
 394         if ( event.GetId() == wxID_ZOOM_IN )
 395             m_zoom *= 1.2;
 396         else if ( event.GetId() == wxID_ZOOM_OUT )
 397             m_zoom /= 1.2;
 398         else // wxID_ZOOM_100
 399             m_zoom = 1.;
 400
 401         UpdateStatusBar();
 402     }
 403
 404     void OnRotate(wxCommandEvent& event)
 405     {
 406         double angle = 5;
 407         if ( event.GetId() == ID_ROTATE_LEFT )
 408             angle = -angle;
 409
 410         wxImage img(m_bitmap.ConvertToImage());
 411         img = img.Rotate(angle, wxPoint(img.GetWidth() / 2, img.GetHeight() / 2));
 412         if ( !img.Ok() )
 413         {
 414             wxLogWarning(wxT("Rotation failed"));
 415             return;
 416         }
 417
 418         m_bitmap = wxBitmap(img);
 419
 420         UpdateStatusBar();
 421     }
 422
 423     void UpdateStatusBar()
 424     {
 425         wxLogStatus(this, wxT("Image size: (%d, %d), zoom %.2f"),
 426                     m_bitmap.GetWidth(),
 427                     m_bitmap.GetHeight(),
 428                     m_zoom);
 429         Refresh();
 430     }
 431
 432     wxBitmap m_bitmap;
 433     double m_zoom;
 434
 435     DECLARE_EVENT_TABLE()
 436 };
 437
 438 #ifdef wxHAVE_RAW_BITMAP
 439
 440 #include "wx/rawbmp.h"
 441
 442 class MyRawBitmapFrame : public wxFrame
 443 {
 444 public:
 445     enum
 446     {
 447         BORDER = 15,
 448         SIZE = 150,
 449         REAL_SIZE = SIZE - 2*BORDER
 450     };
 451
 452     MyRawBitmapFrame(wxFrame *parent)
 453         : wxFrame(parent, wxID_ANY, wxT("Raw bitmaps (how exciting)")),
 454         m_bitmap(SIZE, SIZE, 24),
 455         m_alphaBitmap(SIZE, SIZE, 32)
 456     {
 457         SetClientSize(SIZE, SIZE*2+25);
 458
 459         InitAlphaBitmap();
 460         InitBitmap();
 461
 462     }
 463
 464     void InitAlphaBitmap()
 465     {
 466         // First, clear the whole bitmap by making it alpha
 467         {
 468             wxAlphaPixelData data( m_alphaBitmap, wxPoint(0,0), wxSize(SIZE, SIZE) );
 469             if ( !data )
 470             {
 471                 wxLogError(wxT("Failed to gain raw access to bitmap data"));
 472                 return;
 473             }
 474             wxAlphaPixelData::Iterator p(data);
 475             for ( int y = 0; y < SIZE; ++y )
 476             {
 477                 wxAlphaPixelData::Iterator rowStart = p;
 478                 for ( int x = 0; x < SIZE; ++x )
 479                 {
 480                     p.Alpha() = 0;
 481                     ++p; // same as p.OffsetX(1)
 482                 }
 483                 p = rowStart;
 484                 p.OffsetY(data, 1);
 485             }
 486         }
 487
 488         // Then, draw colourful alpha-blended stripes
 489         wxAlphaPixelData data(m_alphaBitmap, wxPoint(BORDER, BORDER),
 490                             wxSize(REAL_SIZE, REAL_SIZE));
 491         if ( !data )
 492         {
 493             wxLogError(wxT("Failed to gain raw access to bitmap data"));
 494             return;
 495         }
 496
 497         wxAlphaPixelData::Iterator p(data);
 498
 499         for ( int y = 0; y < REAL_SIZE; ++y )
 500         {
 501             wxAlphaPixelData::Iterator rowStart = p;
 502
 503             int r = y < REAL_SIZE/3 ? 255 : 0,
 504                 g = (REAL_SIZE/3 <= y) && (y < 2*(REAL_SIZE/3)) ? 255 : 0,
 505                 b = 2*(REAL_SIZE/3) <= y ? 255 : 0;
 506
 507             for ( int x = 0; x < REAL_SIZE; ++x )
 508             {
 509                 // note that RGB must be premultiplied by alpha
 510                 unsigned a = (wxAlphaPixelData::Iterator::ChannelType)((x*255.)/REAL_SIZE);
 511                 p.Red() = r * a / 256;
 512                 p.Green() = g * a / 256;
 513                 p.Blue() = b * a / 256;
 514                 p.Alpha() = a;
 515
 516                 ++p; // same as p.OffsetX(1)
 517             }
 518
 519             p = rowStart;
 520             p.OffsetY(data, 1);
 521         }
 522     }
 523
 524     void InitBitmap()
 525     {
 526         // draw some colourful stripes without alpha
 527         wxNativePixelData data(m_bitmap);
 528         if ( !data )
 529         {
 530             wxLogError(wxT("Failed to gain raw access to bitmap data"));
 531             return;
 532         }
 533
 534         wxNativePixelData::Iterator p(data);
 535         for ( int y = 0; y < SIZE; ++y )
 536         {
 537             wxNativePixelData::Iterator rowStart = p;
 538
 539             int r = y < SIZE/3 ? 255 : 0,
 540                 g = (SIZE/3 <= y) && (y < 2*(SIZE/3)) ? 255 : 0,
 541                 b = 2*(SIZE/3) <= y ? 255 : 0;
 542
 543             for ( int x = 0; x < SIZE; ++x )
 544             {
 545                 p.Red() = r;
 546                 p.Green() = g;
 547                 p.Blue() = b;
 548                 ++p; // same as p.OffsetX(1)
 549             }
 550
 551             p = rowStart;
 552             p.OffsetY(data, 1);
 553         }
 554     }
 555
 556     void OnPaint(wxPaintEvent& WXUNUSED(event))
 557     {
 558         wxPaintDC dc( this );
 559         dc.DrawText(wxT("This is alpha and raw bitmap test"), 0, BORDER);
 560         dc.DrawText(wxT("This is alpha and raw bitmap test"), 0, SIZE/2 - BORDER);
 561         dc.DrawText(wxT("This is alpha and raw bitmap test"), 0, SIZE - 2*BORDER);
 562         dc.DrawBitmap( m_alphaBitmap, 0, 0, true /* use mask */ );
 563
 564         dc.DrawText(wxT("Raw bitmap access without alpha"), 0, SIZE+5);
 565         dc.DrawBitmap( m_bitmap, 0, SIZE+5+dc.GetCharHeight());
 566     }
 567
 568 private:
 569     wxBitmap m_bitmap;
 570     wxBitmap m_alphaBitmap;
 571
 572     DECLARE_EVENT_TABLE()
 573 };
 574
 575 #endif // wxHAVE_RAW_BITMAP
 576
 577
 578 // ============================================================================
 579 // implementations
 580 // ============================================================================
 581
 582 //-----------------------------------------------------------------------------
 583 // MyImageFrame
 584 //-----------------------------------------------------------------------------
 585
 586 BEGIN_EVENT_TABLE(MyImageFrame, wxFrame)
 587     EVT_ERASE_BACKGROUND(MyImageFrame::OnEraseBackground)
 588     EVT_PAINT(MyImageFrame::OnPaint)
 589
 590     EVT_MENU(wxID_SAVE, MyImageFrame::OnSave)
 591     EVT_MENU_RANGE(ID_ROTATE_LEFT, ID_ROTATE_RIGHT, MyImageFrame::OnRotate)
 592     EVT_MENU(ID_RESIZE, MyImageFrame::OnResize)
 593
 594     EVT_MENU(wxID_ZOOM_IN, MyImageFrame::OnZoom)
 595     EVT_MENU(wxID_ZOOM_OUT, MyImageFrame::OnZoom)
 596     EVT_MENU(wxID_ZOOM_100, MyImageFrame::OnZoom)
 597 END_EVENT_TABLE()
 598
 599 //-----------------------------------------------------------------------------
 600 // MyRawBitmapFrame
 601 //-----------------------------------------------------------------------------
 602
 603 #ifdef wxHAVE_RAW_BITMAP
 604
 605 BEGIN_EVENT_TABLE(MyRawBitmapFrame, wxFrame)
 606     EVT_PAINT(MyRawBitmapFrame::OnPaint)
 607 END_EVENT_TABLE()
 608
 609 #endif // wxHAVE_RAW_BITMAP
 610
 611 //-----------------------------------------------------------------------------
 612 // MyFrame
 613 //-----------------------------------------------------------------------------
 614
 615 enum
 616 {
 617     ID_QUIT  = wxID_EXIT,
 618     ID_ABOUT = wxID_ABOUT,
 619     ID_NEW = 100,
 620     ID_INFO,
 621     ID_SHOWRAW,
 622     ID_SHOWTHUMBNAIL
 623 };
 624
 625 IMPLEMENT_DYNAMIC_CLASS( MyFrame, wxFrame )
 626 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 627     EVT_MENU    (ID_ABOUT, MyFrame::OnAbout)
 628     EVT_MENU    (ID_QUIT,  MyFrame::OnQuit)
 629     EVT_MENU    (ID_NEW,   MyFrame::OnNewFrame)
 630     EVT_MENU    (ID_INFO,  MyFrame::OnImageInfo)
 631     EVT_MENU    (ID_SHOWTHUMBNAIL, MyFrame::OnThumbnail)
 632 #ifdef wxHAVE_RAW_BITMAP
 633     EVT_MENU    (ID_SHOWRAW, MyFrame::OnTestRawBitmap)
 634 #endif
 635 #if wxUSE_CLIPBOARD
 636     EVT_MENU(wxID_COPY, MyFrame::OnCopy)
 637     EVT_MENU(wxID_PASTE, MyFrame::OnPaste)
 638 #endif // wxUSE_CLIPBOARD
 639 END_EVENT_TABLE()
 640
 641 MyFrame::MyFrame()
 642     : wxFrame( (wxFrame *)NULL, wxID_ANY, wxT("wxImage sample"),
 643                 wxPoint(20, 20), wxSize(950, 700) )
 644 {
 645     SetIcon(wxICON(sample));
 646
 647     wxMenuBar *menu_bar = new wxMenuBar();
 648
 649     wxMenu *menuImage = new wxMenu;
 650     menuImage->Append( ID_NEW, wxT("&Show any image...\tCtrl-O"));
 651     menuImage->Append( ID_INFO, wxT("Show image &information...\tCtrl-I"));
 652 #ifdef wxHAVE_RAW_BITMAP
 653     menuImage->AppendSeparator();
 654     menuImage->Append( ID_SHOWRAW, wxT("Test &raw bitmap...\tCtrl-R"));
 655 #endif
 656     menuImage->AppendSeparator();
 657     menuImage->Append( ID_SHOWTHUMBNAIL, wxT("Test &thumbnail...\tCtrl-T"),
 658                         "Test scaling the image during load (try with JPEG)");
 659     menuImage->AppendSeparator();
 660     menuImage->Append( ID_ABOUT, wxT("&About..."));
 661     menuImage->AppendSeparator();
 662     menuImage->Append( ID_QUIT, wxT("E&xit\tCtrl-Q"));
 663     menu_bar->Append(menuImage, wxT("&Image"));
 664
 665 #if wxUSE_CLIPBOARD
 666     wxMenu *menuClipboard = new wxMenu;
 667     menuClipboard->Append(wxID_COPY, wxT("&Copy test image\tCtrl-C"));
 668     menuClipboard->Append(wxID_PASTE, wxT("&Paste image\tCtrl-V"));
 669     menu_bar->Append(menuClipboard, wxT("&Clipboard"));
 670 #endif // wxUSE_CLIPBOARD
 671
 672     SetMenuBar( menu_bar );
 673
 674 #if wxUSE_STATUSBAR
 675     CreateStatusBar(2);
 676     int widths[] = { -1, 100 };
 677     SetStatusWidths( 2, widths );
 678 #endif // wxUSE_STATUSBAR
 679
 680     m_canvas = new MyCanvas( this, wxID_ANY, wxPoint(0,0), wxSize(10,10) );
 681
 682     // 500 width * 2750 height
 683     m_canvas->SetScrollbars( 10, 10, 50, 275 );
 684 }
 685
 686 void MyFrame::OnQuit( wxCommandEvent &WXUNUSED(event) )
 687 {
 688     Close( true );
 689 }
 690
 691 void MyFrame::OnAbout( wxCommandEvent &WXUNUSED(event) )
 692 {
 693     (void)wxMessageBox( "wxImage demo\n"
 694                         "(c) Robert Roebling 1998-2005"
 695                         "(c) Vadim Zeitlin 2005-2009",
 696                         "About wxImage Demo",
 697                         wxICON_INFORMATION | wxOK );
 698 }
 699
 700 wxString MyFrame::LoadUserImage(wxImage& image)
 701 {
 702     wxString filename;
 703
 704 #if wxUSE_FILEDLG
 705     filename = wxLoadFileSelector(wxT("image"), wxEmptyString);
 706     if ( !filename.empty() )
 707     {
 708         if ( !image.LoadFile(filename) )
 709         {
 710             wxLogError(wxT("Couldn't load image from '%s'."), filename.c_str());
 711
 712             return wxEmptyString;
 713         }
 714     }
 715 #endif // wxUSE_FILEDLG
 716
 717     return filename;
 718 }
 719
 720 void MyFrame::OnNewFrame( wxCommandEvent &WXUNUSED(event) )
 721 {
 722     wxImage image;
 723     wxString filename = LoadUserImage(image);
 724     if ( !filename.empty() )
 725         new MyImageFrame(this, filename, image);
 726 }
 727
 728 void MyFrame::OnImageInfo( wxCommandEvent &WXUNUSED(event) )
 729 {
 730     wxImage image;
 731     if ( !LoadUserImage(image).empty() )
 732     {
 733         // TODO: show more information about the file
 734         wxString info = wxString::Format("Image size: %dx%d",
 735                                         image.GetWidth(),
 736                                         image.GetHeight());
 737
 738         int xres = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX),
 739             yres = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY);
 740         if ( xres || yres )
 741         {
 742             info += wxString::Format("\nResolution: %dx%d", xres, yres);
 743             switch ( image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT) )
 744             {
 745                 default:
 746                     wxFAIL_MSG( "unknown image resolution units" );
 747                     // fall through
 748
 749                 case wxIMAGE_RESOLUTION_NONE:
 750                     info += " in default units";
 751                     break;
 752
 753                 case wxIMAGE_RESOLUTION_INCHES:
 754                     info += " in";
 755                     break;
 756
 757                 case wxIMAGE_RESOLUTION_CM:
 758                     info += " cm";
 759                     break;
 760             }
 761         }
 762
 763         wxLogMessage("%s", info);
 764     }
 765 }
 766
 767 #ifdef wxHAVE_RAW_BITMAP
 768
 769 void MyFrame::OnTestRawBitmap( wxCommandEvent &WXUNUSED(event) )
 770 {
 771     (new MyRawBitmapFrame(this))->Show();
 772 }
 773
 774 #endif // wxHAVE_RAW_BITMAP
 775
 776 #if wxUSE_CLIPBOARD
 777
 778 void MyFrame::OnCopy(wxCommandEvent& WXUNUSED(event))
 779 {
 780     wxBitmapDataObject *dobjBmp = new wxBitmapDataObject;
 781     dobjBmp->SetBitmap(m_canvas->my_horse_png);
 782
 783     wxTheClipboard->Open();
 784
 785     if ( !wxTheClipboard->SetData(dobjBmp) )
 786     {
 787         wxLogError(wxT("Failed to copy bitmap to clipboard"));
 788     }
 789
 790     wxTheClipboard->Close();
 791 }
 792
 793 void MyFrame::OnPaste(wxCommandEvent& WXUNUSED(event))
 794 {
 795     wxBitmapDataObject dobjBmp;
 796
 797     wxTheClipboard->Open();
 798     if ( !wxTheClipboard->GetData(dobjBmp) )
 799     {
 800         wxLogMessage(wxT("No bitmap data in the clipboard"));
 801     }
 802     else
 803     {
 804         new MyImageFrame(this, wxT("Clipboard"), dobjBmp.GetBitmap());
 805     }
 806     wxTheClipboard->Close();
 807 }
 808
 809 #endif // wxUSE_CLIPBOARD
 810
 811 void MyFrame::OnThumbnail( wxCommandEvent &WXUNUSED(event) )
 812 {
 813 #if wxUSE_FILEDLG
 814     wxString filename = wxLoadFileSelector(wxT("image"), wxEmptyString, wxEmptyString, this);
 815     if ( filename.empty() )
 816         return;
 817
 818     static const int THUMBNAIL_WIDTH = 320;
 819     static const int THUMBNAIL_HEIGHT = 240;
 820
 821     wxImage image;
 822     image.SetOption(wxIMAGE_OPTION_MAX_WIDTH, THUMBNAIL_WIDTH);
 823     image.SetOption(wxIMAGE_OPTION_MAX_HEIGHT, THUMBNAIL_HEIGHT);
 824
 825     wxStopWatch sw;
 826     if ( !image.LoadFile(filename) )
 827     {
 828         wxLogError(wxT("Couldn't load image from '%s'."), filename.c_str());
 829         return;
 830     }
 831
 832     const long loadTime = sw.Time();
 833
 834     MyImageFrame * const frame = new MyImageFrame(this, filename, image);
 835     wxLogStatus(frame, "Loaded \"%s\" in %ldms", filename, loadTime);
 836 #else
 837     wxLogError( wxT("Couldn't create file selector dialog") );
 838     return;
 839 #endif // wxUSE_FILEDLG
 840 }
 841
 842 //-----------------------------------------------------------------------------
 843 // MyApp
 844 //-----------------------------------------------------------------------------
 845
 846 IMPLEMENT_APP(MyApp)
 847
 848 bool MyApp::OnInit()
 849 {
 850     if ( !wxApp::OnInit() )
 851         return false;
 852
 853     wxInitAllImageHandlers();
 854
 855     wxFrame *frame = new MyFrame();
 856     frame->Show( true );
 857
 858     return true;
 859 }