samples/drawing/drawing.cpp

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