Initialize wxDateTime::Tm::yday in the ctor.

[wxWidgets.git] / src / mgl / dc.cpp

diff --git a/src/mgl/dc.cpp b/src/mgl/dc.cpp
index 2c48b7f25601656e0d30e89ab84cff39b33e68c3..5af342f8b776ffeb2853768a618d2998919d73df 100644 (file)
--- a/src/mgl/dc.cpp
+++ b/src/mgl/dc.cpp
@@ -1,10 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        dc.cpp
+// Name:        src/mgl/dc.cpp

 // Purpose:     wxDC class
 // Author:      Vaclav Slavik
 // Created:     2001/03/09
 // RCS-ID:      $Id$
 // Purpose:     wxDC class
 // Author:      Vaclav Slavik
 // Created:     2001/03/09
 // RCS-ID:      $Id$

-// Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
+// Copyright:   (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -16,10 +16,6 @@
 // headers
 // ---------------------------------------------------------------------------
 
 // headers
 // ---------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "dc.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -30,15 +26,15 @@
 #ifndef WX_PRECOMP
     #include "wx/dc.h"
     #include "wx/dcmemory.h"
 #ifndef WX_PRECOMP
     #include "wx/dc.h"
     #include "wx/dcmemory.h"

+    #include "wx/log.h"

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

+#include "wx/encinfo.h"

 #include "wx/fontmap.h"
 #include "wx/mgl/private.h"
 #include "wx/fontmap.h"
 #include "wx/mgl/private.h"

-#include "wx/log.h"

 
 #include <string.h>
 
 #include <string.h>

-#include <math.h>

 #include <mgraph.hpp>
 
 
 #include <mgraph.hpp>
 
 


@@ -47,12 +43,6 @@
 // constants
 //-----------------------------------------------------------------------------
 
 // constants
 //-----------------------------------------------------------------------------
 

-const double mm2inches      = 0.0393700787402;
-const double inches2mm      = 25.4;
-const double mm2twips       = 56.6929133859;
-const double twips2mm       = 0.0176388888889;
-const double mm2pt          = 2.83464566929;
-const double pt2mm          = 0.352777777778;

 const double RAD2DEG        = 180.0 / M_PI;
 
 
 const double RAD2DEG        = 180.0 / M_PI;
 
 


@@ -63,8 +53,8 @@ const double RAD2DEG        = 180.0 / M_PI;
 const ushort STIPPLE_wxDOT        = 0x5555/* - - - - - - - -*/;
 const ushort STIPPLE_wxLONG_DASH  = 0xF0F0/*    ----    ----*/;
 const ushort STIPPLE_wxSHORT_DASH = 0xCCCC/*--  --  --  --  */;
 const ushort STIPPLE_wxDOT        = 0x5555/* - - - - - - - -*/;
 const ushort STIPPLE_wxLONG_DASH  = 0xF0F0/*    ----    ----*/;
 const ushort STIPPLE_wxSHORT_DASH = 0xCCCC/*--  --  --  --  */;

-const ushort STIPPLE_wxDOT_DASH   = 0x3939/*  ---  -  ---  -*/;        
-const ushort STIPPLE_wxSOLID      = 0xFFFF/*----------------*/;        
+const ushort STIPPLE_wxDOT_DASH   = 0x3939/*  ---  -  ---  -*/;
+const ushort STIPPLE_wxSOLID      = 0xFFFF/*----------------*/;

 
 #define PATTERN_ROW(b7,b6,b5,b4,b3,b2,b1,b0) \
             ((b7 << 7) | (b6 << 6) | (b5 << 5) | (b4 << 4) | \
 
 #define PATTERN_ROW(b7,b6,b5,b4,b3,b2,b1,b0) \
             ((b7 << 7) | (b6 << 6) | (b5 << 5) | (b4 << 4) | \


@@ -147,10 +137,10 @@ IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase)
 // Default constructor
 wxDC::wxDC()
 {
 // Default constructor
 wxDC::wxDC()
 {

-    m_isMemDC = FALSE;
+    m_isMemDC = false;

     m_MGLDC = NULL;
     m_MGLDC = NULL;

-    m_OwnsMGLDC = FALSE;
-    m_ok = FALSE; // must call SetMGLDevCtx() before using it
+    m_OwnsMGLDC = false;
+    m_ok = false; // must call SetMGLDevCtx() before using it

 
     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
                     (double)wxGetDisplaySizeMM().GetWidth();
 
     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
                     (double)wxGetDisplaySizeMM().GetWidth();


@@ -162,16 +152,16 @@ wxDC::wxDC()
     m_brush = *wxWHITE_BRUSH;
     m_penOfsX = m_penOfsY = 0;
 
     m_brush = *wxWHITE_BRUSH;
     m_penOfsX = m_penOfsY = 0;
 

-    m_penSelected = m_brushSelected = FALSE;
-    m_downloadedPatterns[0] = m_downloadedPatterns[1] = FALSE;
-    
+    m_penSelected = m_brushSelected = false;
+    m_downloadedPatterns[0] = m_downloadedPatterns[1] = false;
+

     m_mglFont = NULL;
 }
 
 
 wxDC::~wxDC()
 {
     m_mglFont = NULL;
 }
 
 
 wxDC::~wxDC()
 {

-    if (m_OwnsMGLDC) 
+    if (m_OwnsMGLDC)

         delete m_MGLDC;
 }
 
         delete m_MGLDC;
 }
 


@@ -181,11 +171,11 @@ void wxDC::SetMGLDC(MGLDevCtx *mgldc, bool OwnsMGLDC)
         delete m_MGLDC;
     m_MGLDC = mgldc;
     m_OwnsMGLDC = OwnsMGLDC;
         delete m_MGLDC;
     m_MGLDC = mgldc;
     m_OwnsMGLDC = OwnsMGLDC;

-       m_ok = TRUE;
+    m_ok = true;

 
     if ( !m_globalClippingRegion.IsNull() )
         SetClippingRegion(m_globalClippingRegion);
 
     if ( !m_globalClippingRegion.IsNull() )
         SetClippingRegion(m_globalClippingRegion);

-    
+

     InitializeMGLDC();
 }
 
     InitializeMGLDC();
 }
 


@@ -226,11 +216,11 @@ void wxDC::DoSetClippingRegion(wxCoord cx, wxCoord cy, wxCoord cw, wxCoord ch)
 
     m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
 
 
     m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
 

-    m_clipping = TRUE;
+    m_clipping = true;

     DO_SET_CLIPPING_BOX(m_currentClippingRegion)
 }
 
     DO_SET_CLIPPING_BOX(m_currentClippingRegion)
 }
 

-void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
+void wxDC::DoSetDeviceClippingRegion(const wxRegion& region)

 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 


@@ -239,25 +229,26 @@ void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
         DestroyClippingRegion();
         return;
     }
         DestroyClippingRegion();
         return;
     }

-   
+

     wxRegion rg(region);
     wxRegion rg(region);

-    
+

     // check if the DC is scaled or moved, and if yes, then
     // convert rg to device coordinates:
     if ( m_deviceOriginX != 0 || m_deviceOriginY != 0 ||
     // check if the DC is scaled or moved, and if yes, then
     // convert rg to device coordinates:
     if ( m_deviceOriginX != 0 || m_deviceOriginY != 0 ||

+         m_logicalOriginX != 0 || m_logicalOriginY != 0 ||

          XLOG2DEVREL(500) != 500 || YLOG2DEVREL(500) != 500 )
     {
         region_t *mrg = rg.GetMGLRegion().rgnPointer();
          XLOG2DEVREL(500) != 500 || YLOG2DEVREL(500) != 500 )
     {
         region_t *mrg = rg.GetMGLRegion().rgnPointer();

-           span_t *s;
-           segment_t *p;
-           for (s = mrg->spans; s; s = s->next) 
+        span_t *s;
+        segment_t *p;
+        for (s = mrg->spans; s; s = s->next)

         {
         {

-                   s->y = YLOG2DEV(s->y);
-                   for (p = s->seg; p; p = p->next)
-                           p->x = XLOG2DEV(p->x);
+            s->y = YLOG2DEV(s->y);
+            for (p = s->seg; p; p = p->next)
+                p->x = XLOG2DEV(p->x);

         }
     }
         }
     }

