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