ensure all topic overviews have an horizontal rule with the list of the sections...

[wxWidgets.git] / samples / image / image.cpp

diff --git a/samples/image/image.cpp b/samples/image/image.cpp
index 85358943f9df08a90569bd0c9837ec235de84ef2..a365d34310ec4c4f5128e12747165b0f25d384e9 100644 (file)
--- a/samples/image/image.cpp
+++ b/samples/image/image.cpp
@@ -17,7 +17,7 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-#include "wx/wx.h"
+    #include "wx/wx.h"

 #endif
 
 #include "wx/image.h"
 #endif
 
 #include "wx/image.h"


@@ -69,6 +69,7 @@ public:
     wxBitmap  my_horse_pcx;
     wxBitmap  my_horse_pnm;
     wxBitmap  my_horse_tiff;
     wxBitmap  my_horse_pcx;
     wxBitmap  my_horse_pnm;
     wxBitmap  my_horse_tiff;

+    wxBitmap  my_horse_tga;

     wxBitmap  my_horse_xpm;
     wxBitmap  my_horse_ico32;
     wxBitmap  my_horse_ico16;
     wxBitmap  my_horse_xpm;
     wxBitmap  my_horse_ico32;
     wxBitmap  my_horse_ico16;


@@ -89,7 +90,11 @@ public:
     wxBitmap my_toucan_flipped_horiz;
     wxBitmap my_toucan_flipped_vert;
     wxBitmap my_toucan_flipped_both;
     wxBitmap my_toucan_flipped_horiz;
     wxBitmap my_toucan_flipped_vert;
     wxBitmap my_toucan_flipped_both;

+    wxBitmap my_toucan_grey;

     wxBitmap my_toucan_head;
     wxBitmap my_toucan_head;

+    wxBitmap my_toucan_scaled_normal;
+    wxBitmap my_toucan_scaled_high;
+    wxBitmap my_toucan_blur;

 
     int xH, yH ;
     int m_ani_images;
 
     int xH, yH ;
     int m_ani_images;


@@ -113,6 +118,7 @@ public:
 
     void OnAbout( wxCommandEvent &event );
     void OnNewFrame( wxCommandEvent &event );
 
     void OnAbout( wxCommandEvent &event );
     void OnNewFrame( wxCommandEvent &event );

+    void OnImageInfo( wxCommandEvent &event );

 #ifdef wxHAVE_RAW_BITMAP
     void OnTestRawBitmap( wxCommandEvent &event );
 #endif // wxHAVE_RAW_BITMAP
 #ifdef wxHAVE_RAW_BITMAP
     void OnTestRawBitmap( wxCommandEvent &event );
 #endif // wxHAVE_RAW_BITMAP


@@ -126,20 +132,55 @@ public:
     MyCanvas         *m_canvas;
 
 private:
     MyCanvas         *m_canvas;
 
 private:

+    // ask user for the file name and try to load an image from it
+    //
+    // return the file path on success, empty string if we failed to load the
+    // image or were cancelled by user
+    static wxString LoadUserImage(wxImage& image);
+
+

     DECLARE_DYNAMIC_CLASS(MyFrame)
     DECLARE_EVENT_TABLE()
 };
 
     DECLARE_DYNAMIC_CLASS(MyFrame)
     DECLARE_EVENT_TABLE()
 };
 