-    
+

     if ( !m_currentClippingRegion.IsNull() )
         m_currentClippingRegion.Intersect(rg);
     else
     if ( !m_currentClippingRegion.IsNull() )
         m_currentClippingRegion.Intersect(rg);
     else


@@ -265,24 +256,24 @@ void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
 
     m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
 
 
     m_MGLDC->setClipRegion(m_currentClippingRegion.GetMGLRegion());
 

-    m_clipping = TRUE;
+    m_clipping = true;

     DO_SET_CLIPPING_BOX(m_currentClippingRegion)
 }
 
 void wxDC::DestroyClippingRegion()
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
     DO_SET_CLIPPING_BOX(m_currentClippingRegion)
 }
 
 void wxDC::DestroyClippingRegion()
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );

-    
+

     if ( !m_globalClippingRegion.IsNull() )
     {
         m_MGLDC->setClipRegion(m_globalClippingRegion.GetMGLRegion());
         m_currentClippingRegion = m_globalClippingRegion;
     if ( !m_globalClippingRegion.IsNull() )
     {
         m_MGLDC->setClipRegion(m_globalClippingRegion.GetMGLRegion());
         m_currentClippingRegion = m_globalClippingRegion;

-        m_clipping = TRUE;
+        m_clipping = true;

     }
     else
     {
         m_MGLDC->setClipRect(MGLRect(0, 0, m_MGLDC->sizex()+1, m_MGLDC->sizey()+1));
     }
     else
     {
         m_MGLDC->setClipRect(MGLRect(0, 0, m_MGLDC->sizex()+1, m_MGLDC->sizey()+1));

-        m_clipping = FALSE;
+        ResetClipping();

         m_currentClippingRegion.Clear();
     }
 }
         m_currentClippingRegion.Clear();
     }
 }


@@ -293,12 +284,12 @@ void wxDC::DestroyClippingRegion()
 
 bool wxDC::CanDrawBitmap() const
 {
 
 bool wxDC::CanDrawBitmap() const
 {

-    return TRUE;
+    return true;

 }
 
 bool wxDC::CanGetTextExtent() const
 {
 }
 
 bool wxDC::CanGetTextExtent() const
 {

-    return TRUE;
+    return true;

 }
 
 int wxDC::GetDepth() const
 }
 
 int wxDC::GetDepth() const


@@ -327,20 +318,24 @@ void wxDC::Clear()
     }
 }
 
     }
 }
 

-void wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
+extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
+                          const wxColour & col, wxFloodFillStyle style);
+
+bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
+                       const wxColour& col, wxFloodFillStyle style)

 {
 {

-    wxFAIL_MSG( wxT("wxDC::DoFloodFill not implemented") );
+    return wxDoFloodFill(this, x, y, col, style);

 }
 
 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 {
 }
 
 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 {

-    wxCHECK_MSG( col, FALSE, _T("NULL colour parameter in wxDC::GetPixel"));
+    wxCHECK_MSG( col, false, wxT("NULL colour parameter in wxDC::GetPixel"));

 
     uchar r, g, b;
 
     uchar r, g, b;

-    m_MGLDC->unpackColorFast(m_MGLDC->getPixel(XLOG2DEV(x), YLOG2DEV(y)), 
+    m_MGLDC->unpackColorFast(m_MGLDC->getPixel(XLOG2DEV(x), YLOG2DEV(y)),

                              r, g, b);
     col->Set(r, g, b);
                              r, g, b);
     col->Set(r, g, b);

-    return TRUE;
+    return true;

 }
 
 void wxDC::DoCrossHair(wxCoord x, wxCoord y)
 }
 
 void wxDC::DoCrossHair(wxCoord x, wxCoord y)


@@ -353,7 +348,7 @@ void wxDC::DoCrossHair(wxCoord x, wxCoord y)
         int h = 0;
         GetSize(&w, &h);
         m_MGLDC->makeCurrent(); // will go away with MGL6.0
         int h = 0;
         GetSize(&w, &h);
         m_MGLDC->makeCurrent(); // will go away with MGL6.0

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

             SelectPen();
         wxCoord xx = XLOG2DEV(x);
         wxCoord yy = YLOG2DEV(y);
             SelectPen();
         wxCoord xx = XLOG2DEV(x);
         wxCoord yy = YLOG2DEV(y);


@@ -371,9 +366,9 @@ void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
         m_MGLDC->makeCurrent(); // will go away with MGL6.0
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
         m_MGLDC->makeCurrent(); // will go away with MGL6.0

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

             SelectPen();
             SelectPen();

-        m_MGLDC->lineExt(XLOG2DEV(x1) + m_penOfsX, YLOG2DEV(y1) + m_penOfsY, 
+        m_MGLDC->lineExt(XLOG2DEV(x1) + m_penOfsX, YLOG2DEV(y1) + m_penOfsY,

                       XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY,FALSE);
         CalcBoundingBox(x1, y1);
         CalcBoundingBox(x2, y2);
                       XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY,FALSE);
         CalcBoundingBox(x1, y1);
         CalcBoundingBox(x2, y2);


@@ -427,17 +422,17 @@ void wxDC::DoDrawArc(wxCoord x1, wxCoord y1,
     m_MGLDC->makeCurrent(); // will go away with MGL6.0
     if ( m_brush.GetStyle() != wxTRANSPARENT )
     {
     m_MGLDC->makeCurrent(); // will go away with MGL6.0
     if ( m_brush.GetStyle() != wxTRANSPARENT )
     {

-        if ( !m_brushSelected ) 
+        if ( !m_brushSelected )

             SelectBrush();
         m_MGLDC->fillEllipseArc(xxc, yyc, r, r, alpha1, alpha2);
             SelectBrush();
         m_MGLDC->fillEllipseArc(xxc, yyc, r, r, alpha1, alpha2);

-    }    
+    }

 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

          SelectPen();
         m_MGLDC->ellipseArc(xxc + m_penOfsX, yyc + m_penOfsY, r, r, alpha1, alpha2);
          SelectPen();
         m_MGLDC->ellipseArc(xxc + m_penOfsX, yyc + m_penOfsY, r, r, alpha1, alpha2);

-    }    
+    }

 
     CalcBoundingBox(xc - r, yc - r);
     CalcBoundingBox(xc + r, yc + r);
 
     CalcBoundingBox(xc - r, yc - r);
     CalcBoundingBox(xc + r, yc + r);


@@ -450,20 +445,20 @@ void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
         m_MGLDC->makeCurrent(); // will go away with MGL6.0
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
         m_MGLDC->makeCurrent(); // will go away with MGL6.0

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

             SelectPen();
         m_MGLDC->pixel(XLOG2DEV(x), YLOG2DEV(y));
         CalcBoundingBox(x, y);
     }
 }
 
             SelectPen();
         m_MGLDC->pixel(XLOG2DEV(x), YLOG2DEV(y));
         CalcBoundingBox(x, y);
     }
 }
 

-void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,int fillStyle)
+void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,wxPolygonFillMode WXUNUSED(fillStyle))

 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 

-    wxCoord xxoffset = XLOG2DEVREL(xoffset), 
+    wxCoord xxoffset = XLOG2DEVREL(xoffset),

             yyoffset = YLOG2DEVREL(yoffset);
             yyoffset = YLOG2DEVREL(yoffset);

