samples/drawing/drawing.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        drawing.cpp
   3 // Purpose:     shows and tests wxDC features
   4 // Author:      Robert Roebling
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Robert Roebling
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(__APPLE__)
  21     #pragma implementation
  22     #pragma interface
  23 #endif
  24
  25 // For compilers that support precompilation, includes "wx/wx.h".
  26 #include "wx/wxprec.h"
  27
  28 #ifdef __BORLANDC__
  29     #pragma hdrstop
  30 #endif
  31
  32 // for all others, include the necessary headers (this file is usually all you
  33 // need because it includes almost all "standard" wxWidgets headers
  34 #ifndef WX_PRECOMP
  35     #include "wx/wx.h"
  36 #endif
  37
  38 #include "wx/colordlg.h"
  39 #include "wx/image.h"
  40 #include "wx/artprov.h"
  41
  42 // ----------------------------------------------------------------------------
  43 // ressources
  44 // ----------------------------------------------------------------------------
  45
  46 // the application icon
  47 #if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__) || defined(__WXMGL__) || defined(__WXX11__)
  48     #include "mondrian.xpm"
  49 #endif
  50
  51 // ----------------------------------------------------------------------------
  52 // constants
  53 // ----------------------------------------------------------------------------
  54
  55 // what do we show on screen (there are too many shapes to put them all on
  56 // screen simultaneously)
  57 enum ScreenToShow
  58 {
  59     Show_Default,
  60     Show_Text,
  61     Show_Lines,
  62     Show_Brushes,
  63     Show_Polygons,
  64     Show_Mask,
  65     Show_Ops,
  66     Show_Regions,
  67     Show_Circles
  68 };
  69
  70 // ----------------------------------------------------------------------------
  71 // global variables
  72 // ----------------------------------------------------------------------------
  73
  74 static wxBitmap *gs_bmpNoMask = NULL,
  75                 *gs_bmpWithColMask = NULL,
  76                 *gs_bmpMask = NULL,
  77                 *gs_bmpWithMask = NULL,
  78                 *gs_bmp4 = NULL,
  79                 *gs_bmp4_mono = NULL,
  80                 *gs_bmp36 = NULL;
  81
  82 // ----------------------------------------------------------------------------
  83 // private classes
  84 // ----------------------------------------------------------------------------
  85
  86 // Define a new application type, each program should derive a class from wxApp
  87 class MyApp : public wxApp
  88 {
  89 public:
  90     // override base class virtuals
  91     // ----------------------------
  92
  93     // this one is called on application startup and is a good place for the app
  94     // initialization (doing it here and not in the ctor allows to have an error
  95     // return: if OnInit() returns false, the application terminates)
  96     virtual bool OnInit();
  97
  98     virtual int OnExit() { DeleteBitmaps(); return 0; }
  99
 100 protected:
 101     void DeleteBitmaps();
 102
 103     bool LoadImages();
 104 };
 105
 106 class MyCanvas;
 107
 108 // Define a new frame type: this is going to be our main frame
 109 class MyFrame : public wxFrame
 110 {
 111 public:
 112     // ctor(s)
 113     MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size);
 114
 115     // event handlers (these functions should _not_ be virtual)
 116     void OnQuit(wxCommandEvent& event);
 117     void OnAbout(wxCommandEvent& event);
 118     void OnClip(wxCommandEvent& event);
 119     void OnShow(wxCommandEvent &event);
 120     void OnOption(wxCommandEvent &event);
 121
 122 #if wxUSE_COLOURDLG
 123     wxColour SelectColour();
 124 #endif // wxUSE_COLOURDLG
 125     void PrepareDC(wxDC& dc);
 126
 127     int         m_backgroundMode;
 128     int         m_textureBackground;
 129     int         m_mapMode;
 130     double      m_xUserScale;
 131     double      m_yUserScale;
 132     int         m_xLogicalOrigin;
 133     int         m_yLogicalOrigin;
 134     bool        m_xAxisReversed,
 135                 m_yAxisReversed;
 136     wxColour    m_colourForeground,    // these are _text_ colours
 137                 m_colourBackground;
 138     wxBrush     m_backgroundBrush;
 139     MyCanvas   *m_canvas;
 140
 141 private:
 142     // any class wishing to process wxWidgets events must use this macro
 143     DECLARE_EVENT_TABLE()
 144 };
 145
 146 // define a scrollable canvas for drawing onto
 147 class MyCanvas: public wxScrolledWindow
 148 {
 149 public:
 150     MyCanvas( MyFrame *parent );
 151
 152     void OnPaint(wxPaintEvent &event);
 153     void OnMouseMove(wxMouseEvent &event);
 154
 155     void ToShow(ScreenToShow show) { m_show = show; Refresh(); }
 156
 157     // set or remove the clipping region
 158     void Clip(bool clip) { m_clip = clip; Refresh(); }
 159
 160 protected:
 161     void DrawTestLines( int x, int y, int width, wxDC &dc );
 162     void DrawTestPoly(wxDC& dc);
 163     void DrawTestBrushes(wxDC& dc);
 164     void DrawText(wxDC& dc);
 165     void DrawImages(wxDC& dc);
 166     void DrawWithLogicalOps(wxDC& dc);
 167     void DrawRegions(wxDC& dc);
 168     void DrawCircles(wxDC& dc);
 169     void DrawDefault(wxDC& dc);
 170
 171     void DrawRegionsHelper(wxDC& dc, wxCoord x, bool firstTime);
 172
 173 private:
 174     MyFrame *m_owner;
 175
 176     ScreenToShow m_show;
 177     wxBitmap     m_smile_bmp;
 178     wxIcon       m_std_icon;
 179     bool         m_clip;
 180
 181     DECLARE_EVENT_TABLE()
 182 };
 183
 184 // ----------------------------------------------------------------------------
 185 // constants
 186 // ----------------------------------------------------------------------------
 187
 188 // IDs for the controls and the menu commands
 189 enum
 190 {
 191     // menu items
 192     File_Quit = 1,
 193     File_About,
 194
 195     MenuShow_First,
 196     File_ShowDefault = MenuShow_First,
 197     File_ShowText,
 198     File_ShowLines,
 199     File_ShowBrushes,
 200     File_ShowPolygons,
 201     File_ShowMask,
 202     File_ShowOps,
 203     File_ShowRegions,
 204     File_ShowCircles,
 205     MenuShow_Last = File_ShowCircles,
 206
 207     File_Clip,
 208
 209     MenuOption_First,
 210
 211     MapMode_Text = MenuOption_First,
 212     MapMode_Lometric,
 213     MapMode_Twips,
 214     MapMode_Points,
 215     MapMode_Metric,
 216
 217     UserScale_StretchHoriz,
 218     UserScale_ShrinkHoriz,
 219     UserScale_StretchVertic,
 220     UserScale_ShrinkVertic,
 221     UserScale_Restore,
 222
 223     AxisMirror_Horiz,
 224     AxisMirror_Vertic,
 225
 226     LogicalOrigin_MoveDown,
 227     LogicalOrigin_MoveUp,
 228     LogicalOrigin_MoveLeft,
 229     LogicalOrigin_MoveRight,
 230     LogicalOrigin_Set,
 231     LogicalOrigin_Restore,
 232
 233 #if wxUSE_COLOURDLG
 234     Colour_TextForeground,
 235     Colour_TextBackground,
 236     Colour_Background,
 237 #endif // wxUSE_COLOURDLG
 238     Colour_BackgroundMode,
 239     Colour_TextureBackgound,
 240
 241     MenuOption_Last = Colour_TextureBackgound
 242 };
 243
 244 // ----------------------------------------------------------------------------
 245 // event tables and other macros for wxWidgets
 246 // ----------------------------------------------------------------------------
 247
 248
 249 // Create a new application object: this macro will allow wxWidgets to create
 250 // the application object during program execution (it's better than using a
 251 // static object for many reasons) and also declares the accessor function
 252 // wxGetApp() which will return the reference of the right type (i.e. MyApp and
 253 // not wxApp)
 254 IMPLEMENT_APP(MyApp)
 255
 256 // ============================================================================
 257 // implementation
 258 // ============================================================================
 259
 260 // ----------------------------------------------------------------------------
 261 // the application class
 262 // ----------------------------------------------------------------------------
 263
 264 bool MyApp::LoadImages()
 265 {
 266     gs_bmpNoMask = new wxBitmap;
 267     gs_bmpWithColMask = new wxBitmap;
 268     gs_bmpMask = new wxBitmap;
 269     gs_bmpWithMask = new wxBitmap;
 270     gs_bmp4 = new wxBitmap;
 271     gs_bmp4_mono = new wxBitmap;
 272     gs_bmp36 = new wxBitmap;
 273
 274     wxPathList pathList;
 275     pathList.Add(_T("."));
 276     pathList.Add(_T(".."));
 277
 278     wxString path = pathList.FindValidPath(_T("pat4.bmp"));
 279     if ( !path )
 280         return false;
 281
 282     /* 4 colour bitmap */
 283     gs_bmp4->LoadFile(path, wxBITMAP_TYPE_BMP);
 284     /* turn into mono-bitmap */
 285     gs_bmp4_mono->LoadFile(path, wxBITMAP_TYPE_BMP);
 286     wxMask* mask4 = new wxMask(*gs_bmp4_mono, *wxBLACK);
 287     gs_bmp4_mono->SetMask(mask4);
 288
 289     path = pathList.FindValidPath(_T("pat36.bmp"));
 290     if ( !path )
 291         return false;
 292     gs_bmp36->LoadFile(path, wxBITMAP_TYPE_BMP);
 293     wxMask* mask36 = new wxMask(*gs_bmp36, *wxBLACK);
 294     gs_bmp36->SetMask(mask36);
 295
 296     path = pathList.FindValidPath(_T("image.bmp"));
 297     if ( !path )
 298         return false;
 299     gs_bmpNoMask->LoadFile(path, wxBITMAP_TYPE_BMP);
 300     gs_bmpWithMask->LoadFile(path, wxBITMAP_TYPE_BMP);
 301     gs_bmpWithColMask->LoadFile(path, wxBITMAP_TYPE_BMP);
 302
 303     path = pathList.FindValidPath(_T("mask.bmp"));
 304     if ( !path )
 305         return false;
 306     gs_bmpMask->LoadFile(path, wxBITMAP_TYPE_BMP);
 307
 308     wxMask *mask = new wxMask(*gs_bmpMask, *wxBLACK);
 309     gs_bmpWithMask->SetMask(mask);
 310
 311     mask = new wxMask(*gs_bmpWithColMask, *wxWHITE);
 312     gs_bmpWithColMask->SetMask(mask);
 313
 314     return true;
 315 }
 316
 317 // `Main program' equivalent: the program execution "starts" here
 318 bool MyApp::OnInit()
 319 {
 320     // Create the main application window
 321     MyFrame *frame = new MyFrame(_T("Drawing sample"),
 322                                  wxPoint(50, 50), wxSize(550, 340));
 323
 324     // Show it and tell the application that it's our main window
 325     frame->Show(true);
 326     SetTopWindow(frame);
 327
 328     if ( !LoadImages() )
 329     {
 330         wxLogError(wxT("Can't load one of the bitmap files needed ")
 331                    wxT("for this sample from the current or parent ")
 332                    wxT("directory, please copy them there."));
 333
 334         // stop here
 335         DeleteBitmaps();
 336
 337         return false;
 338     }
 339
 340     // ok, continue
 341     return true;
 342 }
 343
 344 void MyApp::DeleteBitmaps()
 345 {
 346     delete gs_bmpNoMask;
 347     delete gs_bmpWithColMask;
 348     delete gs_bmpMask;
 349     delete gs_bmpWithMask;
 350     delete gs_bmp4;
 351     delete gs_bmp4_mono;
 352     delete gs_bmp36;
 353
 354     gs_bmpNoMask = NULL;
 355     gs_bmpWithColMask = NULL;
 356     gs_bmpMask = NULL;
 357     gs_bmpWithMask = NULL;
 358     gs_bmp4 = NULL;
 359     gs_bmp4_mono = NULL;
 360     gs_bmp36 = NULL;
 361 }
 362
 363 // ----------------------------------------------------------------------------
 364 // MyCanvas
 365 // ----------------------------------------------------------------------------
 366
 367 // the event tables connect the wxWidgets events with the functions (event
 368 // handlers) which process them.
 369 BEGIN_EVENT_TABLE(MyCanvas, wxScrolledWindow)
 370     EVT_PAINT  (MyCanvas::OnPaint)
 371     EVT_MOTION (MyCanvas::OnMouseMove)
 372 END_EVENT_TABLE()
 373
 374 #include "smile.xpm"
 375
 376 MyCanvas::MyCanvas(MyFrame *parent)
 377         : wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
 378                            wxHSCROLL | wxVSCROLL | wxNO_FULL_REPAINT_ON_RESIZE)
 379 {
 380     m_owner = parent;
 381     m_show = Show_Default;
 382     m_smile_bmp = wxBitmap(smile_xpm);
 383     m_std_icon = wxArtProvider::GetIcon(wxART_INFORMATION);
 384     m_clip = false;
 385 }
 386
 387 void MyCanvas::DrawTestBrushes(wxDC& dc)
 388 {
 389     static const wxCoord WIDTH = 200;
 390     static const wxCoord HEIGHT = 80;
 391
 392     wxCoord x = 10,
 393             y = 10;
 394
 395     dc.SetBrush(wxBrush(*wxGREEN, wxSOLID));
 396     dc.DrawRectangle(x, y, WIDTH, HEIGHT);
 397     dc.DrawText(_T("Solid green"), x + 10, y + 10);
 398
 399     y += HEIGHT;
 400     dc.SetBrush(wxBrush(*wxRED, wxCROSSDIAG_HATCH));
 401     dc.DrawRectangle(x, y, WIDTH, HEIGHT);
 402     dc.DrawText(_T("Hatched red"), x + 10, y + 10);
 403
 404     y += HEIGHT;
 405     dc.SetBrush(wxBrush(*gs_bmpMask));
 406     dc.DrawRectangle(x, y, WIDTH, HEIGHT);
 407     dc.DrawText(_T("Stipple mono"), x + 10, y + 10);
 408
 409     y += HEIGHT;
 410     dc.SetBrush(wxBrush(*gs_bmpNoMask));
 411     dc.DrawRectangle(x, y, WIDTH, HEIGHT);
 412     dc.DrawText(_T("Stipple colour"), x + 10, y + 10);
 413 }
 414
 415 void MyCanvas::DrawTestPoly(wxDC& dc)
 416 {
 417     wxBrush brushHatch(*wxRED, wxFDIAGONAL_HATCH);
 418     dc.SetBrush(brushHatch);
 419
 420     wxPoint star[5];
 421     star[0] = wxPoint(100, 60);
 422     star[1] = wxPoint(60, 150);
 423     star[2] = wxPoint(160, 100);
 424     star[3] = wxPoint(40, 100);
 425     star[4] = wxPoint(140, 150);
 426
 427     dc.DrawText(_T("You should see two (irregular) stars below, the left one ")
 428                 _T("hatched"), 10, 10);
 429     dc.DrawText(_T("except for the central region and the right ")
 430                 _T("one entirely hatched"), 10, 30);
 431     dc.DrawText(_T("The third star only has a hatched outline"), 10, 50);
 432
 433     dc.DrawPolygon(WXSIZEOF(star), star, 0, 30);
 434     dc.DrawPolygon(WXSIZEOF(star), star, 160, 30, wxWINDING_RULE);
 435
 436     wxPoint star2[10];
 437     star2[0] = wxPoint(0, 100);
 438     star2[1] = wxPoint(-59, -81);
 439     star2[2] = wxPoint(95, 31);
 440     star2[3] = wxPoint(-95, 31);
 441     star2[4] = wxPoint(59, -81);
 442     star2[5] = wxPoint(0, 80);
 443     star2[6] = wxPoint(-47, -64);
 444     star2[7] = wxPoint(76, 24);
 445     star2[8] = wxPoint(-76, 24);
 446     star2[9] = wxPoint(47, -64);
 447     int count[2] = {5, 5};
 448
 449     dc.DrawPolyPolygon(WXSIZEOF(count), count, star2, 450, 150);
 450 }
 451
 452 void MyCanvas::DrawTestLines( int x, int y, int width, wxDC &dc )
 453 {
 454     dc.SetPen( wxPen( wxT("black"), width, wxSOLID) );
 455     dc.SetBrush( *wxRED_BRUSH );
 456     dc.DrawText(wxString::Format(wxT("Testing lines of width %d"), width), x + 10, y - 10);
 457     dc.DrawRectangle( x+10, y+10, 100, 190 );
 458
 459     dc.DrawText(_T("Solid/dot/short dash/long dash/dot dash"), x + 150, y + 10);
 460     dc.SetPen( wxPen( wxT("black"), width, wxSOLID) );
 461     dc.DrawLine( x+20, y+20, 100, y+20 );
 462     dc.SetPen( wxPen( wxT("black"), width, wxDOT) );
 463     dc.DrawLine( x+20, y+30, 100, y+30 );
 464     dc.SetPen( wxPen( wxT("black"), width, wxSHORT_DASH) );
 465     dc.DrawLine( x+20, y+40, 100, y+40 );
 466     dc.SetPen( wxPen( wxT("black"), width, wxLONG_DASH) );
 467     dc.DrawLine( x+20, y+50, 100, y+50 );
 468     dc.SetPen( wxPen( wxT("black"), width, wxDOT_DASH) );
 469     dc.DrawLine( x+20, y+60, 100, y+60 );
 470
 471     dc.DrawText(_T("Misc hatches"), x + 150, y + 70);
 472     dc.SetPen( wxPen( wxT("black"), width, wxBDIAGONAL_HATCH) );
 473     dc.DrawLine( x+20, y+70, 100, y+70 );
 474     dc.SetPen( wxPen( wxT("black"), width, wxCROSSDIAG_HATCH) );
 475     dc.DrawLine( x+20, y+80, 100, y+80 );
 476     dc.SetPen( wxPen( wxT("black"), width, wxFDIAGONAL_HATCH) );
 477     dc.DrawLine( x+20, y+90, 100, y+90 );
 478     dc.SetPen( wxPen( wxT("black"), width, wxCROSS_HATCH) );
 479     dc.DrawLine( x+20, y+100, 100, y+100 );
 480     dc.SetPen( wxPen( wxT("black"), width, wxHORIZONTAL_HATCH) );
 481     dc.DrawLine( x+20, y+110, 100, y+110 );
 482     dc.SetPen( wxPen( wxT("black"), width, wxVERTICAL_HATCH) );
 483     dc.DrawLine( x+20, y+120, 100, y+120 );
 484
 485     dc.DrawText(_T("User dash"), x + 150, y + 140);
 486     wxPen ud( wxT("black"), width, wxUSER_DASH );
 487     wxDash dash1[6];
 488     dash1[0] = 8;  // Long dash  <---------+
 489     dash1[1] = 2;  // Short gap            |
 490     dash1[2] = 3;  // Short dash           |
 491     dash1[3] = 2;  // Short gap            |
 492     dash1[4] = 3;  // Short dash           |
 493     dash1[5] = 2;  // Short gap and repeat +
 494     ud.SetDashes( 6, dash1 );
 495     dc.SetPen( ud );
 496     dc.DrawLine( x+20, y+140, 100, y+140 );
 497     dash1[0] = 5;  // Make first dash shorter
 498     ud.SetDashes( 6, dash1 );
 499     dc.SetPen( ud );
 500     dc.DrawLine( x+20, y+150, 100, y+150 );
 501     dash1[2] = 5;  // Make second dash longer
 502     ud.SetDashes( 6, dash1 );
 503     dc.SetPen( ud );
 504     dc.DrawLine( x+20, y+160, 100, y+160 );
 505     dash1[4] = 5;  // Make third dash longer
 506     ud.SetDashes( 6, dash1 );
 507     dc.SetPen( ud );
 508     dc.DrawLine( x+20, y+170, 100, y+170 );
 509 }
 510
 511 void MyCanvas::DrawDefault(wxDC& dc)
 512 {
 513     // mark the origin
 514     dc.DrawCircle(0, 0, 10);
 515
 516 #if !wxMAC_USE_CORE_GRAPHICS
 517     // GetPixel and FloodFill not supported by Mac OS X CoreGraphics
 518     // (FloodFill uses Blit from a non-wxMemoryDC)
 519     //flood fill using brush, starting at 1,1 and replacing whatever colour we find there
 520     dc.SetBrush(wxBrush(wxColour(128,128,0), wxSOLID));
 521
 522     wxColour tmpColour ;
 523     dc.GetPixel(1,1, &tmpColour);
 524     dc.FloodFill(1,1, tmpColour, wxFLOOD_SURFACE);
 525 #endif
 526
 527     dc.DrawCheckMark(5, 80, 15, 15);
 528     dc.DrawCheckMark(25, 80, 30, 30);
 529     dc.DrawCheckMark(60, 80, 60, 60);
 530
 531     // this is the test for "blitting bitmap into DC damages selected brush" bug
 532     wxCoord rectSize = m_std_icon.GetWidth() + 10;
 533     wxCoord x = 100;
 534     dc.SetPen(*wxTRANSPARENT_PEN);
 535     dc.SetBrush( *wxGREEN_BRUSH );
 536     dc.DrawRectangle(x, 10, rectSize, rectSize);
 537     dc.DrawBitmap(m_std_icon, x + 5, 15, true);
 538     x += rectSize + 10;
 539     dc.DrawRectangle(x, 10, rectSize, rectSize);
 540     dc.DrawIcon(m_std_icon, x + 5, 15);
 541     x += rectSize + 10;
 542     dc.DrawRectangle(x, 10, rectSize, rectSize);
 543
 544     // test for "transparent" bitmap drawing (it intersects with the last
 545     // rectangle above)
 546     //dc.SetBrush( *wxTRANSPARENT_BRUSH );
 547
 548     if (m_smile_bmp.Ok())
 549         dc.DrawBitmap(m_smile_bmp, x + rectSize - 20, rectSize - 10, true);
 550
 551     dc.SetBrush( *wxBLACK_BRUSH );
 552     dc.DrawRectangle( 0, 160, 1000, 300 );
 553
 554     // draw lines
 555     wxBitmap bitmap(20,70);
 556     wxMemoryDC memdc;
 557     memdc.SelectObject( bitmap );
 558     memdc.SetBrush( *wxBLACK_BRUSH );
 559     memdc.SetPen( *wxWHITE_PEN );
 560     memdc.DrawRectangle(0,0,20,70);
 561     memdc.DrawLine( 10,0,10,70 );
 562
 563     // to the right
 564     wxPen pen = *wxRED_PEN;
 565     memdc.SetPen(pen);
 566     memdc.DrawLine( 10, 5,10, 5 );
 567     memdc.DrawLine( 10,10,11,10 );
 568     memdc.DrawLine( 10,15,12,15 );
 569     memdc.DrawLine( 10,20,13,20 );
 570
 571 /*
 572     memdc.SetPen(*wxRED_PEN);
 573     memdc.DrawLine( 12, 5,12, 5 );
 574     memdc.DrawLine( 12,10,13,10 );
 575     memdc.DrawLine( 12,15,14,15 );
 576     memdc.DrawLine( 12,20,15,20 );
 577 */
 578
 579     // same to the left
 580     memdc.DrawLine( 10,25,10,25 );
 581     memdc.DrawLine( 10,30, 9,30 );
 582     memdc.DrawLine( 10,35, 8,35 );
 583     memdc.DrawLine( 10,40, 7,40 );
 584
 585     // XOR draw lines
 586     dc.SetPen(*wxWHITE_PEN);
 587     memdc.SetLogicalFunction( wxINVERT );
 588     memdc.SetPen( *wxWHITE_PEN );
 589     memdc.DrawLine( 10,50,10,50 );
 590     memdc.DrawLine( 10,55,11,55 );
 591     memdc.DrawLine( 10,60,12,60 );
 592     memdc.DrawLine( 10,65,13,65 );
 593
 594     memdc.DrawLine( 12,50,12,50 );
 595     memdc.DrawLine( 12,55,13,55 );
 596     memdc.DrawLine( 12,60,14,60 );
 597     memdc.DrawLine( 12,65,15,65 );
 598
 599     memdc.SelectObject( wxNullBitmap );
 600     dc.DrawBitmap( bitmap, 10, 170 );
 601     wxImage image = bitmap.ConvertToImage();
 602     image.Rescale( 60,210 );
 603     bitmap = wxBitmap(image);
 604     dc.DrawBitmap( bitmap, 50, 170 );
 605
 606     // test the rectangle outline drawing - there should be one pixel between
 607     // the rect and the lines
 608     dc.SetPen(*wxWHITE_PEN);
 609     dc.SetBrush( *wxTRANSPARENT_BRUSH );
 610     dc.DrawRectangle(150, 170, 49, 29);
 611     dc.DrawRectangle(200, 170, 49, 29);
 612     dc.SetPen(*wxWHITE_PEN);
 613     dc.DrawLine(250, 210, 250, 170);
 614     dc.DrawLine(260, 200, 150, 200);
 615
 616     // test the rectangle filled drawing - there should be one pixel between
 617     // the rect and the lines
 618     dc.SetPen(*wxTRANSPARENT_PEN);
 619     dc.SetBrush( *wxWHITE_BRUSH );
 620     dc.DrawRectangle(300, 170, 49, 29);
 621     dc.DrawRectangle(350, 170, 49, 29);
 622     dc.SetPen(*wxWHITE_PEN);
 623     dc.DrawLine(400, 170, 400, 210);
 624     dc.DrawLine(300, 200, 410, 200);
 625
 626     // a few more tests of this kind
 627     dc.SetPen(*wxRED_PEN);
 628     dc.SetBrush( *wxWHITE_BRUSH );
 629     dc.DrawRectangle(300, 220, 1, 1);
 630     dc.DrawRectangle(310, 220, 2, 2);
 631     dc.DrawRectangle(320, 220, 3, 3);
 632     dc.DrawRectangle(330, 220, 4, 4);
 633
 634     dc.SetPen(*wxTRANSPARENT_PEN);
 635     dc.SetBrush( *wxWHITE_BRUSH );
 636     dc.DrawRectangle(300, 230, 1, 1);
 637     dc.DrawRectangle(310, 230, 2, 2);
 638     dc.DrawRectangle(320, 230, 3, 3);
 639     dc.DrawRectangle(330, 230, 4, 4);
 640
 641     // and now for filled rect with outline
 642     dc.SetPen(*wxRED_PEN);
 643     dc.SetBrush( *wxWHITE_BRUSH );
 644     dc.DrawRectangle(500, 170, 49, 29);
 645     dc.DrawRectangle(550, 170, 49, 29);
 646     dc.SetPen(*wxWHITE_PEN);
 647     dc.DrawLine(600, 170, 600, 210);
 648     dc.DrawLine(500, 200, 610, 200);
 649
 650     // test the rectangle outline drawing - there should be one pixel between
 651     // the rect and the lines
 652     dc.SetPen(*wxWHITE_PEN);
 653     dc.SetBrush( *wxTRANSPARENT_BRUSH );
 654     dc.DrawRoundedRectangle(150, 270, 49, 29, 6);
 655     dc.DrawRoundedRectangle(200, 270, 49, 29, 6);
 656     dc.SetPen(*wxWHITE_PEN);
 657     dc.DrawLine(250, 270, 250, 310);
 658     dc.DrawLine(150, 300, 260, 300);
 659
 660     // test the rectangle filled drawing - there should be one pixel between
 661     // the rect and the lines
 662     dc.SetPen(*wxTRANSPARENT_PEN);
 663     dc.SetBrush( *wxWHITE_BRUSH );
 664     dc.DrawRoundedRectangle(300, 270, 49, 29, 6);
 665     dc.DrawRoundedRectangle(350, 270, 49, 29, 6);
 666     dc.SetPen(*wxWHITE_PEN);
 667     dc.DrawLine(400, 270, 400, 310);
 668     dc.DrawLine(300, 300, 410, 300);
 669
 670     // Added by JACS to demonstrate bizarre behaviour.
 671     // With a size of 70, we get a missing red RHS,
 672     // and the hight is too small, so we get yellow
 673     // showing. With a size of 40, it draws as expected:
 674     // it just shows a white rectangle with red outline.
 675     int totalWidth = 70;
 676     int totalHeight = 70;
 677     wxBitmap bitmap2(totalWidth, totalHeight);
 678
 679     wxMemoryDC memdc2;
 680     memdc2.SelectObject(bitmap2);
 681
 682     wxColour clr(255, 255, 0);
 683     wxBrush yellowBrush(clr, wxSOLID);
 684     memdc2.SetBackground(yellowBrush);
 685     memdc2.Clear();
 686
 687     wxPen yellowPen(clr, 1, wxSOLID);
 688
 689     // Now draw a white rectangle with red outline. It should
 690     // entirely eclipse the yellow background.
 691     memdc2.SetPen(*wxRED_PEN);
 692     memdc2.SetBrush(*wxWHITE_BRUSH);
 693
 694     memdc2.DrawRectangle(0, 0, totalWidth, totalHeight);
 695
 696     memdc2.SetPen(wxNullPen);
 697     memdc2.SetBrush(wxNullBrush);
 698     memdc2.SelectObject(wxNullBitmap);
 699
 700     dc.DrawBitmap(bitmap2, 500, 270);
 701
 702     // Repeat, but draw directly on dc
 703     // Draw a yellow rectangle filling the bitmap
 704
 705     x = 600; int y = 270;
 706     dc.SetPen(yellowPen);
 707     dc.SetBrush(yellowBrush);
 708     dc.DrawRectangle(x, y, totalWidth, totalHeight);
 709
 710     // Now draw a white rectangle with red outline. It should
 711     // entirely eclipse the yellow background.
 712     dc.SetPen(*wxRED_PEN);
 713     dc.SetBrush(*wxWHITE_BRUSH);
 714
 715     dc.DrawRectangle(x, y, totalWidth, totalHeight);
 716 }
 717
 718 void MyCanvas::DrawText(wxDC& dc)
 719 {
 720     // set underlined font for testing
 721     dc.SetFont( wxFont(12, wxMODERN, wxNORMAL, wxNORMAL, true) );
 722     dc.DrawText( _T("This is text"), 110, 10 );
 723     dc.DrawRotatedText( _T("That is text"), 20, 10, -45 );
 724
 725     // use wxSWISS_FONT and not wxNORMAL_FONT as the latter can't be rotated
 726     // under Win9x (it is not TrueType)
 727     dc.SetFont( *wxSWISS_FONT );
 728
 729     wxString text;
 730     dc.SetBackgroundMode(wxTRANSPARENT);
 731
 732     for ( int n = -180; n < 180; n += 30 )
 733     {
 734         text.Printf(wxT("     %d rotated text"), n);
 735         dc.DrawRotatedText(text , 400, 400, n);
 736     }
 737
 738     dc.SetFont( wxFont( 18, wxSWISS, wxNORMAL, wxNORMAL ) );
 739
 740     dc.DrawText( _T("This is Swiss 18pt text."), 110, 40 );
 741
 742     long length;
 743     long height;
 744     long descent;
 745     dc.GetTextExtent( _T("This is Swiss 18pt text."), &length, &height, &descent );
 746     text.Printf( wxT("Dimensions are length %ld, height %ld, descent %ld"), length, height, descent );
 747     dc.DrawText( text, 110, 80 );
 748
 749     text.Printf( wxT("CharHeight() returns: %d"), dc.GetCharHeight() );
 750     dc.DrawText( text, 110, 120 );
 751
 752     dc.DrawRectangle( 100, 40, 4, height );
 753
 754     // test the logical function effect
 755     wxCoord y = 150;
 756     dc.SetLogicalFunction(wxINVERT);
 757     dc.DrawText( _T("There should be no text below"), 110, 150 );
 758     dc.DrawRectangle( 110, y, 100, height );
 759
 760     // twice drawn inverted should result in invisible
 761     y += height;
 762     dc.DrawText( _T("Invisible text"), 110, y );
 763     dc.DrawRectangle( 110, y, 100, height );
 764     dc.DrawText( _T("Invisible text"), 110, y );
 765     dc.DrawRectangle( 110, y, 100, height );
 766     dc.SetLogicalFunction(wxCOPY);
 767
 768     y += height;
 769     dc.DrawRectangle( 110, y, 100, height );
 770     dc.DrawText( _T("Visible text"), 110, y );
 771 }
 772
 773 static const struct
 774 {
 775     const wxChar *name;
 776     int           rop;
 777 } rasterOperations[] =
 778 {
 779     { wxT("wxAND"),          wxAND           },
 780     { wxT("wxAND_INVERT"),   wxAND_INVERT    },
 781     { wxT("wxAND_REVERSE"),  wxAND_REVERSE   },
 782     { wxT("wxCLEAR"),        wxCLEAR         },
 783     { wxT("wxCOPY"),         wxCOPY          },
 784     { wxT("wxEQUIV"),        wxEQUIV         },
 785     { wxT("wxINVERT"),       wxINVERT        },
 786     { wxT("wxNAND"),         wxNAND          },
 787     { wxT("wxNO_OP"),        wxNO_OP         },
 788     { wxT("wxOR"),           wxOR            },
 789     { wxT("wxOR_INVERT"),    wxOR_INVERT     },
 790     { wxT("wxOR_REVERSE"),   wxOR_REVERSE    },
 791     { wxT("wxSET"),          wxSET           },
 792     { wxT("wxSRC_INVERT"),   wxSRC_INVERT    },
 793     { wxT("wxXOR"),          wxXOR           },
 794 };
 795
 796 void MyCanvas::DrawImages(wxDC& dc)
 797 {
 798     dc.DrawText(_T("original image"), 0, 0);
 799     dc.DrawBitmap(*gs_bmpNoMask, 0, 20, 0);
 800     dc.DrawText(_T("with colour mask"), 0, 100);
 801     dc.DrawBitmap(*gs_bmpWithColMask, 0, 120, true);
 802     dc.DrawText(_T("the mask image"), 0, 200);
 803     dc.DrawBitmap(*gs_bmpMask, 0, 220, 0);
 804     dc.DrawText(_T("masked image"), 0, 300);
 805     dc.DrawBitmap(*gs_bmpWithMask, 0, 320, true);
 806
 807     int cx = gs_bmpWithColMask->GetWidth(),
 808         cy = gs_bmpWithColMask->GetHeight();
 809
 810     wxMemoryDC memDC;
 811     for ( size_t n = 0; n < WXSIZEOF(rasterOperations); n++ )
 812     {
 813         wxCoord x = 120 + 150*(n%4),
 814                 y =  20 + 100*(n/4);
 815
 816         dc.DrawText(rasterOperations[n].name, x, y - 20);
 817         memDC.SelectObject(*gs_bmpWithColMask);
 818         dc.Blit(x, y, cx, cy, &memDC, 0, 0, rasterOperations[n].rop, true);
 819     }
 820 }
 821
 822 void MyCanvas::DrawWithLogicalOps(wxDC& dc)
 823 {
 824     static const wxCoord w = 60;
 825     static const wxCoord h = 60;
 826
 827     // reuse the text colour here
 828     dc.SetPen(wxPen(m_owner->m_colourForeground, 1, wxSOLID));
 829     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 830
 831     size_t n;
 832     for ( n = 0; n < WXSIZEOF(rasterOperations); n++ )
 833     {
 834         wxCoord x = 20 + 150*(n%4),
 835                 y = 20 + 100*(n/4);
 836
 837         dc.DrawText(rasterOperations[n].name, x, y - 20);
 838         dc.SetLogicalFunction(rasterOperations[n].rop);
 839         dc.DrawRectangle(x, y, w, h);
 840         dc.DrawLine(x, y, x + w, y + h);
 841         dc.DrawLine(x + w, y, x, y + h);
 842     }
 843
 844     // now some filled rectangles
 845     dc.SetBrush(wxBrush(m_owner->m_colourForeground, wxSOLID));
 846
 847     for ( n = 0; n < WXSIZEOF(rasterOperations); n++ )
 848     {
 849         wxCoord x = 20 + 150*(n%4),
 850                 y = 500 + 100*(n/4);
 851
 852         dc.DrawText(rasterOperations[n].name, x, y - 20);
 853         dc.SetLogicalFunction(rasterOperations[n].rop);
 854         dc.DrawRectangle(x, y, w, h);
 855     }
 856 }
 857
 858 void MyCanvas::DrawCircles(wxDC& dc)
 859 {
 860     int x = 100,
 861         y = 100,
 862         r = 20;
 863
 864     dc.DrawText(_T("Some circles"), 0, y);
 865     dc.DrawCircle(x, y, r);
 866     dc.DrawCircle(x + 2*r, y, r);
 867     dc.DrawCircle(x + 4*r, y, r);
 868
 869     y += 2*r;
 870     dc.DrawText(_T("And ellipses"), 0, y);
 871     dc.DrawEllipse(x - r, y, 2*r, r);
 872     dc.DrawEllipse(x + r, y, 2*r, r);
 873     dc.DrawEllipse(x + 3*r, y, 2*r, r);
 874
 875     y += 2*r;
 876     dc.DrawText(_T("And arcs"), 0, y);
 877     dc.DrawArc(x - r, y, x + r, y, x, y);
 878     dc.DrawArc(x + 4*r, y, x + 2*r, y, x + 3*r, y);
 879     dc.DrawArc(x + 5*r, y, x + 5*r, y, x + 6*r, y);
 880
 881     y += 2*r;
 882     dc.DrawEllipticArc(x - r, y, 2*r, r, 0, 90);
 883     dc.DrawEllipticArc(x + r, y, 2*r, r, 90, 180);
 884     dc.DrawEllipticArc(x + 3*r, y, 2*r, r, 180, 270);
 885     dc.DrawEllipticArc(x + 5*r, y, 2*r, r, 270, 360);
 886 }
 887
 888 void MyCanvas::DrawRegions(wxDC& dc)
 889 {
 890     dc.DrawText(_T("You should see a red rect partly covered by a cyan one ")
 891                 _T("on the left"), 10, 5);
 892     dc.DrawText(_T("and 5 smileys from which 4 are partially clipped on the right"),
 893                 10, 5 + dc.GetCharHeight());
 894     dc.DrawText(_T("The second copy should be identical but right part of it ")
 895                 _T("should be offset by 10 pixels."),
 896                 10, 5 + 2*dc.GetCharHeight());
 897
 898     DrawRegionsHelper(dc, 10, true);
 899     DrawRegionsHelper(dc, 350, false);
 900 }
 901
 902 void MyCanvas::DrawRegionsHelper(wxDC& dc, wxCoord x, bool firstTime)
 903 {
 904     wxCoord y = 100;
 905
 906     dc.DestroyClippingRegion();
 907     dc.SetBrush( *wxWHITE_BRUSH );
 908     dc.SetPen( *wxTRANSPARENT_PEN );
 909     dc.DrawRectangle( x, y, 310, 310 );
 910
 911     dc.SetClippingRegion( x + 10, y + 10, 100, 270 );
 912
 913     dc.SetBrush( *wxRED_BRUSH );
 914     dc.DrawRectangle( x, y, 310, 310 );
 915
 916     dc.SetClippingRegion( x + 10, y + 10, 100, 100 );
 917
 918     dc.SetBrush( *wxCYAN_BRUSH );
 919     dc.DrawRectangle( x, y, 310, 310 );
 920
 921     dc.DestroyClippingRegion();
 922
 923     wxRegion region(x + 110, y + 20, 100, 270);
 924 #if !defined(__WXMOTIF__) && !defined(__WXMAC__)
 925     if ( !firstTime )
 926         region.Offset(10, 10);
 927 #endif
 928     dc.SetClippingRegion(region);
 929
 930     dc.SetBrush( *wxGREY_BRUSH );
 931     dc.DrawRectangle( x, y, 310, 310 );
 932
 933     if (m_smile_bmp.Ok())
 934     {
 935         dc.DrawBitmap( m_smile_bmp, x + 150, y + 150, true );
 936         dc.DrawBitmap( m_smile_bmp, x + 130, y + 10,  true );
 937         dc.DrawBitmap( m_smile_bmp, x + 130, y + 280, true );
 938         dc.DrawBitmap( m_smile_bmp, x + 100, y + 70,  true );
 939         dc.DrawBitmap( m_smile_bmp, x + 200, y + 70,  true );
 940     }
 941 }
 942
 943 void MyCanvas::OnPaint(wxPaintEvent &WXUNUSED(event))
 944 {
 945     wxPaintDC dc(this);
 946     PrepareDC(dc);
 947
 948     m_owner->PrepareDC(dc);
 949
 950     dc.SetBackgroundMode( m_owner->m_backgroundMode );
 951     if ( m_owner->m_backgroundBrush.Ok() )
 952         dc.SetBackground( m_owner->m_backgroundBrush );
 953     if ( m_owner->m_colourForeground.Ok() )
 954         dc.SetTextForeground( m_owner->m_colourForeground );
 955     if ( m_owner->m_colourBackground.Ok() )
 956         dc.SetTextBackground( m_owner->m_colourBackground );
 957
 958     if ( m_owner->m_textureBackground) {
 959         if ( ! m_owner->m_backgroundBrush.Ok() ) {
 960             wxColour clr(0,128,0);
 961             wxBrush b(clr, wxSOLID);
 962             dc.SetBackground(b);
 963         }
 964     }
 965
 966     if ( m_clip )
 967         dc.SetClippingRegion(100, 100, 100, 100);
 968
 969     dc.Clear();
 970
 971     if ( m_owner->m_textureBackground )
 972     {
 973         dc.SetPen(*wxMEDIUM_GREY_PEN);
 974         for ( int i = 0; i < 200; i++ )
 975             dc.DrawLine(0, i*10, i*10, 0);
 976     }
 977
 978     switch ( m_show )
 979     {
 980         case Show_Default:
 981             DrawDefault(dc);
 982             break;
 983
 984         case Show_Circles:
 985             DrawCircles(dc);
 986             break;
 987
 988         case Show_Regions:
 989             DrawRegions(dc);
 990             break;
 991
 992         case Show_Text:
 993             DrawText(dc);
 994             break;
 995
 996         case Show_Lines:
 997             DrawTestLines( 0, 100, 0, dc );
 998             DrawTestLines( 0, 320, 1, dc );
 999             DrawTestLines( 0, 540, 2, dc );
1000             DrawTestLines( 0, 760, 6, dc );
1001             break;
1002
1003         case Show_Brushes:
1004             DrawTestBrushes(dc);
1005             break;
1006
1007         case Show_Polygons:
1008             DrawTestPoly(dc);
1009             break;
1010
1011         case Show_Mask:
1012             DrawImages(dc);
1013             break;
1014
1015         case Show_Ops:
1016             DrawWithLogicalOps(dc);
1017             break;
1018     }
1019 }
1020
1021 void MyCanvas::OnMouseMove(wxMouseEvent &event)
1022 {
1023 #if wxUSE_STATUSBAR
1024     wxClientDC dc(this);
1025     PrepareDC(dc);
1026     m_owner->PrepareDC(dc);
1027
1028     wxPoint pos = event.GetPosition();
1029     long x = dc.DeviceToLogicalX( pos.x );
1030     long y = dc.DeviceToLogicalY( pos.y );
1031     wxString str;
1032     str.Printf( wxT("Current mouse position: %d,%d"), (int)x, (int)y );
1033     m_owner->SetStatusText( str );
1034 #else
1035     wxUnusedVar(event);
1036 #endif // wxUSE_STATUSBAR
1037 }
1038
1039 // ----------------------------------------------------------------------------
1040 // MyFrame
1041 // ----------------------------------------------------------------------------
1042
1043 // the event tables connect the wxWidgets events with the functions (event
1044 // handlers) which process them. It can be also done at run-time, but for the
1045 // simple menu events like this the static method is much simpler.
1046 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
1047     EVT_MENU      (File_Quit,     MyFrame::OnQuit)
1048     EVT_MENU      (File_About,    MyFrame::OnAbout)
1049     EVT_MENU      (File_Clip,     MyFrame::OnClip)
1050
1051     EVT_MENU_RANGE(MenuShow_First,   MenuShow_Last,   MyFrame::OnShow)
1052
1053     EVT_MENU_RANGE(MenuOption_First, MenuOption_Last, MyFrame::OnOption)
1054 END_EVENT_TABLE()
1055
1056 // frame constructor
1057 MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
1058        : wxFrame((wxFrame *)NULL, wxID_ANY, title, pos, size,
1059                  wxDEFAULT_FRAME_STYLE | wxNO_FULL_REPAINT_ON_RESIZE)
1060 {
1061     // set the frame icon
1062     SetIcon(wxICON(mondrian));
1063
1064     wxMenu *menuFile = new wxMenu;
1065     menuFile->Append(File_ShowDefault, _T("&Default screen\tF1"));
1066     menuFile->Append(File_ShowText, _T("&Text screen\tF2"));
1067     menuFile->Append(File_ShowLines, _T("&Lines screen\tF3"));
1068     menuFile->Append(File_ShowBrushes, _T("&Brushes screen\tF4"));
1069     menuFile->Append(File_ShowPolygons, _T("&Polygons screen\tF5"));
1070     menuFile->Append(File_ShowMask, _T("&Mask screen\tF6"));
1071     menuFile->Append(File_ShowOps, _T("&ROP screen\tF7"));
1072     menuFile->Append(File_ShowRegions, _T("Re&gions screen\tF8"));
1073     menuFile->Append(File_ShowCircles, _T("&Circles screen\tF9"));
1074     menuFile->AppendSeparator();
1075     menuFile->AppendCheckItem(File_Clip, _T("&Clip\tCtrl-C"), _T("Clip/unclip drawing"));
1076     menuFile->AppendSeparator();
1077     menuFile->Append(File_About, _T("&About...\tCtrl-A"), _T("Show about dialog"));
1078     menuFile->AppendSeparator();
1079     menuFile->Append(File_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));
1080
1081     wxMenu *menuMapMode = new wxMenu;
1082     menuMapMode->Append( MapMode_Text, _T("&TEXT map mode") );
1083     menuMapMode->Append( MapMode_Lometric, _T("&LOMETRIC map mode") );
1084     menuMapMode->Append( MapMode_Twips, _T("T&WIPS map mode") );
1085     menuMapMode->Append( MapMode_Points, _T("&POINTS map mode") );
1086     menuMapMode->Append( MapMode_Metric, _T("&METRIC map mode") );
1087
1088     wxMenu *menuUserScale = new wxMenu;
1089     menuUserScale->Append( UserScale_StretchHoriz, _T("Stretch &horizontally\tCtrl-H") );
1090     menuUserScale->Append( UserScale_ShrinkHoriz, _T("Shrin&k horizontally\tCtrl-G") );
1091     menuUserScale->Append( UserScale_StretchVertic, _T("Stretch &vertically\tCtrl-V") );
1092     menuUserScale->Append( UserScale_ShrinkVertic, _T("&Shrink vertically\tCtrl-W") );
1093     menuUserScale->AppendSeparator();
1094     menuUserScale->Append( UserScale_Restore, _T("&Restore to normal\tCtrl-0") );
1095
1096     wxMenu *menuAxis = new wxMenu;
1097     menuAxis->AppendCheckItem( AxisMirror_Horiz, _T("Mirror horizontally\tCtrl-M") );
1098     menuAxis->AppendCheckItem( AxisMirror_Vertic, _T("Mirror vertically\tCtrl-N") );
1099
1100     wxMenu *menuLogical = new wxMenu;
1101     menuLogical->Append( LogicalOrigin_MoveDown, _T("Move &down\tCtrl-D") );
1102     menuLogical->Append( LogicalOrigin_MoveUp, _T("Move &up\tCtrl-U") );
1103     menuLogical->Append( LogicalOrigin_MoveLeft, _T("Move &right\tCtrl-L") );
1104     menuLogical->Append( LogicalOrigin_MoveRight, _T("Move &left\tCtrl-R") );
1105     menuLogical->AppendSeparator();
1106     menuLogical->Append( LogicalOrigin_Set, _T("Set to (&100, 100)\tShift-Ctrl-1") );
1107     menuLogical->Append( LogicalOrigin_Restore, _T("&Restore to normal\tShift-Ctrl-0") );
1108
1109     wxMenu *menuColour = new wxMenu;
1110 #if wxUSE_COLOURDLG
1111     menuColour->Append( Colour_TextForeground, _T("Text &foreground...") );
1112     menuColour->Append( Colour_TextBackground, _T("Text &background...") );
1113     menuColour->Append( Colour_Background, _T("Background &colour...") );
1114 #endif // wxUSE_COLOURDLG
1115     menuColour->AppendCheckItem( Colour_BackgroundMode, _T("&Opaque/transparent\tCtrl-B") );
1116     menuColour->AppendCheckItem( Colour_TextureBackgound, _T("Draw textured back&ground\tCtrl-T") );
1117
1118     // now append the freshly created menu to the menu bar...
1119     wxMenuBar *menuBar = new wxMenuBar;
1120     menuBar->Append(menuFile, _T("&File"));
1121     menuBar->Append(menuMapMode, _T("&Mode"));
1122     menuBar->Append(menuUserScale, _T("&Scale"));
1123     menuBar->Append(menuAxis, _T("&Axis"));
1124     menuBar->Append(menuLogical, _T("&Origin"));
1125     menuBar->Append(menuColour, _T("&Colours"));
1126
1127     // ... and attach this menu bar to the frame
1128     SetMenuBar(menuBar);
1129
1130 #if wxUSE_STATUSBAR
1131     CreateStatusBar(2);
1132     SetStatusText(_T("Welcome to wxWidgets!"));
1133 #endif // wxUSE_STATUSBAR
1134
1135     m_mapMode = wxMM_TEXT;
1136     m_xUserScale = 1.0;
1137     m_yUserScale = 1.0;
1138     m_xLogicalOrigin = 0;
1139     m_yLogicalOrigin = 0;
1140     m_xAxisReversed =
1141     m_yAxisReversed = false;
1142     m_backgroundMode = wxSOLID;
1143     m_colourForeground = *wxRED;
1144     m_colourBackground = *wxBLUE;
1145     m_textureBackground = false;
1146
1147     m_canvas = new MyCanvas( this );
1148     m_canvas->SetScrollbars( 10, 10, 100, 240 );
1149 }
1150
1151 // event handlers
1152
1153 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
1154 {
1155     // true is to force the frame to close
1156     Close(true);
1157 }
1158
1159 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
1160 {
1161     wxString msg;
1162     msg.Printf( wxT("This is the about dialog of the drawing sample.\n")
1163                 wxT("This sample tests various primitive drawing functions\n")
1164                 wxT("(without any attempts to prevent flicker).\n")
1165                 wxT("Copyright (c) Robert Roebling 1999")
1166               );
1167
1168     wxMessageBox(msg, _T("About Drawing"), wxOK | wxICON_INFORMATION, this);
1169 }
1170
1171 void MyFrame::OnClip(wxCommandEvent& event)
1172 {
1173     m_canvas->Clip(event.IsChecked());
1174 }
1175
1176 void MyFrame::OnShow(wxCommandEvent& event)
1177 {
1178     m_canvas->ToShow((ScreenToShow)(event.GetId() - MenuShow_First));
1179 }
1180
1181 void MyFrame::OnOption(wxCommandEvent& event)
1182 {
1183     switch (event.GetId())
1184     {
1185         case MapMode_Text:
1186             m_mapMode = wxMM_TEXT;
1187             break;
1188         case MapMode_Lometric:
1189             m_mapMode = wxMM_LOMETRIC;
1190             break;
1191         case MapMode_Twips:
1192             m_mapMode = wxMM_TWIPS;
1193             break;
1194         case MapMode_Points:
1195             m_mapMode = wxMM_POINTS;
1196             break;
1197         case MapMode_Metric:
1198             m_mapMode = wxMM_METRIC;
1199             break;
1200
1201         case LogicalOrigin_MoveDown:
1202             m_yLogicalOrigin += 10;
1203             break;
1204         case LogicalOrigin_MoveUp:
1205             m_yLogicalOrigin -= 10;
1206             break;
1207         case LogicalOrigin_MoveLeft:
1208             m_xLogicalOrigin += 10;
1209             break;
1210         case LogicalOrigin_MoveRight:
1211             m_xLogicalOrigin -= 10;
1212             break;
1213         case LogicalOrigin_Set:
1214             m_xLogicalOrigin =
1215             m_yLogicalOrigin = -100;
1216             break;
1217         case LogicalOrigin_Restore:
1218             m_xLogicalOrigin =
1219             m_yLogicalOrigin = 0;
1220             break;
1221
1222         case UserScale_StretchHoriz:
1223             m_xUserScale *= 1.10;
1224             break;
1225         case UserScale_ShrinkHoriz:
1226             m_xUserScale /= 1.10;
1227             break;
1228         case UserScale_StretchVertic:
1229             m_yUserScale *= 1.10;
1230             break;
1231         case UserScale_ShrinkVertic:
1232             m_yUserScale /= 1.10;
1233             break;
1234         case UserScale_Restore:
1235             m_xUserScale =
1236             m_yUserScale = 1.0;
1237             break;
1238
1239         case AxisMirror_Vertic:
1240             m_yAxisReversed = !m_yAxisReversed;
1241             break;
1242         case AxisMirror_Horiz:
1243             m_xAxisReversed = !m_xAxisReversed;
1244             break;
1245
1246 #if wxUSE_COLOURDLG
1247         case Colour_TextForeground:
1248             m_colourForeground = SelectColour();
1249             break;
1250         case Colour_TextBackground:
1251             m_colourBackground = SelectColour();
1252             break;
1253         case Colour_Background:
1254             {
1255                 wxColour col = SelectColour();
1256                 if ( col.Ok() )
1257                 {
1258                     m_backgroundBrush.SetColour(col);
1259                 }
1260             }
1261             break;
1262 #endif // wxUSE_COLOURDLG
1263
1264         case Colour_BackgroundMode:
1265             m_backgroundMode = m_backgroundMode == wxSOLID ? wxTRANSPARENT
1266                                                            : wxSOLID;
1267             break;
1268
1269         case Colour_TextureBackgound:
1270             m_textureBackground = ! m_textureBackground;
1271             break;
1272
1273         default:
1274             // skip Refresh()
1275             return;
1276     }
1277
1278     m_canvas->Refresh();
1279 }
1280
1281 void MyFrame::PrepareDC(wxDC& dc)
1282 {
1283     dc.SetLogicalOrigin( m_xLogicalOrigin, m_yLogicalOrigin );
1284     dc.SetAxisOrientation( !m_xAxisReversed, m_yAxisReversed );
1285     dc.SetUserScale( m_xUserScale, m_yUserScale );
1286     dc.SetMapMode( m_mapMode );
1287 }
1288
1289 #if wxUSE_COLOURDLG
1290 wxColour MyFrame::SelectColour()
1291 {
1292     wxColour col;
1293     wxColourData data;
1294     wxColourDialog dialog(this, &data);
1295
1296     if ( dialog.ShowModal() == wxID_OK )
1297     {
1298         col = dialog.GetColourData().GetColour();
1299     }
1300
1301     return col;
1302 }
1303 #endif // wxUSE_COLOURDLG
1304