+// ----------------------------------------------------------------------------
+// Frame used for showing a standalone image
+// ----------------------------------------------------------------------------
+
+enum
+{
+    ID_ROTATE_LEFT = 100,
+    ID_ROTATE_RIGHT,
+    ID_RESIZE
+};
+

 class MyImageFrame : public wxFrame
 {
 public:
 class MyImageFrame : public wxFrame
 {
 public:

-    MyImageFrame(wxFrame *parent, const wxBitmap& bitmap)
-        : wxFrame(parent, wxID_ANY, _T("Double click to save"),
+    MyImageFrame(wxFrame *parent, const wxString& desc, const wxBitmap& bitmap)
+        : wxFrame(parent, wxID_ANY,
+                  wxString::Format(_T("Image from %s"), desc.c_str()),

                   wxDefaultPosition, wxDefaultSize,
                   wxDefaultPosition, wxDefaultSize,

-                  wxCAPTION | wxSYSTEM_MENU | wxCLOSE_BOX),
+                  wxDEFAULT_FRAME_STYLE | wxFULL_REPAINT_ON_RESIZE),

                   m_bitmap(bitmap)
     {
                   m_bitmap(bitmap)
     {

+        wxMenu *menu = new wxMenu;
+        menu->Append(wxID_SAVE);
+        menu->AppendSeparator();
+        menu->Append(ID_RESIZE, _T("&Fit to window\tCtrl-F"));
+        menu->AppendSeparator();
+        menu->Append(ID_ROTATE_LEFT, _T("Rotate &left\tCtrl-L"));
+        menu->Append(ID_ROTATE_RIGHT, _T("Rotate &right\tCtrl-R"));
+
+        wxMenuBar *mbar = new wxMenuBar;
+        mbar->Append(menu, _T("&Image"));
+        SetMenuBar(mbar);
+
+        CreateStatusBar();
+

         SetClientSize(bitmap.GetWidth(), bitmap.GetHeight());
         SetClientSize(bitmap.GetWidth(), bitmap.GetHeight());

+
+        UpdateStatusBar();

     }
 
     void OnEraseBackground(wxEraseEvent& WXUNUSED(event))
     }
 
     void OnEraseBackground(wxEraseEvent& WXUNUSED(event))


@@ -149,11 +190,15 @@ public:
 
     void OnPaint(wxPaintEvent& WXUNUSED(event))
     {
 
     void OnPaint(wxPaintEvent& WXUNUSED(event))
     {

-        wxPaintDC dc( this );
-        dc.DrawBitmap( m_bitmap, 0, 0, true /* use mask */ );
+        wxPaintDC dc(this);
+        const wxSize size = GetClientSize();
+        dc.DrawBitmap(m_bitmap,
+                      (size.x - m_bitmap.GetWidth())/2,
+                      (size.y - m_bitmap.GetHeight())/2,
+                      true /* use mask */);

     }
 
     }
 

-    void OnSave(wxMouseEvent& WXUNUSED(event))
+    void OnSave(wxCommandEvent& WXUNUSED(event))

     {
 #if wxUSE_FILEDLG
         wxImage image = m_bitmap.ConvertToImage();
     {
 #if wxUSE_FILEDLG
         wxImage image = m_bitmap.ConvertToImage();


@@ -180,7 +225,7 @@ public:
         wxFileName::SplitPath(savefilename, NULL, NULL, &extension);
 
         bool saved = false;
         wxFileName::SplitPath(savefilename, NULL, NULL, &extension);
 
         bool saved = false;

-        if ( extension == _T("bpp") )
+        if ( extension == _T("bmp") )

         {
             static const int bppvalues[] =
             {
         {
             static const int bppvalues[] =
             {


@@ -279,7 +324,46 @@ public:
 #endif // wxUSE_FILEDLG
     }
 
 #endif // wxUSE_FILEDLG
     }
 

+    void OnResize(wxCommandEvent& WXUNUSED(event))
+    {
+        wxImage img(m_bitmap.ConvertToImage());
+
+        const wxSize size = GetClientSize();
+        img.Rescale(size.x, size.y, wxIMAGE_QUALITY_HIGH);
+        m_bitmap = wxBitmap(img);
+
+        UpdateStatusBar();
+        Refresh();
+    }
+
+    void OnRotate(wxCommandEvent& event)
+    {
+        double angle = 5;
+        if ( event.GetId() == ID_ROTATE_LEFT )
+            angle = -angle;
+
+        wxImage img(m_bitmap.ConvertToImage());
+        img = img.Rotate(angle, wxPoint(img.GetWidth() / 2, img.GetHeight() / 2));
+        if ( !img.Ok() )
+        {
+            wxLogWarning(_T("Rotation failed"));
+            return;
+        }
+
+        m_bitmap = wxBitmap(img);
+
+        UpdateStatusBar();
+        Refresh();
+    }
+

 private:
 private:

+    void UpdateStatusBar()
+    {
+        wxLogStatus(this, _T("Image size: (%d, %d)"),
+                    m_bitmap.GetWidth(),
+                    m_bitmap.GetHeight());
+    }
+

     wxBitmap m_bitmap;
 
     DECLARE_EVENT_TABLE()
     wxBitmap m_bitmap;
 
     DECLARE_EVENT_TABLE()


@@ -301,28 +385,30 @@ public:
 
     MyRawBitmapFrame(wxFrame *parent)
         : wxFrame(parent, wxID_ANY, _T("Raw bitmaps (how exciting)")),
 
     MyRawBitmapFrame(wxFrame *parent)
         : wxFrame(parent, wxID_ANY, _T("Raw bitmaps (how exciting)")),

-          m_bitmap(SIZE, SIZE, 32)
+          m_bitmap(SIZE, SIZE, 24),
+          m_alphaBitmap(SIZE, SIZE, 32)

     {
     {

-        SetClientSize(SIZE, SIZE);
+        SetClientSize(SIZE, SIZE*2+25);
+
+        InitAlphaBitmap();
+        InitBitmap();

 
 

-        // another possibility: wxNativePixelData (don't forget to remove code
-        // setting alpha in the loop below then)
-        typedef wxAlphaPixelData Data;
-        // typedef wxNativePixelData Data;
+    }

 
 

+    void InitAlphaBitmap()
+    {

         // First, clear the whole bitmap by making it alpha
         {
         // First, clear the whole bitmap by making it alpha
         {

-            Data data( m_bitmap, wxPoint(0,0), wxSize(SIZE, SIZE) );
+            wxAlphaPixelData data( m_alphaBitmap, wxPoint(0,0), wxSize(SIZE, SIZE) );

             if ( !data )
             {
                 wxLogError(_T("Failed to gain raw access to bitmap data"));
                 return;
             }
             if ( !data )
             {
                 wxLogError(_T("Failed to gain raw access to bitmap data"));
                 return;
             }

-            data.UseAlpha();
-            Data::Iterator p(data);
+            wxAlphaPixelData::Iterator p(data);

             for ( int y = 0; y < SIZE; ++y )
             {
             for ( int y = 0; y < SIZE; ++y )
             {

-                Data::Iterator rowStart = p;
+                wxAlphaPixelData::Iterator rowStart = p;

                 for ( int x = 0; x < SIZE; ++x )
                 {
                     p.Alpha() = 0;
                 for ( int x = 0; x < SIZE; ++x )
                 {
                     p.Alpha() = 0;


@@ -334,20 +420,19 @@ public:
         }
 
         // Then, draw colourful alpha-blended stripes
         }
 
         // Then, draw colourful alpha-blended stripes

-        Data data(m_bitmap, wxPoint(BORDER, BORDER) , wxSize(REAL_SIZE, REAL_SIZE));
+        wxAlphaPixelData data(m_alphaBitmap, wxPoint(BORDER, BORDER),
+                              wxSize(REAL_SIZE, REAL_SIZE));

         if ( !data )
         {
             wxLogError(_T("Failed to gain raw access to bitmap data"));
             return;
         }
 
         if ( !data )
         {
             wxLogError(_T("Failed to gain raw access to bitmap data"));
             return;
         }
 

-        data.UseAlpha();
-
-        Data::Iterator p(data);
+        wxAlphaPixelData::Iterator p(data);

 
         for ( int y = 0; y < REAL_SIZE; ++y )
         {
 
         for ( int y = 0; y < REAL_SIZE; ++y )
         {

-            Data::Iterator rowStart = p;
+            wxAlphaPixelData::Iterator rowStart = p;

 
             int r = y < REAL_SIZE/3 ? 255 : 0,
                 g = (REAL_SIZE/3 <= y) && (y < 2*(REAL_SIZE/3)) ? 255 : 0,
 
             int r = y < REAL_SIZE/3 ? 255 : 0,
                 g = (REAL_SIZE/3 <= y) && (y < 2*(REAL_SIZE/3)) ? 255 : 0,


@@ -356,7 +441,7 @@ public:
             for ( int x = 0; x < REAL_SIZE; ++x )
             {
                 // note that RGB must be premultiplied by alpha
             for ( int x = 0; x < REAL_SIZE; ++x )
             {
                 // note that RGB must be premultiplied by alpha

-                unsigned a = (Data::Iterator::ChannelType)((x*255.)/REAL_SIZE);
+                unsigned a = (wxAlphaPixelData::Iterator::ChannelType)((x*255.)/REAL_SIZE);

                 p.Red() = r * a / 256;
                 p.Green() = g * a / 256;
                 p.Blue() = b * a / 256;
                 p.Red() = r * a / 256;
                 p.Green() = g * a / 256;
                 p.Blue() = b * a / 256;


@@ -370,17 +455,53 @@ public:
         }
     }
 
         }
     }
 

+    void InitBitmap()
+    {
+        // draw some colourful stripes without alpha
+        wxNativePixelData data(m_bitmap);
+        if ( !data )
+        {
+            wxLogError(_T("Failed to gain raw access to bitmap data"));
+            return;
+        }
+
+        wxNativePixelData::Iterator p(data);
+        for ( int y = 0; y < SIZE; ++y )
+        {
+            wxNativePixelData::Iterator rowStart = p;
+
+            int r = y < SIZE/3 ? 255 : 0,
+                g = (SIZE/3 <= y) && (y < 2*(SIZE/3)) ? 255 : 0,
+                b = 2*(SIZE/3) <= y ? 255 : 0;
+
+            for ( int x = 0; x < SIZE; ++x )
+            {
+                p.Red() = r;
+                p.Green() = g;
+                p.Blue() = b;
+                ++p; // same as p.OffsetX(1)
+            }
+
+            p = rowStart;
+            p.OffsetY(data, 1);
+        }
+    }
+

     void OnPaint(wxPaintEvent& WXUNUSED(event))
     {
         wxPaintDC dc( this );
         dc.DrawText(_T("This is alpha and raw bitmap test"), 0, BORDER);
         dc.DrawText(_T("This is alpha and raw bitmap test"), 0, SIZE/2 - BORDER);
         dc.DrawText(_T("This is alpha and raw bitmap test"), 0, SIZE - 2*BORDER);
     void OnPaint(wxPaintEvent& WXUNUSED(event))
     {
         wxPaintDC dc( this );
         dc.DrawText(_T("This is alpha and raw bitmap test"), 0, BORDER);
         dc.DrawText(_T("This is alpha and raw bitmap test"), 0, SIZE/2 - BORDER);
         dc.DrawText(_T("This is alpha and raw bitmap test"), 0, SIZE - 2*BORDER);

-        dc.DrawBitmap( m_bitmap, 0, 0, true /* use mask */ );
+        dc.DrawBitmap( m_alphaBitmap, 0, 0, true /* use mask */ );
+
+        dc.DrawText(_T("Raw bitmap access without alpha"), 0, SIZE+5);
+        dc.DrawBitmap( m_bitmap, 0, SIZE+5+dc.GetCharHeight());

     }
 
 private:
     wxBitmap m_bitmap;
     }
 
 private:
     wxBitmap m_bitmap;

+    wxBitmap m_alphaBitmap;

 
     DECLARE_EVENT_TABLE()
 };
 
     DECLARE_EVENT_TABLE()
 };


@@ -404,7 +525,10 @@ IMPLEMENT_APP(MyApp)
 BEGIN_EVENT_TABLE(MyImageFrame, wxFrame)
     EVT_ERASE_BACKGROUND(MyImageFrame::OnEraseBackground)
     EVT_PAINT(MyImageFrame::OnPaint)
 BEGIN_EVENT_TABLE(MyImageFrame, wxFrame)
     EVT_ERASE_BACKGROUND(MyImageFrame::OnEraseBackground)
     EVT_PAINT(MyImageFrame::OnPaint)

-    EVT_LEFT_DCLICK(MyImageFrame::OnSave)
+
+    EVT_MENU(wxID_SAVE, MyImageFrame::OnSave)
+    EVT_MENU_RANGE(ID_ROTATE_LEFT, ID_ROTATE_RIGHT, MyImageFrame::OnRotate)
+    EVT_MENU(ID_RESIZE, MyImageFrame::OnResize)

 END_EVENT_TABLE()
 
 #ifdef wxHAVE_RAW_BITMAP
 END_EVENT_TABLE()
 
 #ifdef wxHAVE_RAW_BITMAP


@@ -416,14 +540,14 @@ END_EVENT_TABLE()
 #endif // wxHAVE_RAW_BITMAP
 
 BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
 #endif // wxHAVE_RAW_BITMAP
 
 BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)

-  EVT_PAINT(MyCanvas::OnPaint)
+    EVT_PAINT(MyCanvas::OnPaint)

 END_EVENT_TABLE()
 
 MyCanvas::MyCanvas( wxWindow *parent, wxWindowID id,
                     const wxPoint &pos, const wxSize &size )
 END_EVENT_TABLE()
 
 MyCanvas::MyCanvas( wxWindow *parent, wxWindowID id,
                     const wxPoint &pos, const wxSize &size )

-        : wxScrolledWindow( parent, id, pos, size, wxSUNKEN_BORDER )
-          , m_bmpSmileXpm((const char **) smile_xpm)
-          , m_iconSmileXpm((const char **) smile_xpm)
+    : wxScrolledWindow( parent, id, pos, size, wxSUNKEN_BORDER )
+    , m_bmpSmileXpm(smile_xpm)
+    , m_iconSmileXpm(smile_xpm)

 {
     my_horse_ani = NULL;
     m_ani_images = 0 ;
 {
     my_horse_ani = NULL;
     m_ani_images = 0 ;


@@ -468,12 +592,19 @@ MyCanvas::MyCanvas( wxWindow *parent, wxWindowID id,
     else
         my_horse_png = wxBitmap( image );
 
     else
         my_horse_png = wxBitmap( image );
 

-    image = wxImage(wxT("toucan.png"));
-    my_toucan = wxBitmap(image);
+    if ( !image.LoadFile( dir + _T("toucan.png")) )
+        wxLogError(wxT("Can't load PNG image"));
+    else
+        my_toucan = wxBitmap(image);
+

     my_toucan_flipped_horiz = wxBitmap(image.Mirror(true));
     my_toucan_flipped_vert = wxBitmap(image.Mirror(false));
     my_toucan_flipped_both = wxBitmap(image.Mirror(true).Mirror(false));
     my_toucan_flipped_horiz = wxBitmap(image.Mirror(true));
     my_toucan_flipped_vert = wxBitmap(image.Mirror(false));
     my_toucan_flipped_both = wxBitmap(image.Mirror(true).Mirror(false));

+    my_toucan_grey = wxBitmap(image.ConvertToGreyscale());

     my_toucan_head = wxBitmap(image.GetSubImage(wxRect(40, 7, 80, 60)));
     my_toucan_head = wxBitmap(image.GetSubImage(wxRect(40, 7, 80, 60)));

+    my_toucan_scaled_normal = wxBitmap(image.Scale(110,90,wxIMAGE_QUALITY_NORMAL));
+    my_toucan_scaled_high = wxBitmap(image.Scale(110,90,wxIMAGE_QUALITY_HIGH));
+    my_toucan_blur = wxBitmap(image.Blur(10));

 
 #endif // wxUSE_LIBPNG
 
 
 #endif // wxUSE_LIBPNG
 


@@ -568,6 +699,15 @@ MyCanvas::MyCanvas( wxWindow *parent, wxWindowID id,
         my_horse_tiff = wxBitmap( image );
 #endif
 
         my_horse_tiff = wxBitmap( image );
 #endif
 

+#if wxUSE_LIBTIFF
+    image.Destroy();
+
+    if ( !image.LoadFile( dir + _T("horse.tga"), wxBITMAP_TYPE_TGA ) )
+        wxLogError(wxT("Can't load TGA image"));
+    else
+        my_horse_tga = wxBitmap( image );
+#endif
+

     CreateAntiAliasedBitmap();
 
     my_smile_xbm = wxBitmap( (const char*)smile_bits, smile_width,
     CreateAntiAliasedBitmap();
 
     my_smile_xbm = wxBitmap( (const char*)smile_bits, smile_width,


@@ -732,42 +872,64 @@ void MyCanvas::OnPaint( wxPaintEvent &WXUNUSED(event) )
     if (my_horse_tiff.Ok())
         dc.DrawBitmap( my_horse_tiff, 30, 1530 );
 
     if (my_horse_tiff.Ok())
         dc.DrawBitmap( my_horse_tiff, 30, 1530 );
 

-    dc.DrawText( _T("XPM handler"), 30, 1745 );
+    dc.DrawText( _T("TGA handler"), 30, 1745 );
+    if (my_horse_tga.Ok())
+        dc.DrawBitmap( my_horse_tga, 30, 1760 );
+
+    dc.DrawText( _T("XPM handler"), 30, 1975 );

     if (my_horse_xpm.Ok())
     if (my_horse_xpm.Ok())

-        dc.DrawBitmap( my_horse_xpm, 30, 1760 );
+        dc.DrawBitmap( my_horse_xpm, 30, 2000 );

 
     // toucans
     {
         int x = 750, y = 10, yy = 170;
 
         dc.DrawText(wxT("Original toucan"), x+50, y);
 
     // toucans
     {
         int x = 750, y = 10, yy = 170;
 
         dc.DrawText(wxT("Original toucan"), x+50, y);

-        dc.DrawBitmap(my_toucan, x, y+15);
+        dc.DrawBitmap(my_toucan, x, y+15, true);

         y += yy;
         dc.DrawText(wxT("Flipped horizontally"), x+50, y);
         y += yy;
         dc.DrawText(wxT("Flipped horizontally"), x+50, y);

-        dc.DrawBitmap(my_toucan_flipped_horiz, x, y+15);
+        dc.DrawBitmap(my_toucan_flipped_horiz, x, y+15, true);

         y += yy;
         dc.DrawText(wxT("Flipped vertically"), x+50, y);
         y += yy;
         dc.DrawText(wxT("Flipped vertically"), x+50, y);

-        dc.DrawBitmap(my_toucan_flipped_vert, x, y+15);
+        dc.DrawBitmap(my_toucan_flipped_vert, x, y+15, true);

         y += yy;
         dc.DrawText(wxT("Flipped both h&v"), x+50, y);
         y += yy;
         dc.DrawText(wxT("Flipped both h&v"), x+50, y);

-        dc.DrawBitmap(my_toucan_flipped_both, x, y+15);
+        dc.DrawBitmap(my_toucan_flipped_both, x, y+15, true);
+
+        y += yy;
+        dc.DrawText(wxT("In greyscale"), x+50, y);
+        dc.DrawBitmap(my_toucan_grey, x, y+15, true);

 
         y += yy;
         dc.DrawText(wxT("Toucan's head"), x+50, y);
 
         y += yy;
         dc.DrawText(wxT("Toucan's head"), x+50, y);

-        dc.DrawBitmap(my_toucan_head, x, y+15);
+        dc.DrawBitmap(my_toucan_head, x, y+15, true);
+
+        y += yy;
+        dc.DrawText(wxT("Scaled with normal quality"), x+50, y);
+        dc.DrawBitmap(my_toucan_scaled_normal, x, y+15, true);
+
+        y += yy;
+        dc.DrawText(wxT("Scaled with high quality"), x+50, y);
+        dc.DrawBitmap(my_toucan_scaled_high, x, y+15, true);
+
+        y += yy;
+        dc.DrawText(wxT("Blured"), x+50, y);
+        dc.DrawBitmap(my_toucan_blur, x, y+15, true);

     }
 
     if (my_smile_xbm.Ok())
     {
     }
 
     if (my_smile_xbm.Ok())
     {

-        dc.DrawText( _T("XBM bitmap"), 30, 1975 );
-        dc.DrawText( _T("(green on red)"), 30, 1990 );
+        int x = 300, y = 1800;
+
+        dc.DrawText( _T("XBM bitmap"), x, y );
+        dc.DrawText( _T("(green on red)"), x, y + 15 );

         dc.SetTextForeground( _T("GREEN") );
         dc.SetTextBackground( _T("RED") );
         dc.SetTextForeground( _T("GREEN") );
         dc.SetTextBackground( _T("RED") );

-        dc.DrawBitmap( my_smile_xbm, 30, 2010 );
+        dc.DrawBitmap( my_smile_xbm, x, y + 30 );

 
 

-        dc.SetTextForeground( wxT("BLACK") );
-        dc.DrawText( _T("After wxImage conversion"), 150, 1975 );
-        dc.DrawText( _T("(red on white)"), 150, 1990 );
+        dc.SetTextForeground( *wxBLACK );
+        dc.DrawText( _T("After wxImage conversion"), x + 120, y );
+        dc.DrawText( _T("(red on white)"), x + 120, y + 15 );

         dc.SetTextForeground( wxT("RED") );
         wxImage i = my_smile_xbm.ConvertToImage();
         i.SetMaskColour( 255, 255, 255 );
         dc.SetTextForeground( wxT("RED") );
         wxImage i = my_smile_xbm.ConvertToImage();
         i.SetMaskColour( 255, 255, 255 );


@@ -775,8 +937,8 @@ void MyCanvas::OnPaint( wxPaintEvent &WXUNUSED(event) )
                wxRED_PEN->GetColour().Red(),
                wxRED_PEN->GetColour().Green(),
                wxRED_PEN->GetColour().Blue() );
                wxRED_PEN->GetColour().Red(),
                wxRED_PEN->GetColour().Green(),
                wxRED_PEN->GetColour().Blue() );

-        dc.DrawBitmap( wxBitmap(i), 150, 2010, true );
-        dc.SetTextForeground( wxT("BLACK") );
+        dc.DrawBitmap( wxBitmap(i), x + 120, y + 30, true );
+        dc.SetTextForeground( *wxBLACK );

     }
 
 
     }
 
 


@@ -799,15 +961,17 @@ void MyCanvas::OnPaint( wxPaintEvent &WXUNUSED(event) )
 
     if (mono.Ok())
     {
 
     if (mono.Ok())
     {

-        dc.DrawText( _T("Mono bitmap"), 30, 2095 );
-        dc.DrawText( _T("(red on green)"), 30, 2110 );
+        int x = 300, y = 1900;
+
+        dc.DrawText( _T("Mono bitmap"), x, y );
+        dc.DrawText( _T("(red on green)"), x, y + 15 );

         dc.SetTextForeground( wxT("RED") );
         dc.SetTextBackground( wxT("GREEN") );
         dc.SetTextForeground( wxT("RED") );
         dc.SetTextBackground( wxT("GREEN") );

-        dc.DrawBitmap( mono, 30, 2130 );
+        dc.DrawBitmap( mono, x, y + 30 );

 
 

-        dc.SetTextForeground( wxT("BLACK") );
-        dc.DrawText( _T("After wxImage conversion"), 150, 2095 );
-        dc.DrawText( _T("(red on white)"), 150, 2110 );
+        dc.SetTextForeground( *wxBLACK );
+        dc.DrawText( _T("After wxImage conversion"), x + 120, y );
+        dc.DrawText( _T("(red on white)"), x + 120, y + 15 );

         dc.SetTextForeground( wxT("RED") );
         wxImage i = mono.ConvertToImage();
         i.SetMaskColour( 255,255,255 );
         dc.SetTextForeground( wxT("RED") );
         wxImage i = mono.ConvertToImage();
         i.SetMaskColour( 255,255,255 );


@@ -815,8 +979,8 @@ void MyCanvas::OnPaint( wxPaintEvent &WXUNUSED(event) )
                wxRED_PEN->GetColour().Red(),
                wxRED_PEN->GetColour().Green(),
                wxRED_PEN->GetColour().Blue() );
                wxRED_PEN->GetColour().Red(),
                wxRED_PEN->GetColour().Green(),
                wxRED_PEN->GetColour().Blue() );

-        dc.DrawBitmap( wxBitmap(i), 150, 2130, true );
-        dc.SetTextForeground( wxT("BLACK") );
+        dc.DrawBitmap( wxBitmap(i), x + 120, y + 30, true );
+        dc.SetTextForeground( *wxBLACK );

     }
 
     // For testing transparency
     }
 
     // For testing transparency


@@ -945,17 +1109,19 @@ enum
     ID_QUIT  = wxID_EXIT,
     ID_ABOUT = wxID_ABOUT,
     ID_NEW = 100,
     ID_QUIT  = wxID_EXIT,
     ID_ABOUT = wxID_ABOUT,
     ID_NEW = 100,

-    ID_SHOWRAW = 101
+    ID_INFO,
+    ID_SHOWRAW

 };
 
 IMPLEMENT_DYNAMIC_CLASS( MyFrame, wxFrame )
 
 };
 
 IMPLEMENT_DYNAMIC_CLASS( MyFrame, wxFrame )
 

-BEGIN_EVENT_TABLE(MyFrame,wxFrame)
+BEGIN_EVENT_TABLE(MyFrame, wxFrame)

   EVT_MENU    (ID_ABOUT, MyFrame::OnAbout)
   EVT_MENU    (ID_QUIT,  MyFrame::OnQuit)
   EVT_MENU    (ID_ABOUT, MyFrame::OnAbout)
   EVT_MENU    (ID_QUIT,  MyFrame::OnQuit)

-  EVT_MENU    (ID_NEW,  MyFrame::OnNewFrame)
+  EVT_MENU    (ID_NEW,   MyFrame::OnNewFrame)
+  EVT_MENU    (ID_INFO,  MyFrame::OnImageInfo)

 #ifdef wxHAVE_RAW_BITMAP
 #ifdef wxHAVE_RAW_BITMAP

-  EVT_MENU    (ID_SHOWRAW,  MyFrame::OnTestRawBitmap)
+  EVT_MENU    (ID_SHOWRAW, MyFrame::OnTestRawBitmap)

 #endif
 
 #if wxUSE_CLIPBOARD
 #endif
 
 #if wxUSE_CLIPBOARD


@@ -972,8 +1138,9 @@ MyFrame::MyFrame()
 
   wxMenu *menuImage = new wxMenu;
   menuImage->Append( ID_NEW, _T("&Show any image...\tCtrl-O"));
 
   wxMenu *menuImage = new wxMenu;
   menuImage->Append( ID_NEW, _T("&Show any image...\tCtrl-O"));

-
+  menuImage->Append( ID_INFO, _T("Show image &information...\tCtrl-I"));

 #ifdef wxHAVE_RAW_BITMAP
 #ifdef wxHAVE_RAW_BITMAP

+  menuImage->AppendSeparator();

   menuImage->Append( ID_SHOWRAW, _T("Test &raw bitmap...\tCtrl-R"));
 #endif
   menuImage->AppendSeparator();
   menuImage->Append( ID_SHOWRAW, _T("Test &raw bitmap...\tCtrl-R"));
 #endif
   menuImage->AppendSeparator();


@@ -1015,23 +1182,71 @@ void MyFrame::OnAbout( wxCommandEvent &WXUNUSED(event) )
                       _T("About wxImage Demo"), wxICON_INFORMATION | wxOK );
 }
 
                       _T("About wxImage Demo"), wxICON_INFORMATION | wxOK );
 }
 

-void MyFrame::OnNewFrame( wxCommandEvent &WXUNUSED(event) )
+wxString MyFrame::LoadUserImage(wxImage& image)

 {
 {

+    wxString filename;
+

 #if wxUSE_FILEDLG
 #if wxUSE_FILEDLG

-    wxString filename = wxFileSelector(_T("Select image file"));
-    if ( !filename )
-        return;
+    filename = wxFileSelector(_T("Select image file"));
+    if ( !filename.empty() )
+    {
+        if ( !image.LoadFile(filename) )
+        {
+            wxLogError(_T("Couldn't load image from '%s'."), filename.c_str());
+
+            return wxEmptyString;
+        }
+    }
+#endif // wxUSE_FILEDLG
+
+    return filename;
+}

 
 

+void MyFrame::OnNewFrame( wxCommandEvent &WXUNUSED(event) )
+{

     wxImage image;
     wxImage image;

-    if ( !image.LoadFile(filename) )
+    wxString filename = LoadUserImage(image);
+    if ( !filename.empty() )
+        (new MyImageFrame(this, filename, wxBitmap(image)))->Show();
+}
+
+void MyFrame::OnImageInfo( wxCommandEvent &WXUNUSED(event) )
+{
+    wxImage image;
+    if ( !LoadUserImage(image).empty() )

     {
     {

-        wxLogError(_T("Couldn't load image from '%s'."), filename.c_str());
+        // TODO: show more information about the file
+        wxString info = wxString::Format("Image size: %dx%d",
+                                         image.GetWidth(),
+                                         image.GetHeight());
+
+        int xres = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX),
+            yres = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY);
+        if ( xres || yres )
+        {
+            info += wxString::Format("\nResolution: %dx%d", xres, yres);
+            switch ( image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT) )
+            {
+                default:
+                    wxFAIL_MSG( "unknown image resolution units" );
+                    // fall through

 
 

-        return;
-    }
+                case wxIMAGE_RESOLUTION_NONE:
+                    info += " in default units";
+                    break;

 
 

-    (new MyImageFrame(this, wxBitmap(image)))->Show();
-#endif // wxUSE_FILEDLG
+                case wxIMAGE_RESOLUTION_INCHES:
+                    info += " in";
+                    break;
+
+                case wxIMAGE_RESOLUTION_CM:
+                    info += " cm";
+                    break;
+            }
+        }
+
+        wxLogMessage("%s", info);
+    }

 }
 
 #ifdef wxHAVE_RAW_BITMAP
 }
 
 #ifdef wxHAVE_RAW_BITMAP


@@ -1071,7 +1286,7 @@ void MyFrame::OnPaste(wxCommandEvent& WXUNUSED(event))
     }
     else
     {
     }
     else
     {

-        (new MyImageFrame(this, dobjBmp.GetBitmap()))->Show();
+        (new MyImageFrame(this, _T("Clipboard"), dobjBmp.GetBitmap()))->Show();

     }
     wxTheClipboard->Close();
 }
     }
     wxTheClipboard->Close();
 }