-    MGLPoint *cpoints = new MGLPoint[n+1];   
+    MGLPoint *cpoints = new MGLPoint[n+1];

     for (int i = 0; i < n; i++)
     {
         CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);
     for (int i = 0; i < n; i++)
     {
         CalcBoundingBox(points[i].x + xoffset, points[i].y + yoffset);


@@ -482,7 +477,7 @@ void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffs
 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

             SelectPen();
         if (m_penOfsX != 0 || m_penOfsY != 0)
         {
             SelectPen();
         if (m_penOfsX != 0 || m_penOfsY != 0)
         {


@@ -506,7 +501,7 @@ void wxDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset
     {
         MGLPoint *cpoints = new MGLPoint[n];
         m_MGLDC->makeCurrent(); // will go away with MGL6.0
     {
         MGLPoint *cpoints = new MGLPoint[n];
         m_MGLDC->makeCurrent(); // will go away with MGL6.0

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

             SelectPen();
         for (int i = 0; i < n; i++)
         {
             SelectPen();
         for (int i = 0; i < n; i++)
         {


@@ -530,32 +525,33 @@ void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 
     if ( ww == 0 || hh == 0 ) return;
 
 
     if ( ww == 0 || hh == 0 ) return;
 

-    if ( ww < 0 ) 
+    if ( ww < 0 )

     {
     {

-        ww = -ww; 
+        ww = -ww;

         xx = xx - ww;
     }
         xx = xx - ww;
     }

-    if ( hh < 0 ) 
+    if ( hh < 0 )

     {
     {

-        hh = -hh; 
-        yy = yy - hh; 
+        hh = -hh;
+        yy = yy - hh;

     }
 
     m_MGLDC->makeCurrent(); // will go away with MGL6.0
     if ( m_brush.GetStyle() != wxTRANSPARENT )
     {
     }
 
     m_MGLDC->makeCurrent(); // will go away with MGL6.0
     if ( m_brush.GetStyle() != wxTRANSPARENT )
     {

-        if ( !m_brushSelected ) 
+        if ( !m_brushSelected )

             SelectBrush();
         m_MGLDC->fillRect(xx, yy, xx + ww, yy + hh);
             SelectBrush();
         m_MGLDC->fillRect(xx, yy, xx + ww, yy + hh);

-    }    
+    }

 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

             SelectPen();
             SelectPen();

-        m_MGLDC->rect(xx + m_penOfsX, yy + m_penOfsY, 
+
+        m_MGLDC->rect(xx + m_penOfsX, yy + m_penOfsY,

                       xx + ww + m_penOfsX, yy + hh + m_penOfsY);
                       xx + ww + m_penOfsX, yy + hh + m_penOfsY);

-    }    
+    }

 
     CalcBoundingBox(x, y);
     CalcBoundingBox(x + width, y + height);
 
     CalcBoundingBox(x, y);
     CalcBoundingBox(x + width, y + height);


@@ -565,7 +561,7 @@ void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord h
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 

-    if ( radius < 0.0 ) 
+    if ( radius < 0.0 )

         radius = -radius * ((width < height) ? width : height);
 
     wxCoord xx = XLOG2DEV(x);
         radius = -radius * ((width < height) ? width : height);
 
     wxCoord xx = XLOG2DEV(x);


@@ -575,15 +571,15 @@ void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord h
     wxCoord rr = XLOG2DEVREL((wxCoord)radius);
 
     // CMB: handle -ve width and/or height
     wxCoord rr = XLOG2DEVREL((wxCoord)radius);
 
     // CMB: handle -ve width and/or height

-    if ( ww < 0 ) 
+    if ( ww < 0 )

     {
     {

-        ww = -ww; 
-        xx = xx - ww; 
+        ww = -ww;
+        xx = xx - ww;

     }
     }

-    if ( hh < 0 ) 
-    { 
-        hh = -hh; 
-        yy = yy - hh; 
+    if ( hh < 0 )
+    {
+        hh = -hh;
+        yy = yy - hh;

     }
 
     // CMB: if radius is zero use DrawRectangle() instead to avoid
     }
 
     // CMB: if radius is zero use DrawRectangle() instead to avoid


@@ -607,7 +603,7 @@ void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord h
     m_MGLDC->makeCurrent(); // will go away with MGL6.0
     if ( m_brush.GetStyle() != wxTRANSPARENT )
     {
     m_MGLDC->makeCurrent(); // will go away with MGL6.0
     if ( m_brush.GetStyle() != wxTRANSPARENT )
     {

-        if (!m_brushSelected) 
+        if (!m_brushSelected)

             SelectBrush();
         m_MGLDC->fillRect(xx+rr, yy, xx+ww-rr, yy+hh);
         m_MGLDC->fillRect(xx, yy+rr, xx+ww, yy+hh-rr);
             SelectBrush();
         m_MGLDC->fillRect(xx+rr, yy, xx+ww-rr, yy+hh);
         m_MGLDC->fillRect(xx, yy+rr, xx+ww, yy+hh-rr);


@@ -615,20 +611,20 @@ void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord h
         m_MGLDC->fillEllipseArc(xx+ww-rr, yy+rr, rr, rr, 0, 90);
         m_MGLDC->fillEllipseArc(xx+rr, yy+hh-rr, rr, rr, 180, 270);
         m_MGLDC->fillEllipseArc(xx+ww-rr, yy+hh-rr, rr, rr, 270, 0);
         m_MGLDC->fillEllipseArc(xx+ww-rr, yy+rr, rr, rr, 0, 90);
         m_MGLDC->fillEllipseArc(xx+rr, yy+hh-rr, rr, rr, 180, 270);
         m_MGLDC->fillEllipseArc(xx+ww-rr, yy+hh-rr, rr, rr, 270, 0);

-    }   
+    }

 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

             SelectPen();
         xx += m_penOfsX;
         yy += m_penOfsY;
             SelectPen();
         xx += m_penOfsX;
         yy += m_penOfsY;

-        m_MGLDC->line(xx+rr+1, yy, xx+ww-rr, yy);       
+        m_MGLDC->line(xx+rr+1, yy, xx+ww-rr, yy);

         m_MGLDC->ellipseArc(xx+ww-rr, yy+rr, rr, rr, 0, 90);
         m_MGLDC->line(xx+ww, yy+rr+1, xx+ww, yy+hh-rr);
         m_MGLDC->ellipseArc(xx+ww-rr, yy+hh-rr, rr, rr, 270, 0);
         m_MGLDC->line(xx+ww-rr, yy+hh, xx+rr+1, yy+hh);
         m_MGLDC->ellipseArc(xx+ww-rr, yy+rr, rr, rr, 0, 90);
         m_MGLDC->line(xx+ww, yy+rr+1, xx+ww, yy+hh-rr);
         m_MGLDC->ellipseArc(xx+ww-rr, yy+hh-rr, rr, rr, 270, 0);
         m_MGLDC->line(xx+ww-rr, yy+hh, xx+rr+1, yy+hh);

-        m_MGLDC->ellipseArc(xx+rr, yy+hh-rr, rr, rr, 180, 270);       
+        m_MGLDC->ellipseArc(xx+rr, yy+hh-rr, rr, rr, 180, 270);

         m_MGLDC->line(xx, yy+hh-rr, xx, yy+rr+1);
         m_MGLDC->ellipseArc(xx+rr, yy+rr, rr, rr, 90, 180);
     }
         m_MGLDC->line(xx, yy+hh-rr, xx, yy+rr+1);
         m_MGLDC->ellipseArc(xx+rr, yy+rr, rr, rr, 90, 180);
     }


@@ -651,13 +647,13 @@ void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
             SelectBrush();
         MGLRect rect(XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
         m_MGLDC->fillEllipse(rect);
             SelectBrush();
         MGLRect rect(XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
         m_MGLDC->fillEllipse(rect);

-    }    
+    }

 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

             SelectPen();
             SelectPen();

-        MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY, 
+        MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY,

                      XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY);
         m_MGLDC->ellipse(rect);
     }
                      XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY);
         m_MGLDC->ellipse(rect);
     }


@@ -679,16 +675,16 @@ void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,d
         if (!m_brushSelected) SelectBrush();
         MGLRect rect(XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
         m_MGLDC->fillEllipseArc(rect, (int)sa, (int)ea);
         if (!m_brushSelected) SelectBrush();
         MGLRect rect(XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
         m_MGLDC->fillEllipseArc(rect, (int)sa, (int)ea);

-    }    
+    }

 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {
 
     if ( m_pen.GetStyle() != wxTRANSPARENT )
     {

-        if ( !m_penSelected ) 
+        if ( !m_penSelected )

             SelectPen();
             SelectPen();

-        MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY, 
+        MGLRect rect(XLOG2DEV(x) + m_penOfsX, YLOG2DEV(y) + m_penOfsY,

                      XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY);
         m_MGLDC->ellipseArc(rect, (int)sa, (int)ea);
                      XLOG2DEV(x2) + m_penOfsX, YLOG2DEV(y2) + m_penOfsY);
         m_MGLDC->ellipseArc(rect, (int)sa, (int)ea);

-    }    
+    }

 
     CalcBoundingBox(x, y);
     CalcBoundingBox(x2, y2);
 
     CalcBoundingBox(x, y);
     CalcBoundingBox(x2, y2);


@@ -714,8 +710,8 @@ bool wxDC::SelectMGLFont()
         bool antialiased = (GetDepth() > 8);
 
         m_mglFont = m_font.GetMGLfont_t(scale, antialiased);
         bool antialiased = (GetDepth() > 8);
 
         m_mglFont = m_font.GetMGLfont_t(scale, antialiased);

-        wxCHECK_MSG( m_mglFont, FALSE, wxT("invalid font") );
-        
+        wxCHECK_MSG( m_mglFont, false, wxT("invalid font") );
+

         m_MGLDC->useFont(m_mglFont);
         wxLogTrace("mgl_font", "useFont(%p)", m_mglFont);
 
         m_MGLDC->useFont(m_mglFont);
         wxLogTrace("mgl_font", "useFont(%p)", m_mglFont);
 


@@ -726,7 +722,7 @@ bool wxDC::SelectMGLFont()
              !wxTestFontEncoding(nativeEnc) )
         {
 #if wxUSE_FONTMAP
              !wxTestFontEncoding(nativeEnc) )
         {
 #if wxUSE_FONTMAP

-            if ( !wxTheFontMapper->GetAltForEncoding(encoding, &nativeEnc) )
+            if ( !wxFontMapper::Get()->GetAltForEncoding(encoding, &nativeEnc) )

 #endif
             {
                 nativeEnc.mglEncoding = MGL_ENCODING_ASCII;
 #endif
             {
                 nativeEnc.mglEncoding = MGL_ENCODING_ASCII;


@@ -735,7 +731,7 @@ bool wxDC::SelectMGLFont()
         m_MGLDC->setTextEncoding(nativeEnc.mglEncoding);
 #endif
     }
         m_MGLDC->setTextEncoding(nativeEnc.mglEncoding);
 #endif
     }

-    return TRUE;
+    return true;

 }
 
 void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
 }
 
 void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)


@@ -747,7 +743,7 @@ void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
     // Render the text:
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);
     // Render the text:
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);

-    
+

     m_MGLDC->setLineStyle(MGL_LINE_STIPPLE);
     m_MGLDC->setLineStipple(0xFFFF);
     m_MGLDC->setPenSize(1, 1);
     m_MGLDC->setLineStyle(MGL_LINE_STIPPLE);
     m_MGLDC->setLineStipple(0xFFFF);
     m_MGLDC->setPenSize(1, 1);


@@ -759,9 +755,9 @@ void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
     const char *c_text = text.c_str();
 #endif
 
     const char *c_text = text.c_str();
 #endif
 

-#if 1 
-    // FIXME_MGL - this is a temporary hack in absence of proper 
-    //             implementation of solid text background in MGL. Once 
+#if 1
+    // FIXME_MGL - this is a temporary hack in absence of proper
+    //             implementation of solid text background in MGL. Once

     //             the bug in MGL is fixed, this code should be nuked
     //             immediately. Note that the code is not 100% correct;
     //             it only works with wxCOPY logical function
     //             the bug in MGL is fixed, this code should be nuked
     //             immediately. Note that the code is not 100% correct;
     //             it only works with wxCOPY logical function


@@ -779,9 +775,9 @@ void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
             m_textForegroundColour.Green(), m_textForegroundColour.Blue()));
     m_MGLDC->setBackColor(m_MGLDC->packColorFast(m_textBackgroundColour.Red(),
             m_textBackgroundColour.Green(), m_textBackgroundColour.Blue()));
             m_textForegroundColour.Green(), m_textForegroundColour.Blue()));
     m_MGLDC->setBackColor(m_MGLDC->packColorFast(m_textBackgroundColour.Red(),
             m_textBackgroundColour.Green(), m_textBackgroundColour.Blue()));

-    
+

     m_MGLDC->drawStr(xx, yy, c_text);
     m_MGLDC->drawStr(xx, yy, c_text);

-    
+

     // Render underline:
     if ( m_font.GetUnderlined() )
     {
     // Render underline:
     if ( m_font.GetUnderlined() )
     {


@@ -799,7 +795,7 @@ void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
         m_MGLDC->line(x1, y1, x2, y2);
     }
 
         m_MGLDC->line(x1, y1, x2, y2);
     }
 