@@ -1084,42 +1299,13 @@ void MyFrame::OnPaste(wxCommandEvent& WXUNUSED(event))
 
 bool MyApp::OnInit()
 {
 
 bool MyApp::OnInit()
 {

-#if wxUSE_LIBPNG
-  wxImage::AddHandler( new wxPNGHandler );
-#endif
-
-#if wxUSE_LIBJPEG
-  wxImage::AddHandler( new wxJPEGHandler );
-#endif
-
-#if wxUSE_LIBTIFF
-  wxImage::AddHandler( new wxTIFFHandler );
-#endif
-
-#if wxUSE_GIF
-  wxImage::AddHandler( new wxGIFHandler );
-#endif
+    if ( !wxApp::OnInit() )
+        return false;

 
 

-#if wxUSE_PCX
-  wxImage::AddHandler( new wxPCXHandler );
-#endif
-
-#if wxUSE_PNM
-  wxImage::AddHandler( new wxPNMHandler );
-#endif
-
-#if wxUSE_XPM
-  wxImage::AddHandler( new wxXPMHandler );
-#endif
-
-#if wxUSE_ICO_CUR
-  wxImage::AddHandler( new wxICOHandler );
-  wxImage::AddHandler( new wxCURHandler );
-  wxImage::AddHandler( new wxANIHandler );
-#endif
+    wxInitAllImageHandlers();

 
 

-  wxFrame *frame = new MyFrame();
-  frame->Show( true );
+    wxFrame *frame = new MyFrame();
+    frame->Show( true );

 
 

-  return true;
+    return true;

 }
 }