-    m_penSelected = m_brushSelected = FALSE;
+    m_penSelected = m_brushSelected = false;

 }
 
 void wxDC::DoDrawRotatedText(const wxString& text,
 }
 
 void wxDC::DoDrawRotatedText(const wxString& text,


@@ -807,7 +803,7 @@ void wxDC::DoDrawRotatedText(const wxString& text,
                              double angle)
 {
     m_MGLDC->makeCurrent(); // will go away with MGL6.0
                              double angle)
 {
     m_MGLDC->makeCurrent(); // will go away with MGL6.0

-    
+

     if ( angle == 0 )
     {
         DoDrawText(text, x, y);
     if ( angle == 0 )
     {
         DoDrawText(text, x, y);


@@ -825,9 +821,9 @@ void wxDC::DoDrawRotatedText(const wxString& text,
         wxFAIL_MSG(wxT("wxMGL only supports rotated text with angle 0,90,180 or 270"));
         return;
     }
         wxFAIL_MSG(wxT("wxMGL only supports rotated text with angle 0,90,180 or 270"));
         return;
     }

-    
+

     DrawAnyText(text, x, y);
     DrawAnyText(text, x, y);

-    
+

     // Restore default:
     m_MGLDC->setTextDirection(MGL_RIGHT_DIR);
 }
     // Restore default:
     m_MGLDC->setTextDirection(MGL_RIGHT_DIR);
 }


@@ -874,61 +870,61 @@ void wxDC::SelectMGLFatPen(int style, int flag)
     // switch between pens and brushes, we take advantage of MGL's ability
     // to have multiple (pix)pattern_t's loaded. We always download pen
     // to 0th slot and brush to 1st slot.
     // switch between pens and brushes, we take advantage of MGL's ability
     // to have multiple (pix)pattern_t's loaded. We always download pen
     // to 0th slot and brush to 1st slot.

-    if ( flag == wxMGL_SELECT_FROM_PEN ) 
+    if ( flag == wxMGL_SELECT_FROM_PEN )

         slot = 0;
     else
         slot = 1;
 
         slot = 0;
     else
         slot = 1;
 

-    // compute pen's width:    
+    // compute pen's width:

     if ( m_pen.GetWidth() <= 1 )
     {
         wx = wy = 1;
         m_penOfsX = m_penOfsY = 0;
     }
     else
     if ( m_pen.GetWidth() <= 1 )
     {
         wx = wy = 1;
         m_penOfsX = m_penOfsY = 0;
     }
     else

-    { 
+    {

         wx = (int)(0.5 + fabs((double) XLOG2DEVREL(m_pen.GetWidth())));
         wy = (int)(0.5 + fabs((double) YLOG2DEVREL(m_pen.GetWidth())));
         m_penOfsX = -wx/2;
         m_penOfsY = -wy/2;
     }
         wx = (int)(0.5 + fabs((double) XLOG2DEVREL(m_pen.GetWidth())));
         wy = (int)(0.5 + fabs((double) YLOG2DEVREL(m_pen.GetWidth())));
         m_penOfsX = -wx/2;
         m_penOfsY = -wy/2;
     }

-    
+

     // find pen's type:
     penstyle = MGL_BITMAP_TRANSPARENT;
     switch (style)
     {
     // find pen's type:
     penstyle = MGL_BITMAP_TRANSPARENT;
     switch (style)
     {

-        case wxBDIAGONAL_HATCH:  pattern = &PATTERN_wxBDIAGONAL_HATCH;  
-                                 penstyle = MGL_BITMAP_TRANSPARENT; 
+        case wxBDIAGONAL_HATCH:  pattern = &PATTERN_wxBDIAGONAL_HATCH;
+                                 penstyle = MGL_BITMAP_TRANSPARENT;

                                  break;
                                  break;

-        case wxCROSSDIAG_HATCH:  pattern = &PATTERN_wxCROSSDIAG_HATCH;  
-                                 penstyle = MGL_BITMAP_TRANSPARENT; 
+        case wxCROSSDIAG_HATCH:  pattern = &PATTERN_wxCROSSDIAG_HATCH;
+                                 penstyle = MGL_BITMAP_TRANSPARENT;

                                  break;
         case wxFDIAGONAL_HATCH:  pattern = &PATTERN_wxFDIAGONAL_HATCH;
                                  break;
         case wxFDIAGONAL_HATCH:  pattern = &PATTERN_wxFDIAGONAL_HATCH;

-                                 penstyle = MGL_BITMAP_TRANSPARENT; 
+                                 penstyle = MGL_BITMAP_TRANSPARENT;

                                  break;
         case wxCROSS_HATCH:      pattern = &PATTERN_wxCROSS_HATCH;
                                  break;
         case wxCROSS_HATCH:      pattern = &PATTERN_wxCROSS_HATCH;

-                                 penstyle = MGL_BITMAP_TRANSPARENT; 
+                                 penstyle = MGL_BITMAP_TRANSPARENT;

                                  break;
         case wxHORIZONTAL_HATCH: pattern = &PATTERN_wxHORIZONTAL_HATCH;
                                  break;
         case wxHORIZONTAL_HATCH: pattern = &PATTERN_wxHORIZONTAL_HATCH;

-                                 penstyle = MGL_BITMAP_TRANSPARENT; 
+                                 penstyle = MGL_BITMAP_TRANSPARENT;

                                  break;
         case wxVERTICAL_HATCH:   pattern = &PATTERN_wxVERTICAL_HATCH;
                                  break;
         case wxVERTICAL_HATCH:   pattern = &PATTERN_wxVERTICAL_HATCH;

-                                 penstyle = MGL_BITMAP_TRANSPARENT; 
+                                 penstyle = MGL_BITMAP_TRANSPARENT;

                                  break;
                                  break;

-        
+

         case wxSTIPPLE:
         case wxSTIPPLE:

-            if ( flag == wxMGL_SELECT_FROM_PEN ) 
+            if ( flag == wxMGL_SELECT_FROM_PEN )

                 pixPattern = (pixpattern24_t*) m_pen.GetPixPattern();
             else
                 pixPattern = (pixpattern24_t*) m_brush.GetPixPattern();
             penstyle = MGL_PIXMAP;
             break;
                 pixPattern = (pixpattern24_t*) m_pen.GetPixPattern();
             else
                 pixPattern = (pixpattern24_t*) m_brush.GetPixPattern();
             penstyle = MGL_PIXMAP;
             break;

-            
+

         case wxSTIPPLE_MASK_OPAQUE:
             pattern = (pattern_t*) m_brush.GetMaskPattern();
             penstyle = MGL_BITMAP_OPAQUE;
             break;
         case wxSTIPPLE_MASK_OPAQUE:
             pattern = (pattern_t*) m_brush.GetMaskPattern();
             penstyle = MGL_BITMAP_OPAQUE;
             break;

-            
+

         case wxSOLID:
         default:
             penstyle = MGL_BITMAP_SOLID; break;
         case wxSOLID:
         default:
             penstyle = MGL_BITMAP_SOLID; break;


@@ -941,24 +937,24 @@ void wxDC::SelectMGLFatPen(int style, int flag)
         if ( !m_downloadedPatterns[slot] )
         {
             m_MGLDC->setPenBitmapPattern(slot, pattern);
         if ( !m_downloadedPatterns[slot] )
         {
             m_MGLDC->setPenBitmapPattern(slot, pattern);

-            m_downloadedPatterns[slot] = TRUE;
+            m_downloadedPatterns[slot] = true;

         }
         m_MGLDC->usePenBitmapPattern(slot);
     }
         }
         m_MGLDC->usePenBitmapPattern(slot);
     }

-    
+

     if ( pixPattern )
     {
         if ( !m_downloadedPatterns[slot] )
         {
             pixpattern_t pix;
             int x, y, c;
     if ( pixPattern )
     {
         if ( !m_downloadedPatterns[slot] )
         {
             pixpattern_t pix;
             int x, y, c;

-            
+

             switch (GetDepth())
             {
                 case 8:
                     for (y = 0; y < 8; y++)
                         for (x = 0; x < 8; x++)
             switch (GetDepth())
             {
                 case 8:
                     for (y = 0; y < 8; y++)
                         for (x = 0; x < 8; x++)

-                            pix.b8.p[x][y] = m_MGLDC->packColorFast(
+                            pix.b8.p[x][y] = (uchar)m_MGLDC->packColorFast(

                                                         pixPattern->p[x][y][0],
                                                         pixPattern->p[x][y][1],
                                                         pixPattern->p[x][y][2]);
                                                         pixPattern->p[x][y][0],
                                                         pixPattern->p[x][y][1],
                                                         pixPattern->p[x][y][2]);


@@ -967,7 +963,7 @@ void wxDC::SelectMGLFatPen(int style, int flag)
                 case 16:
                     for (y = 0; y < 8; y++)
                         for (x = 0; x < 8; x++)
                 case 16:
                     for (y = 0; y < 8; y++)
                         for (x = 0; x < 8; x++)

-                            pix.b16.p[x][y] = m_MGLDC->packColorFast(
+                            pix.b16.p[x][y] = (M_uint16)m_MGLDC->packColorFast(

                                                         pixPattern->p[x][y][0],
                                                         pixPattern->p[x][y][1],
                                                         pixPattern->p[x][y][2]);
                                                         pixPattern->p[x][y][0],
                                                         pixPattern->p[x][y][1],
                                                         pixPattern->p[x][y][2]);


@@ -987,15 +983,15 @@ void wxDC::SelectMGLFatPen(int style, int flag)
                                                         pixPattern->p[x][y][2]);
                     break;
                 default:
                                                         pixPattern->p[x][y][2]);
                     break;
                 default:

-                    wxFAIL_MSG(_T("invalid DC depth"));
+                    wxFAIL_MSG(wxT("invalid DC depth"));

                     break;
             }
             m_MGLDC->setPenPixmapPattern(slot, &pix);
                     break;
             }
             m_MGLDC->setPenPixmapPattern(slot, &pix);

-            m_downloadedPatterns[slot] = TRUE;
+            m_downloadedPatterns[slot] = true;

         }
         m_MGLDC->usePenPixmapPattern(slot);
     }
         }
         m_MGLDC->usePenPixmapPattern(slot);
     }

-    
+

     m_MGLDC->setLineStyle(MGL_LINE_PENSTYLE);
     m_MGLDC->setPenStyle(penstyle);
     m_MGLDC->setPenSize(wy, wx);
     m_MGLDC->setLineStyle(MGL_LINE_PENSTYLE);
     m_MGLDC->setPenStyle(penstyle);
     m_MGLDC->setPenSize(wy, wx);


@@ -1020,7 +1016,7 @@ void wxDC::SelectPen()
         case wxDOT_DASH:
             SelectMGLStipplePen(m_pen.GetStyle());
             break;
         case wxDOT_DASH:
             SelectMGLStipplePen(m_pen.GetStyle());
             break;

-            
+

         case wxBDIAGONAL_HATCH:
         case wxCROSSDIAG_HATCH:
         case wxFDIAGONAL_HATCH:
         case wxBDIAGONAL_HATCH:
         case wxCROSSDIAG_HATCH:
         case wxFDIAGONAL_HATCH:


@@ -1043,8 +1039,8 @@ void wxDC::SelectPen()
                 SelectMGLFatPen(wxSOLID, wxMGL_SELECT_FROM_PEN);
             break;
     }
                 SelectMGLFatPen(wxSOLID, wxMGL_SELECT_FROM_PEN);
             break;
     }

-    m_penSelected = TRUE;
-    m_brushSelected = FALSE;
+    m_penSelected = true;
+    m_brushSelected = false;

 }
 
 void wxDC::SelectBrush()
 }
 
 void wxDC::SelectBrush()


@@ -1053,7 +1049,7 @@ void wxDC::SelectBrush()
 
     wxColour fg, bg;
     m_MGLDC->makeCurrent(); // will go away with MGL6.0
 
     wxColour fg, bg;
     m_MGLDC->makeCurrent(); // will go away with MGL6.0

-    
+

     if ( m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE )
     {
         fg = m_textForegroundColour;
     if ( m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE )
     {
         fg = m_textForegroundColour;


@@ -1067,8 +1063,8 @@ void wxDC::SelectBrush()
 
     m_MGLDC->setColorRGB(fg.Red(), fg.Green(), fg.Blue());
     m_MGLDC->setBackColor(m_MGLDC->packColorFast(bg.Red(), bg.Green(), bg.Blue()));
 
     m_MGLDC->setColorRGB(fg.Red(), fg.Green(), fg.Blue());
     m_MGLDC->setBackColor(m_MGLDC->packColorFast(bg.Red(), bg.Green(), bg.Blue()));

-    m_penSelected = FALSE;
-    m_brushSelected = TRUE;
+    m_penSelected = false;
+    m_brushSelected = true;

 
     SelectMGLFatPen(m_brush.GetStyle(), wxMGL_SELECT_FROM_BRUSH);
 }
 
     SelectMGLFatPen(m_brush.GetStyle(), wxMGL_SELECT_FROM_BRUSH);
 }


@@ -1078,8 +1074,8 @@ void wxDC::SetPen(const wxPen& pen)
     if ( !pen.Ok() ) return;
     if ( m_pen == pen ) return;
     m_pen = pen;
     if ( !pen.Ok() ) return;
     if ( m_pen == pen ) return;
     m_pen = pen;

-    m_penSelected = FALSE;
-    m_downloadedPatterns[0] = FALSE;
+    m_penSelected = false;
+    m_downloadedPatterns[0] = false;

 }
 
 void wxDC::SetBrush(const wxBrush& brush)
 }
 
 void wxDC::SetBrush(const wxBrush& brush)


@@ -1087,28 +1083,29 @@ void wxDC::SetBrush(const wxBrush& brush)
     if ( !brush.Ok() ) return;
     if ( m_brush == brush ) return;
     m_brush = brush;
     if ( !brush.Ok() ) return;
     if ( m_brush == brush ) return;
     m_brush = brush;

-    m_brushSelected = FALSE;
-    m_downloadedPatterns[1] = FALSE;
+    m_brushSelected = false;
+    m_downloadedPatterns[1] = false;

 }
 
 void wxDC::SetPalette(const wxPalette& palette)
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 }
 
 void wxDC::SetPalette(const wxPalette& palette)
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );

-    
-    if ( palette == wxNullPalette )
+
+    if ( !palette.Ok() )

     {
         if ( m_oldPalette.Ok() )
             SetPalette(m_oldPalette);
         return;
     }
 
     {
         if ( m_oldPalette.Ok() )
             SetPalette(m_oldPalette);
         return;
     }
 

-    if ( !palette.Ok() ) return;
-    if ( m_palette == palette ) return;
+    if ( palette.IsSameAs(m_palette) )
+        return;
+

     m_oldPalette = m_palette;
     m_palette = palette;
 
     int cnt = m_palette.GetColoursCount();
     m_oldPalette = m_palette;
     m_palette = palette;
 
     int cnt = m_palette.GetColoursCount();

-    palette_t *pal = m_palette.GetMGLpalette_t();   
+    palette_t *pal = m_palette.GetMGLpalette_t();

     m_MGLDC->setPalette(pal, cnt, 0);
     m_MGLDC->realizePalette(cnt, 0, TRUE);
 }
     m_MGLDC->setPalette(pal, cnt, 0);
     m_MGLDC->realizePalette(cnt, 0, TRUE);
 }


@@ -1126,7 +1123,7 @@ void wxDC::SetBackground(const wxBrush& brush)
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 

-    if (!m_backgroundBrush.Ok()) return;
+    if (!brush.Ok()) return;

 
     m_backgroundBrush = brush;
     wxColour &clr = m_backgroundBrush.GetColour();
 
     m_backgroundBrush = brush;
     wxColour &clr = m_backgroundBrush.GetColour();


@@ -1144,7 +1141,7 @@ void wxDC::SetBackgroundMode(int mode)
         m_MGLDC->setBackMode(MGL_TRANSPARENT_BACKGROUND);
 }
 
         m_MGLDC->setBackMode(MGL_TRANSPARENT_BACKGROUND);
 }
 

-void wxDC::SetLogicalFunction(int function)
+void wxDC::SetLogicalFunction(wxRasterOperationMode function)

 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 
 {
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 


@@ -1183,10 +1180,10 @@ int wxDC::LogicalFunctionToMGLRop(int logFunc) const
     return (int)rop;
 }
 
     return (int)rop;
 }
 

-bool wxDC::StartDoc(const wxString& message)
+bool wxDC::StartDoc(const wxString& WXUNUSED(message))

 {
 {

-    // We might be previewing, so return TRUE to let it continue.
-    return TRUE;
+    // We might be previewing, so return true to let it continue.
+    return true;

 }
 
 void wxDC::EndDoc()
 }
 
 void wxDC::EndDoc()


@@ -1224,23 +1221,23 @@ wxCoord wxDC::GetCharWidth() const
 
 void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
                            wxCoord *descent, wxCoord *externalLeading,
 
 void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
                            wxCoord *descent, wxCoord *externalLeading,

-                           wxFont *theFont) const
+                           const wxFont *theFont) const

 {
     wxFont oldFont;
 {
     wxFont oldFont;

-    
+

     if ( theFont != NULL )
     {
         oldFont = m_font;
         wxConstCast(this, wxDC)->SetFont(*theFont);
     }
     if ( theFont != NULL )
     {
         oldFont = m_font;
         wxConstCast(this, wxDC)->SetFont(*theFont);
     }

-    
+

     wxCurrentDCSwitcher switcher(m_MGLDC);
     if ( !wxConstCast(this, wxDC)->SelectMGLFont() ) return;
 
     if ( x )
     wxCurrentDCSwitcher switcher(m_MGLDC);
     if ( !wxConstCast(this, wxDC)->SelectMGLFont() ) return;
 
     if ( x )

-        // VS: YDEV is corrent, it should *not* be XDEV, because font's are 
+        // VS: YDEV is corrent, it should *not* be XDEV, because font's are

         //     only scaled according to m_scaleY
         //     only scaled according to m_scaleY

-        *x = YDEV2LOGREL(m_MGLDC->textWidth(string.c_str()));
+        *x = YDEV2LOGREL(m_MGLDC->textWidth(string.wc_str()));

     if ( y )
         *y = YDEV2LOGREL(m_MGLDC->textHeight());
     if ( descent )
     if ( y )
         *y = YDEV2LOGREL(m_MGLDC->textHeight());
     if ( descent )


@@ -1253,7 +1250,6 @@ void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
 }
 
 
 }
 
 

-

 // ---------------------------------------------------------------------------
 // mapping modes
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // mapping modes
 // ---------------------------------------------------------------------------


@@ -1262,125 +1258,17 @@ void wxDC::ComputeScaleAndOrigin()
 {
     double newX = m_logicalScaleX * m_userScaleX;
     double newY = m_logicalScaleY * m_userScaleY;
 {
     double newX = m_logicalScaleX * m_userScaleX;
     double newY = m_logicalScaleY * m_userScaleY;

-    
+

     // make sure font will be reloaded before drawing:
     if ( newY != m_scaleY )
         m_mglFont = NULL;
     // make sure m_penOfs{X,Y} will be reevaluated before drawing:
     if ( newY != m_scaleY || newX != m_scaleX )
     // make sure font will be reloaded before drawing:
     if ( newY != m_scaleY )
         m_mglFont = NULL;
     // make sure m_penOfs{X,Y} will be reevaluated before drawing:
     if ( newY != m_scaleY || newX != m_scaleX )

-        m_penSelected = FALSE;
-    
-    m_scaleX = newX, m_scaleY = newY;
-}
-
-void wxDC::SetMapMode(int mode)
-{
-    switch (mode)
-    {
-        case wxMM_TWIPS:
-          SetLogicalScale(twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y);
-          break;
-        case wxMM_POINTS:
-          SetLogicalScale(pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y);
-          break;
-        case wxMM_METRIC:
-          SetLogicalScale(m_mm_to_pix_x, m_mm_to_pix_y);
-          break;
-        case wxMM_LOMETRIC:
-          SetLogicalScale(m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0);
-          break;
-        default:
-        case wxMM_TEXT:
-          SetLogicalScale(1.0, 1.0);
-          break;
-    }
-    m_mappingMode = mode;
-}
-
-void wxDC::SetUserScale( double x, double y )
-{
-    // allow negative ? -> no
-    m_userScaleX = x;
-    m_userScaleY = y;
-    ComputeScaleAndOrigin();
-}
-
-void wxDC::SetLogicalScale( double x, double y )
-{
-    // allow negative ?
-    m_logicalScaleX = x;
-    m_logicalScaleY = y;
-    ComputeScaleAndOrigin();
-}
+        m_penSelected = false;

 
 

-void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
-{
-    m_logicalOriginX = x * m_signX;   // is this still correct ?
-    m_logicalOriginY = y * m_signY;
-    ComputeScaleAndOrigin();
-}
-
-void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
-{
-    // only wxPostScripDC has m_signX = -1, we override SetDeviceOrigin there
-    m_deviceOriginX = x;
-    m_deviceOriginY = y;
-    ComputeScaleAndOrigin();
-}
-
-void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
-{
-    // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
-    m_signX = (xLeftRight ?  1 : -1);
-    m_signY = (yBottomUp  ? -1 :  1);
-    ComputeScaleAndOrigin();
-}
-
-// ---------------------------------------------------------------------------
-// coordinates transformations
-// ---------------------------------------------------------------------------
-
-wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
-{
-    return ((wxDC *)this)->XDEV2LOG(x);
-}
-
-wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
-{
-    return ((wxDC *)this)->YDEV2LOG(y);
-}
-
-wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
-{
-    return ((wxDC *)this)->XDEV2LOGREL(x);
-}
-
-wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
-{
-    return ((wxDC *)this)->YDEV2LOGREL(y);
-}
-
-wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
-{
-    return ((wxDC *)this)->XLOG2DEV(x);
-}
-
-wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
-{
-    return ((wxDC *)this)->YLOG2DEV(y);
-}
-
-wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
-{
-    return ((wxDC *)this)->XLOG2DEVREL(x);
-}
-
-wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
-{
-    return ((wxDC *)this)->YLOG2DEVREL(y);
+    m_scaleX = newX, m_scaleY = newY;

 }
 
 }
 

-

 void wxDC::DoGetSize(int *w, int *h) const
 {
     if (w) *w = m_MGLDC->sizex()+1;
 void wxDC::DoGetSize(int *w, int *h) const
 {
     if (w) *w = m_MGLDC->sizex()+1;


@@ -1398,7 +1286,7 @@ void wxDC::DoGetSizeMM(int *width, int *height) const
 
 wxSize wxDC::GetPPI() const
 {
 
 wxSize wxDC::GetPPI() const
 {

-    return wxSize(int(double(m_mm_to_pix_x) * inches2mm), 
+    return wxSize(int(double(m_mm_to_pix_x) * inches2mm),

                   int(double(m_mm_to_pix_y) * inches2mm));
 }
 
                   int(double(m_mm_to_pix_y) * inches2mm));
 }
 


@@ -1410,12 +1298,12 @@ wxSize wxDC::GetPPI() const
 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
                   wxCoord width, wxCoord height,
                   wxDC *source, wxCoord xsrc, wxCoord ysrc,
 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
                   wxCoord width, wxCoord height,
                   wxDC *source, wxCoord xsrc, wxCoord ysrc,

-                  int rop, bool useMask,
+                  wxRasterOperationMode rop, bool useMask,

                   wxCoord xsrcMask, wxCoord ysrcMask)
 {
                   wxCoord xsrcMask, wxCoord ysrcMask)
 {

-    wxCHECK_MSG( Ok(), FALSE, wxT("invalid dc") );
-    wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
-    
+    wxCHECK_MSG( Ok(), false, wxT("invalid dc") );
+    wxCHECK_MSG( source, false, wxT("invalid source dc") );
+

     // transform the source DC coords to the device ones
     xsrc = source->LogicalToDeviceX(xsrc);
     ysrc = source->LogicalToDeviceY(ysrc);
     // transform the source DC coords to the device ones
     xsrc = source->LogicalToDeviceX(xsrc);
     ysrc = source->LogicalToDeviceY(ysrc);


@@ -1437,24 +1325,26 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
     /* scale/translate size and position */
     wxCoord xx = XLOG2DEV(xdest);
     wxCoord yy = YLOG2DEV(ydest);
     /* scale/translate size and position */
     wxCoord xx = XLOG2DEV(xdest);
     wxCoord yy = YLOG2DEV(ydest);

-    wxCoord ww = XLOG2DEVREL(width);
-    wxCoord hh = YLOG2DEVREL(height);

 
     if ( source->m_isMemDC )
     {
         wxMemoryDC *memDC = (wxMemoryDC*) source;
 
     if ( source->m_isMemDC )
     {
         wxMemoryDC *memDC = (wxMemoryDC*) source;

-        DoDrawSubBitmap(memDC->GetSelectedObject(), xsrc, ysrc, ww, hh,
+        DoDrawSubBitmap(memDC->GetSelectedObject(),
+                        xsrc, ysrc, width, height,

                         xdest, ydest, rop, useMask);
     }
     else
     {
                         xdest, ydest, rop, useMask);
     }
     else
     {

+        wxCoord ww = XLOG2DEVREL(width);
+        wxCoord hh = YLOG2DEVREL(height);
+

         m_MGLDC->makeCurrent(); // will go away with MGL6.0
         m_MGLDC->makeCurrent(); // will go away with MGL6.0

-        m_MGLDC->bitBlt(*source->GetMGLDC(), 
+        m_MGLDC->bitBlt(*source->GetMGLDC(),

                         xsrc, ysrc, xsrc + ww, ysrc + hh,
                         xx, yy, LogicalFunctionToMGLRop(rop));
     }
 
                         xsrc, ysrc, xsrc + ww, ysrc + hh,
                         xx, yy, LogicalFunctionToMGLRop(rop));
     }
 

-    return TRUE;
+    return true;

 }
 
 void wxDC::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask)
 }
 
 void wxDC::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask)


@@ -1471,13 +1361,13 @@ void wxDC::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask)
 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 {
     // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 {
     // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why

-    DoDrawBitmap((const wxBitmap&)icon, x, y, (bool)TRUE);
+    DoDrawBitmap((const wxBitmap&)icon, x, y, true);

 }
 
 
 static inline void DoBitBlt(const wxBitmap& src, MGLDevCtx *dst,
 }
 
 
 static inline void DoBitBlt(const wxBitmap& src, MGLDevCtx *dst,

-                            int sx, int sy, int sw, int sh, 
-                            int dx, int dy, int dw, int dh, 
+                            int sx, int sy, int sw, int sh,
+                            int dx, int dy, int dw, int dh,

                             int rop, bool useStretching, bool putSection)
 {
     bitmap_t *bmp = src.GetMGLbitmap_t();
                             int rop, bool useStretching, bool putSection)
 {
     bitmap_t *bmp = src.GetMGLbitmap_t();


@@ -1493,12 +1383,12 @@ static inline void DoBitBlt(const wxBitmap& src, MGLDevCtx *dst,
         if (!putSection)
             dst->stretchBitmap(dx, dy, dx + dw, dy + dh, bmp, rop);
         else
         if (!putSection)
             dst->stretchBitmap(dx, dy, dx + dw, dy + dh, bmp, rop);
         else

-            dst->stretchBitmapSection(sx, sy, sx + sw, sy + sh, 
+            dst->stretchBitmapSection(sx, sy, sx + sw, sy + sh,

                                       dx, dy, dx + dw, dy + dh, bmp, rop);
     }
 }
 
                                       dx, dy, dx + dw, dy + dh, bmp, rop);
     }
 }
 

-void wxDC::DoDrawSubBitmap(const wxBitmap &bmp, 
+void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,

                            wxCoord x, wxCoord y, wxCoord w, wxCoord h,
                            wxCoord destx, wxCoord desty, int rop, bool useMask)
 {
                            wxCoord x, wxCoord y, wxCoord w, wxCoord h,
                            wxCoord destx, wxCoord desty, int rop, bool useMask)
 {


@@ -1512,9 +1402,9 @@ void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,
     wxCoord dy = YLOG2DEV(desty);
     wxCoord dw = XLOG2DEVREL(w);
     wxCoord dh = YLOG2DEVREL(h);
     wxCoord dy = YLOG2DEV(desty);
     wxCoord dw = XLOG2DEVREL(w);
     wxCoord dh = YLOG2DEVREL(h);

-    
+

     m_MGLDC->makeCurrent(); // will go away with MGL6.0
     m_MGLDC->makeCurrent(); // will go away with MGL6.0

-    
+

     bool useStretching = ((w != dw) || (h != dh));
     bool putSection = (w != bmp.GetWidth() || h != bmp.GetHeight());
     MGL_writeModeType mglRop = (MGL_writeModeType)LogicalFunctionToMGLRop(rop);
     bool useStretching = ((w != dw) || (h != dh));
     bool putSection = (w != bmp.GetWidth() || h != bmp.GetHeight());
     MGL_writeModeType mglRop = (MGL_writeModeType)LogicalFunctionToMGLRop(rop);


@@ -1530,34 +1420,34 @@ void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,
     if ( useMask && bmp.GetMask() )
     {
         // Since MGL does not support masks directly (in MGL, mask is handled
     if ( useMask && bmp.GetMask() )
     {
         // Since MGL does not support masks directly (in MGL, mask is handled

-        // in same way as in wxImage, i.e. there is one "key" color), we 
+        // in same way as in wxImage, i.e. there is one "key" color), we

         // simulate masked bitblt in 6 steps (same as in MSW):
         //
         // simulate masked bitblt in 6 steps (same as in MSW):
         //

-        // 1. Create a temporary bitmap and copy the destination area into it. 
-        // 2. Copy the source area into the temporary bitmap using the 
+        // 1. Create a temporary bitmap and copy the destination area into it.
+        // 2. Copy the source area into the temporary bitmap using the

         //    specified logical function.
         //    specified logical function.

-        // 3. Set the masked area in the temporary bitmap to BLACK by ANDing 
-        //    the mask bitmap with the temp bitmap with the foreground colour 
+        // 3. Set the masked area in the temporary bitmap to BLACK by ANDing
+        //    the mask bitmap with the temp bitmap with the foreground colour

         //    set to WHITE and the bg colour set to BLACK.
         // 4. Set the unmasked area in the destination area to BLACK by
         //    set to WHITE and the bg colour set to BLACK.
         // 4. Set the unmasked area in the destination area to BLACK by

-        //    ANDing the mask bitmap with the destination area with the 
+        //    ANDing the mask bitmap with the destination area with the

         //    foreground colour set to BLACK and the background colour set
         //    foreground colour set to BLACK and the background colour set

-        //    to WHITE.  
-        // 5. OR the temporary bitmap with the destination area.  
-        // 6. Delete the temporary bitmap. 
-        // 
-        // This sequence of operations ensures that the source's transparent 
+        //    to WHITE.
+        // 5. OR the temporary bitmap with the destination area.
+        // 6. Delete the temporary bitmap.
+        //
+        // This sequence of operations ensures that the source's transparent

         // area need not be black, and logical functions are supported.
 
         // area need not be black, and logical functions are supported.
 

-        wxBitmap *mask = bmp.GetMask()->GetBitmap();
+        wxBitmap mask = bmp.GetMask()->GetBitmap();

 
         MGLMemoryDC *temp;
 
         MGLMemoryDC *temp;

-        
+

         if ( GetDepth() <= 8 )
         {
             temp = new MGLMemoryDC(dw, dh, GetDepth(), NULL);
             wxDC tempdc;
         if ( GetDepth() <= 8 )
         {
             temp = new MGLMemoryDC(dw, dh, GetDepth(), NULL);
             wxDC tempdc;

-            tempdc.SetMGLDC(temp, FALSE);
+            tempdc.SetMGLDC(temp, false);

             tempdc.SetPalette(m_palette);
         }
         else
             tempdc.SetPalette(m_palette);
         }
         else


@@ -1566,28 +1456,28 @@ void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,
             m_MGLDC->getPixelFormat(pf);
             temp = new MGLMemoryDC(dw, dh, GetDepth(), &pf);
         }
             m_MGLDC->getPixelFormat(pf);
             temp = new MGLMemoryDC(dw, dh, GetDepth(), &pf);
         }

-        
+

         wxCHECK_RET( temp->isValid(), wxT("cannot create temporary dc") );
         wxCHECK_RET( temp->isValid(), wxT("cannot create temporary dc") );

-        
+

         temp->bitBlt(*m_MGLDC, dx, dy, dx + dw, dy + dh, 0, 0, MGL_REPLACE_MODE);
 
         temp->bitBlt(*m_MGLDC, dx, dy, dx + dw, dy + dh, 0, 0, MGL_REPLACE_MODE);
 

-        DoBitBlt(bmp, temp, x, y, w, h, 0, 0, dw, dh, mglRop, 
+        DoBitBlt(bmp, temp, x, y, w, h, 0, 0, dw, dh, mglRop,

                  useStretching, putSection);
 
                  useStretching, putSection);
 

-        mask->SetMonoPalette(wxColour(0,0,0), wxColour(255,255,255));
-        DoBitBlt(*mask, temp, x, y, w, h, 0, 0, dw, dh, MGL_R2_MASKSRC, 
+        mask.SetMonoPalette(wxColour(0,0,0), wxColour(255,255,255));
+        DoBitBlt(mask, temp, x, y, w, h, 0, 0, dw, dh, MGL_R2_MASKSRC,

                  useStretching, putSection);
                  useStretching, putSection);

-        DoBitBlt(*mask, m_MGLDC, x, y, w, h, dx, dy, dw, dh, MGL_R2_MASKNOTSRC, 
+        DoBitBlt(mask, m_MGLDC, x, y, w, h, dx, dy, dw, dh, MGL_R2_MASKNOTSRC,

                  useStretching, putSection);
 
         m_MGLDC->bitBlt(*temp, 0, 0, dw, dh, dx, dy, MGL_OR_MODE);
                  useStretching, putSection);
 
         m_MGLDC->bitBlt(*temp, 0, 0, dw, dh, dx, dy, MGL_OR_MODE);

-        
+

         delete temp;
     }
         delete temp;
     }

-    
+

     else
     {
     else
     {

-        DoBitBlt(bmp, m_MGLDC, x, y, w, h, dx, dy, dw, dh, mglRop, 
+        DoBitBlt(bmp, m_MGLDC, x, y, w, h, dx, dy, dw, dh, mglRop,

                  useStretching, putSection);
     }
 }
                  useStretching, putSection);
     }
 }