add wxUSE_DATAVIEWCTRL check to fix a hundred compilation errors

[wxWidgets.git] / src / x11 / dcclient.cpp

diff --git a/src/x11/dcclient.cpp b/src/x11/dcclient.cpp
index d3601d5985504122367f9d03170b5573d14bfa99..5e19609f432b31023289f3c3ed8faed5de0a48b1 100644 (file)
--- a/src/x11/dcclient.cpp
+++ b/src/x11/dcclient.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        x11/dcclient.cpp
+// Name:        src/x11/dcclient.cpp

 // Purpose:     wxClientDC class
 // Author:      Julian Smart, Robert Roebling
 // Modified by:
 // Purpose:     wxClientDC class
 // Author:      Julian Smart, Robert Roebling
 // Modified by:


@@ -9,26 +9,30 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "dcclient.h"
-#endif
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"

 
 #include "wx/dcclient.h"
 
 #include "wx/dcclient.h"

-#include "wx/dcmemory.h"
-#include "wx/window.h"
-#include "wx/app.h"
-#include "wx/image.h"
-#include "wx/module.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/app.h"
+    #include "wx/window.h"
+    #include "wx/dcmemory.h"
+    #include "wx/math.h"
+    #include "wx/image.h"
+    #include "wx/module.h"
+#endif
+

 #include "wx/fontutil.h"
 
 #include "wx/x11/private.h"
 
 #include "wx/fontutil.h"
 
 #include "wx/x11/private.h"
 

-#include <math.h>
-

 #if wxUSE_UNICODE
 #include "glib.h"
 #include "pango/pangox.h"
 #if wxUSE_UNICODE
 #include "glib.h"
 #include "pango/pangox.h"

-#include "pango/pangoxft.h"
+#ifdef HAVE_PANGO_XFT
+    #include "pango/pangoxft.h"
+#endif

 
 #include "pango_x.cpp"
 #endif
 
 #include "pango_x.cpp"
 #endif


@@ -37,7 +41,8 @@
 // local defines
 //-----------------------------------------------------------------------------
 
 // local defines
 //-----------------------------------------------------------------------------
 

-#define USE_PAINT_REGION 1
+// VZ: what is this for exactly??
+#define USE_PAINT_REGION 0

 
 //-----------------------------------------------------------------------------
 // local data
 
 //-----------------------------------------------------------------------------
 // local data


@@ -127,11 +132,11 @@ static GC wxGetPoolGC( Window window, wxPoolGCType type )
             wxGCPool[i].m_gc = XCreateGC( wxGlobalDisplay(), window, 0, NULL );
             XSetGraphicsExposures( wxGlobalDisplay(), wxGCPool[i].m_gc, FALSE );
             wxGCPool[i].m_type = type;
             wxGCPool[i].m_gc = XCreateGC( wxGlobalDisplay(), window, 0, NULL );
             XSetGraphicsExposures( wxGlobalDisplay(), wxGCPool[i].m_gc, FALSE );
             wxGCPool[i].m_type = type;

-            wxGCPool[i].m_used = FALSE;
+            wxGCPool[i].m_used = false;

         }
         if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
         {
         }
         if ((!wxGCPool[i].m_used) && (wxGCPool[i].m_type == type))
         {

-            wxGCPool[i].m_used = TRUE;
+            wxGCPool[i].m_used = true;

             return wxGCPool[i].m_gc;
         }
     }
             return wxGCPool[i].m_gc;
         }
     }


@@ -147,7 +152,7 @@ static void wxFreePoolGC( GC gc )
     {
         if (wxGCPool[i].m_gc == gc)
         {
     {
         if (wxGCPool[i].m_gc == gc)
         {

-            wxGCPool[i].m_used = FALSE;
+            wxGCPool[i].m_used = false;

             return;
         }
     }
             return;
         }
     }


@@ -161,7 +166,7 @@ static void wxFreePoolGC( GC gc )
 
 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
 

-wxWindowDC::wxWindowDC()
+void wxWindowDC::Init()

 {
     m_display = (WXDisplay *) NULL;
     m_penGC = (WXGC *) NULL;
 {
     m_display = (WXDisplay *) NULL;
     m_penGC = (WXGC *) NULL;


@@ -169,12 +174,12 @@ wxWindowDC::wxWindowDC()
     m_textGC = (WXGC *) NULL;
     m_bgGC = (WXGC *) NULL;
     m_cmap = (WXColormap *) NULL;
     m_textGC = (WXGC *) NULL;
     m_bgGC = (WXGC *) NULL;
     m_cmap = (WXColormap *) NULL;

-    m_isMemDC = FALSE;
-    m_isScreenDC = FALSE;
+    m_isMemDC = false;
+    m_isScreenDC = false;

     m_owner = (wxWindow *)NULL;
     m_owner = (wxWindow *)NULL;

-    
+

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-    m_context = (PangoContext *)NULL;
+    m_context = wxTheApp->GetPangoContext();

     m_fontdesc = (PangoFontDescription *)NULL;
 #endif
 }
     m_fontdesc = (PangoFontDescription *)NULL;
 #endif
 }


@@ -183,15 +188,8 @@ wxWindowDC::wxWindowDC( wxWindow *window )
 {
     wxASSERT_MSG( window, wxT("DC needs a window") );
 
 {
     wxASSERT_MSG( window, wxT("DC needs a window") );
 

-    m_display = (WXDisplay *) NULL;
-    m_penGC = (WXGC *) NULL;
-    m_brushGC = (WXGC *) NULL;
-    m_textGC = (WXGC *) NULL;
-    m_bgGC = (WXGC *) NULL;
-    m_cmap = (WXColormap *) NULL;
-    m_owner = (wxWindow *)NULL;
-    m_isMemDC = FALSE;
-    m_isScreenDC = FALSE;
+    Init();
+

     m_font = window->GetFont();
 
     m_window = (WXWindow*) window->GetMainWindow();
     m_font = window->GetFont();
 
     m_window = (WXWindow*) window->GetMainWindow();


@@ -200,15 +198,14 @@ wxWindowDC::wxWindowDC( wxWindow *window )
     if (!m_window)
     {
          // don't report problems
     if (!m_window)
     {
          // don't report problems

-         m_ok = TRUE;
+         m_ok = true;

 
          return;
     }
 
     m_display = (WXDisplay *) wxGlobalDisplay();
 
          return;
     }
 
     m_display = (WXDisplay *) wxGlobalDisplay();

-    
+

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-    m_context = wxTheApp->GetPangoContext();

     m_fontdesc = window->GetFont().GetNativeFontInfo()->description;
 #endif
 
     m_fontdesc = window->GetFont().GetNativeFontInfo()->description;
 #endif
 


@@ -234,7 +231,7 @@ wxWindowDC::~wxWindowDC()
 
 void wxWindowDC::SetUpDC()
 {
 
 void wxWindowDC::SetUpDC()
 {

-    m_ok = TRUE;
+    m_ok = true;

 
     wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
 
 
     wxASSERT_MSG( !m_penGC, wxT("GCs already created") );
 


@@ -266,6 +263,9 @@ void wxWindowDC::SetUpDC()
     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
     unsigned long bg_col = m_backgroundBrush.GetColour().GetPixel();
 
     m_backgroundBrush.GetColour().CalcPixel( m_cmap );
     unsigned long bg_col = m_backgroundBrush.GetColour().GetPixel();
 

+    m_textForegroundColour = *wxBLACK;
+    m_textBackgroundColour = *wxWHITE;
+

     /* m_textGC */
     m_textForegroundColour.CalcPixel( m_cmap );
     XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );
     /* m_textGC */
     m_textForegroundColour.CalcPixel( m_cmap );
     XSetForeground( (Display*) m_display, (GC) m_textGC, m_textForegroundColour.GetPixel() );


@@ -297,7 +297,7 @@ void wxWindowDC::SetUpDC()
     /* m_bgGC */
     XSetForeground( (Display*) m_display, (GC) m_bgGC, bg_col );
     XSetBackground( (Display*) m_display, (GC) m_bgGC, bg_col );
     /* m_bgGC */
     XSetForeground( (Display*) m_display, (GC) m_bgGC, bg_col );
     XSetBackground( (Display*) m_display, (GC) m_bgGC, bg_col );

-    
+

     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
 
     /* ROPs */
     XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillSolid );
 
     /* ROPs */


@@ -315,7 +315,7 @@ void wxWindowDC::SetUpDC()
     {
         int xscreen = DefaultScreen( (Display*) m_display );
         Window xroot = RootWindow( (Display*) m_display, xscreen );
     {
         int xscreen = DefaultScreen( (Display*) m_display );
         Window xroot = RootWindow( (Display*) m_display, xscreen );

-    
+

         hatch_bitmap    = hatches;
         hatch_bitmap[0] = XCreateBitmapFromData( (Display*) m_display, xroot, bdiag_bits, bdiag_width, bdiag_height );
         hatch_bitmap[1] = XCreateBitmapFromData( (Display*) m_display, xroot, cdiag_bits, cdiag_width, cdiag_height );
         hatch_bitmap    = hatches;
         hatch_bitmap[0] = XCreateBitmapFromData( (Display*) m_display, xroot, bdiag_bits, bdiag_width, bdiag_height );
         hatch_bitmap[1] = XCreateBitmapFromData( (Display*) m_display, xroot, cdiag_bits, cdiag_width, cdiag_height );


@@ -333,7 +333,7 @@ void wxWindowDC::DoGetSize( int* width, int* height ) const
     m_owner->GetSize(width, height);
 }
 
     m_owner->GetSize(width, height);
 }
 

-extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y, 
+extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,

                           const wxColour & col, int style);
 
 bool wxWindowDC::DoFloodFill(wxCoord x, wxCoord y,
                           const wxColour & col, int style);
 
 bool wxWindowDC::DoFloodFill(wxCoord x, wxCoord y,


@@ -353,7 +353,7 @@ bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
     memdc.SelectObject(wxNullBitmap);
     wxImage image(bitmap.ConvertToImage());
     col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));
     memdc.SelectObject(wxNullBitmap);
     wxImage image(bitmap.ConvertToImage());
     col->Set(image.GetRed(0, 0), image.GetGreen(0, 0), image.GetBlue(0, 0));

-    return TRUE;
+    return true;

 }
 
 void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 }
 
 void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )


@@ -372,8 +372,8 @@ void wxWindowDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
             points[1].x = x2;
             points[1].y = y2;
             DrawLines( 2, points, 0, 0 );
             points[1].x = x2;
             points[1].y = y2;
             DrawLines( 2, points, 0, 0 );

-            
-            // XDrawLine( (Display*) m_display, (Window) m_window, 
+
+            // XDrawLine( (Display*) m_display, (Window) m_window,

             //    (GC) m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
         }
 
             //    (GC) m_penGC, XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2) );
         }
 


@@ -452,30 +452,30 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                                      
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-                    
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                                      
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-                    
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -483,10 +483,10 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                                      
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-                    
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else


@@ -500,10 +500,10 @@ void wxWindowDC::DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCo
         {
             XDrawArc( (Display*) m_display, (Window) m_window,
                (GC) m_penGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );
         {
             XDrawArc( (Display*) m_display, (Window) m_window,
                (GC) m_penGC, xxc-r, yyc-r, 2*r,2*r, alpha1, alpha2 );

-               
+

             XDrawLine( (Display*) m_display, (Window) m_window,
                (GC) m_penGC, xx1, yy1, xxc, yyc );
             XDrawLine( (Display*) m_display, (Window) m_window,
                (GC) m_penGC, xx1, yy1, xxc, yyc );

-               
+

             XDrawLine( (Display*) m_display, (Window) m_window,
                (GC) m_penGC, xxc, yyc, xx2, yy2 );
         }
             XDrawLine( (Display*) m_display, (Window) m_window,
                (GC) m_penGC, xxc, yyc, xx2, yy2 );
         }


@@ -538,30 +538,30 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, xx, yy, ww, hh, start, end );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, xx, yy, ww, hh, start, end );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -569,10 +569,10 @@ void wxWindowDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, start, end );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else


@@ -616,7 +616,7 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord
     {
         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
     {
         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);

-        
+

         CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
     }
     XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n, 0 );
         CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset );
     }
     XDrawLines( (Display*) m_display, (Window) m_window, (GC) m_penGC, xpoints, n, 0 );


@@ -625,7 +625,8 @@ void wxWindowDC::DoDrawLines( int n, wxPoint points[], wxCoord xoffset, wxCoord
 }
 
 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
 }
 
 void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],

-                                wxCoord xoffset, wxCoord yoffset, int fillStyle )
+                                wxCoord xoffset, wxCoord yoffset,
+                                int WXUNUSED(fillStyle) )

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


@@ -637,7 +638,7 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
     {
         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
     {
         xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
         xpoints[i].y = YLOG2DEV (points[i].y + yoffset);

-        
+

         CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
     }
 
         CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
     }
 


@@ -645,36 +646,36 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {
     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {

-        
+

             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
+

                 XFillPolygon( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, xpoints, n, Complex, 0);
                 XFillPolygon( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, xpoints, n, Complex, 0);

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                
+

                 XFillPolygon( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xpoints, n, Complex, 0);
                 XFillPolygon( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xpoints, n, Complex, 0);

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
+

                 XFillPolygon( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xpoints, n, Complex, 0);
                 XFillPolygon( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xpoints, n, Complex, 0);

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -682,10 +683,10 @@ void wxWindowDC::DoDrawPolygon( int n, wxPoint points[],
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
+

                 XFillPolygon( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xpoints, n, Complex, 0);
                 XFillPolygon( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xpoints, n, Complex, 0);

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else


@@ -723,7 +724,7 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
     // CMB: handle -ve width and/or height
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }
     // CMB: handle -ve width and/or height
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }

-    
+

     if (m_window)
     {
         if (m_brush.GetStyle() != wxTRANSPARENT)
     if (m_window)
     {
         if (m_brush.GetStyle() != wxTRANSPARENT)


@@ -733,30 +734,30 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
+

                 XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, xx, yy, ww, hh );
                 XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, xx, yy, ww, hh );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                
+

                 XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh );
                 XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
+

                 XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh );
                 XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -764,10 +765,10 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
+

                 XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh );
                 XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else


@@ -791,19 +792,19 @@ void wxWindowDC::DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord h
 void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
 {
     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius )
 {
     wxCHECK_RET( Ok(), wxT("invalid window dc") );

-                                                                                                                  
+

     if (radius < 0.0) radius = - radius * ((width < height) ? width : height);
     if (radius < 0.0) radius = - radius * ((width < height) ? width : height);

-                                                                                                                  
+

     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);
     wxCoord ww = m_signX * XLOG2DEVREL(width);
     wxCoord hh = m_signY * YLOG2DEVREL(height);
     wxCoord rr = XLOG2DEVREL((wxCoord)radius);
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);
     wxCoord ww = m_signX * XLOG2DEVREL(width);
     wxCoord hh = m_signY * YLOG2DEVREL(height);
     wxCoord rr = XLOG2DEVREL((wxCoord)radius);

-                                                                                                                  
+

     // CMB: handle -ve width and/or height
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }
     // CMB: handle -ve width and/or height
     if (ww < 0) { ww = -ww; xx = xx - ww; }
     if (hh < 0) { hh = -hh; yy = yy - hh; }

-                                                                                                                  
+

     // CMB: if radius is zero use DrawRectangle() instead to avoid
     // X drawing errors with small radii
     if (rr == 0)
     // CMB: if radius is zero use DrawRectangle() instead to avoid
     // X drawing errors with small radii
     if (rr == 0)


@@ -812,10 +813,10 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
                 (GC) m_penGC, x, y, width, height);
         return;
     }
                 (GC) m_penGC, x, y, width, height);
         return;
     }

-                                                                                                                  
+

     // CMB: draw nothing if transformed w or h is 0
     if (ww == 0 || hh == 0) return;
     // CMB: draw nothing if transformed w or h is 0
     if (ww == 0 || hh == 0) return;

-                                                                                                                  
+

     // CMB: adjust size if outline is drawn otherwise the result is
     // 1 pixel too wide and high
     if (m_pen.GetStyle() != wxTRANSPARENT)
     // CMB: adjust size if outline is drawn otherwise the result is
     // 1 pixel too wide and high
     if (m_pen.GetStyle() != wxTRANSPARENT)


@@ -823,7 +824,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
         ww--;
         hh--;
     }
         ww--;
         hh--;
     }

-    
+

     if (m_window)
     {
         // CMB: ensure dd is not larger than rectangle otherwise we
     if (m_window)
     {
         // CMB: ensure dd is not larger than rectangle otherwise we


@@ -832,13 +833,13 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
         if (dd > ww) dd = ww;
         if (dd > hh) dd = hh;
         rr = dd / 2;
         if (dd > ww) dd = ww;
         if (dd > hh) dd = hh;
         rr = dd / 2;

-                                                                                                                  
+

         if (m_brush.GetStyle() != wxTRANSPARENT)
         {
             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
             {
         if (m_brush.GetStyle() != wxTRANSPARENT)
         {
             if ((m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE) && (m_brush.GetStipple()->GetMask()))
             {

-                XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 
-                              m_deviceOriginX % m_brush.GetStipple()->GetWidth(), 
+                XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
+                              m_deviceOriginX % m_brush.GetStipple()->GetWidth(),

                               m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx+rr, yy, ww-dd+1, hh );
                 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx, yy+rr, ww, hh-dd+1 );
                               m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx+rr, yy, ww-dd+1, hh );
                 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_textGC, xx, yy+rr, ww, hh-dd+1 );


@@ -872,7 +873,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
             {
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
             {

-                XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 
+                XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,

                               m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                               m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );
                               m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                               m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XFillRectangle( (Display*) m_display, (Window) m_window, (GC) m_brushGC, xx+rr, yy, ww-dd+1, hh );


@@ -905,7 +906,7 @@ void wxWindowDC::DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wx
             XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
         }
     }
             XDrawArc( (Display*) m_display, (Window) m_window, (GC) m_penGC, xx, yy+hh-dd, dd, dd, 180*64, 90*64 );
         }
     }

-                                                                                                                  
+

     // this ignores the radius
     CalcBoundingBox( x, y );
     CalcBoundingBox( x + width, y + height );
     // this ignores the radius
     CalcBoundingBox( x, y );
     CalcBoundingBox( x + width, y + height );


@@ -933,30 +934,30 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, xx, yy, ww, hh, 0, 360*64 );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, xx, yy, ww, hh, 0, 360*64 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );
             } else
             if (IS_15_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 15, m_deviceOriginY % 15 );

-                
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (IS_16_PIX_HATCH(m_brush.GetStyle()))
             {
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % 16, m_deviceOriginY % 16 );

-                
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             } else
             if (m_brush.GetStyle() == wxSTIPPLE)


@@ -964,10 +965,10 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC,
                                       m_deviceOriginX % m_brush.GetStipple()->GetWidth(),
                                       m_deviceOriginY % m_brush.GetStipple()->GetHeight() );

-                
+

                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );
                 XFillArc( (Display*) m_display, (Window) m_window,
                     (GC) m_brushGC, xx, yy, ww, hh, 0, 360*64 );

-                
+

                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else
                 XSetTSOrigin( (Display*) m_display, (GC) m_brushGC, 0, 0 );
             }
             else


@@ -990,7 +991,7 @@ void wxWindowDC::DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord hei
 
 void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
 {
 
 void wxWindowDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
 {

-    DoDrawBitmap(icon, x, y, TRUE);
+    DoDrawBitmap(icon, x, y, true);

 }
 
 #if wxUSE_NANOX
 }
 
 #if wxUSE_NANOX


@@ -1001,7 +1002,7 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 
     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 
     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );

-    
+

     bool is_mono = (bitmap.GetBitmap() != NULL);
 
     /* scale/translate size and position */
     bool is_mono = (bitmap.GetBitmap() != NULL);
 
     /* scale/translate size and position */


@@ -1073,7 +1074,7 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, (Window) m_window,
                   0, 0, GR_MODE_COPY);
 #endif
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, (Window) m_window,
                   0, 0, GR_MODE_COPY);
 #endif

-            
+

         // Copy src to buffer using selected raster op (none selected
         // in DrawBitmap, so just use Gxcopy)
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, pixmap,
         // Copy src to buffer using selected raster op (none selected
         // in DrawBitmap, so just use Gxcopy)
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, pixmap,


@@ -1084,7 +1085,7 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
         GrSetGCForeground(gc, BLACK);
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, maskPixmap,
                     0, 0, GR_MODE_AND);
         GrSetGCForeground(gc, BLACK);
         GrCopyArea(bufPixmap, gc, 0, 0, w, h, maskPixmap,
                     0, 0, GR_MODE_AND);

-                       
+

         // set unmasked area in dest to BLACK
         GrSetGCBackground(gc, BLACK);
         GrSetGCForeground(gc, WHITE);
         // set unmasked area in dest to BLACK
         GrSetGCBackground(gc, BLACK);
         GrSetGCForeground(gc, WHITE);


@@ -1120,7 +1121,7 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 
     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
     wxCHECK_RET( Ok(), wxT("invalid window dc") );
 
     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );

-    
+

     bool is_mono = (bitmap.GetBitmap() != NULL);
 
     // scale/translate size and position
     bool is_mono = (bitmap.GetBitmap() != NULL);
 
     // scale/translate size and position


@@ -1168,63 +1169,79 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
     // apply mask if any
     WXPixmap mask = NULL;
     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
     // apply mask if any
     WXPixmap mask = NULL;
     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();

-    
-        if (useMask && mask)
+
+    bool setClipMask = false;
+
+    if (!m_currentClippingRegion.IsNull() || (useMask && mask))
+    {
+        // XSetClipMask() call is necessary (because of clip region and/or transparent mask)
+        setClipMask = true;
+        Pixmap new_pixmap = 0;
+
+        if (!m_currentClippingRegion.IsNull())

         {
         {

-            WXPixmap new_mask = NULL;
-#if 0
-            if (!m_currentClippingRegion.IsNull())
-            {
-                GdkColor col;
-                new_mask = gdk_pixmap_new( wxGetRootWindow()->window, ww, hh, 1 );
-                GdkGC *gc = gdk_gc_new( new_mask );
-                col.pixel = 0;
-                gdk_gc_set_foreground( gc, &col );
-                gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
-                col.pixel = 0;
-                gdk_gc_set_background( gc, &col );
-                col.pixel = 1;
-                gdk_gc_set_foreground( gc, &col );
-                gdk_gc_set_clip_region( gc, m_currentClippingRegion.GetRegion() );
-                gdk_gc_set_clip_origin( gc, -xx, -yy );
-                gdk_gc_set_fill( gc, GDK_OPAQUE_STIPPLED );
-                gdk_gc_set_stipple( gc, mask );
-                gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
-                gdk_gc_unref( gc );
-            }
-#endif
-            if (is_mono)
+            // clipping necessary => create new_pixmap
+            Display *xdisplay = (Display*) m_display;
+            int xscreen = DefaultScreen( xdisplay );
+            Window xroot = RootWindow( xdisplay, xscreen );
+
+            new_pixmap = XCreatePixmap( xdisplay, xroot, ww, hh, 1 );
+            GC gc = XCreateGC( xdisplay, new_pixmap, 0, NULL );
+
+            XSetForeground( xdisplay, gc, BlackPixel(xdisplay,xscreen) );
+
+            XSetFillStyle( xdisplay, gc, FillSolid );
+            XFillRectangle( xdisplay, new_pixmap, gc, 0, 0, ww, hh );
+
+            XSetForeground( xdisplay, gc, WhitePixel(xdisplay,xscreen) );
+
+            if (useMask && mask)

             {
             {

-                if (new_mask)
-                    XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) new_mask );
-                else
-                    XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) mask );
-                XSetClipOrigin( (Display*) m_display, (GC) m_textGC, xx, yy );
+                // transparent mask => call XSetStipple
+                XSetFillStyle( xdisplay, gc, FillStippled );
+                XSetTSOrigin( xdisplay, gc, 0, 0);
+                XSetStipple( xdisplay, gc, (Pixmap) mask);

             }
             }

+
+            wxCoord clip_x, clip_y, clip_w, clip_h;
+            m_currentClippingRegion.GetBox(clip_x, clip_y, clip_w, clip_h);
+            XFillRectangle( xdisplay, new_pixmap, gc, clip_x-xx, clip_y-yy, clip_w, clip_h );
+
+            XFreeGC( xdisplay, gc );
+        }
+
+        if (is_mono)
+        {
+            if (new_pixmap)
+                XSetClipMask( (Display*) m_display, (GC) m_textGC, new_pixmap );

             else
             else

-            {
-                if (new_mask)
-                    XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) new_mask );
-                else
-                    XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
-                XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );
-            }
-            
-            if (new_mask)
-               XFreePixmap( (Display*) m_display, (Pixmap) new_mask );
+                XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) mask );
+            XSetClipOrigin( (Display*) m_display, (GC) m_textGC, xx, yy );
+        }
+        else
+        {
+            if (new_pixmap)
+                XSetClipMask( (Display*) m_display, (GC) m_penGC, new_pixmap );
+            else
+                XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
+            XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );

         }
 
         }
 

+        if (new_pixmap)
+            XFreePixmap( (Display*) m_display, new_pixmap );
+    }
+

     // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
     // drawing a mono-bitmap (XBitmap) we use the current text GC
     if (is_mono)
         XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_window,
     // Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
     // drawing a mono-bitmap (XBitmap) we use the current text GC
     if (is_mono)
         XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_window,

-            (GC) m_textGC, 0, 0, w, h, xx, yy, 1 );
+            (GC) m_textGC, 0, 0, ww, hh, xx, yy, 1 );

     else
         XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,
     else
         XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,

-            (GC) m_penGC, 0, 0, w, h, xx, yy );
+            (GC) m_penGC, 0, 0, ww, hh, xx, yy );

 
     // remove mask again if any
 
     // remove mask again if any

-    if (useMask && mask)
+    if (setClipMask)

     {
         if (is_mono)
         {
     {
         if (is_mono)
         {


@@ -1254,32 +1271,32 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
       of the source dc, but scales correctly on the target dc and
       knows about possible mask information in a memory dc. */
 
       of the source dc, but scales correctly on the target dc and
       knows about possible mask information in a memory dc. */
 

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

 
 

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

 
 

-    if (!m_window) return FALSE;
+    if (!m_window) return false;

 
     // transform the source DC coords to the device ones
 
     // transform the source DC coords to the device ones

-    xsrc = source->XLOG2DEV(xsrc);
-    ysrc = source->YLOG2DEV(ysrc);
+    xsrc = source->LogicalToDeviceX(xsrc);
+    ysrc = source->LogicalToDeviceY(ysrc);

 
     wxClientDC *srcDC = (wxClientDC*)source;
     wxMemoryDC *memDC = (wxMemoryDC*)source;
 
 
     wxClientDC *srcDC = (wxClientDC*)source;
     wxMemoryDC *memDC = (wxMemoryDC*)source;
 

-    bool use_bitmap_method = FALSE;
-    bool is_mono = FALSE;
+    bool use_bitmap_method = false;
+    bool is_mono = false;

 
 

-    // TODO: use the mask origin when drawing transparently 
+    // TODO: use the mask origin when drawing transparently

     if (xsrcMask == -1 && ysrcMask == -1)
     {
         xsrcMask = xsrc;
         ysrcMask = ysrc;
     }
     if (xsrcMask == -1 && ysrcMask == -1)
     {
         xsrcMask = xsrc;
         ysrcMask = ysrc;
     }

-    
+

     if (srcDC->m_isMemDC)
     {
     if (srcDC->m_isMemDC)
     {

-        if (!memDC->m_selected.Ok()) return FALSE;
+        if (!memDC->m_selected.Ok()) return false;

 
         /* we use the "XCopyArea" way to copy a memory dc into
            y different window if the memory dc BOTH
 
         /* we use the "XCopyArea" way to copy a memory dc into
            y different window if the memory dc BOTH


@@ -1292,15 +1309,15 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
            /* we HAVE TO use the direct way for memory dcs
               that have mask since the XCopyArea doesn't know
               about masks */
            /* we HAVE TO use the direct way for memory dcs
               that have mask since the XCopyArea doesn't know
               about masks */

-            use_bitmap_method = TRUE;
+            use_bitmap_method = true;

         }
         else if (memDC->m_selected.GetDepth() == 1)
         {
            /* we HAVE TO use the direct way for memory dcs
               that are bitmaps because XCopyArea doesn't cope
               with different bit depths */
         }
         else if (memDC->m_selected.GetDepth() == 1)
         {
            /* we HAVE TO use the direct way for memory dcs
               that are bitmaps because XCopyArea doesn't cope
               with different bit depths */

-            is_mono = TRUE;
-            use_bitmap_method = TRUE;
+            is_mono = true;
+            use_bitmap_method = true;

         }
         else if ((xsrc == 0) && (ysrc == 0) &&
                  (width == memDC->m_selected.GetWidth()) &&
         }
         else if ((xsrc == 0) && (ysrc == 0) &&
                  (width == memDC->m_selected.GetWidth()) &&


@@ -1310,11 +1327,11 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
               in the memory dc is copied in which case XCopyArea
               wouldn't be able able to boost performace by reducing
               the area to be scaled */
               in the memory dc is copied in which case XCopyArea
               wouldn't be able able to boost performace by reducing
               the area to be scaled */

-            use_bitmap_method = TRUE;
+            use_bitmap_method = true;

         }
         else
         {
         }
         else
         {

-            use_bitmap_method = FALSE;
+            use_bitmap_method = false;

         }
     }
 
         }
     }
 


@@ -1334,7 +1351,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
         wxRegion tmp( xx,yy,ww,hh );
         tmp.Intersect( m_currentClippingRegion );
         if (tmp.IsEmpty())
         wxRegion tmp( xx,yy,ww,hh );
         tmp.Intersect( m_currentClippingRegion );
         if (tmp.IsEmpty())

-            return TRUE;
+            return true;

     }
 
     int old_logical_func = m_logicalFunction;
     }
 
     int old_logical_func = m_logicalFunction;


@@ -1413,7 +1430,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
                     XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
                 XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );
             }
                     XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
                 XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );
             }

-            
+

             if (new_mask)
                XFreePixmap( (Display*) m_display, (Pixmap) new_mask );
         }
             if (new_mask)
                XFreePixmap( (Display*) m_display, (Pixmap) new_mask );
         }


@@ -1480,7 +1497,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
             bitmap = image;
 
             // draw scaled bitmap
             bitmap = image;
 
             // draw scaled bitmap

-            XCopyArea( (Display*) m_display, (Window) bitmap.GetPixmap(), (Window) m_window, 
+            XCopyArea( (Display*) m_display, (Window) bitmap.GetPixmap(), (Window) m_window,

                        (GC) m_penGC, 0, 0, width, height, xx, yy );
         }
         else
                        (GC) m_penGC, 0, 0, width, height, xx, yy );
         }
         else


@@ -1489,15 +1506,15 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
 
             // copy including child window contents
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );
 
             // copy including child window contents
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );

-            XCopyArea( (Display*) m_display, (Window) srcDC->GetWindow(), (Window) m_window, 
+            XCopyArea( (Display*) m_display, (Window) srcDC->GetWindow(), (Window) m_window,

                        (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
         }
     }
 
     SetLogicalFunction( old_logical_func );
                        (GC) m_penGC, xsrc, ysrc, width, height, xx, yy );
             XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
         }
     }
 
     SetLogicalFunction( old_logical_func );

-    
-    return TRUE;
+
+    return true;

 }
 
 void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 }
 
 void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )


@@ -1512,28 +1529,28 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new(m_context);
     pango_layout_set_font_description(layout, m_fontdesc);
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new(m_context);
     pango_layout_set_font_description(layout, m_fontdesc);

-    
+

     const wxCharBuffer data = wxConvUTF8.cWC2MB( text );
     pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
     const wxCharBuffer data = wxConvUTF8.cWC2MB( text );
     pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));

-    
+

     // Measure layout.
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     wxCoord width = w;
     wxCoord height = h;
     // Measure layout.
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     wxCoord width = w;
     wxCoord height = h;

-    
+

     // Draw layout.
     x11_draw_layout( (Drawable) m_window, (GC) m_textGC, x, y, layout, m_textForegroundColour );
     // Draw layout.
     x11_draw_layout( (Drawable) m_window, (GC) m_textGC, x, y, layout, m_textForegroundColour );

-    
+

     g_object_unref( G_OBJECT( layout ) );
     g_object_unref( G_OBJECT( layout ) );

-    
+

     CalcBoundingBox (x + width, y + height);
     CalcBoundingBox (x, y);
 #else
     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
 
     wxCHECK_RET( xfont, wxT("invalid font") );
     CalcBoundingBox (x + width, y + height);
     CalcBoundingBox (x, y);
 #else
     XFontStruct *xfont = (XFontStruct*) m_font.GetFontStruct( m_scaleY, m_display );
 
     wxCHECK_RET( xfont, wxT("invalid font") );

-    
+

     // First draw a rectangle representing the text background, if a text
     // background is specified
     if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
     // First draw a rectangle representing the text background, if a text
     // background is specified
     if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))


@@ -1548,12 +1565,13 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
         slen = strlen(text);
         XCharStruct overall_return;
 
         slen = strlen(text);
         XCharStruct overall_return;
 

-        (void)XTextExtents(xfont, (char*) text.c_str(), slen, &direction,
+        (void)XTextExtents(xfont, (const char*) text.c_str(), slen, &direction,

                                  &ascent, &descent, &overall_return);
 
         cx = overall_return.width;
         cy = ascent + descent;
         m_textBackgroundColour.CalcPixel(m_cmap);
                                  &ascent, &descent, &overall_return);
 
         cx = overall_return.width;
         cy = ascent + descent;
         m_textBackgroundColour.CalcPixel(m_cmap);

+        m_textForegroundColour.CalcPixel(m_cmap);

         XSetForeground ((Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel());
         XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, x, y, cx, cy );
         XSetForeground ((Display*) m_display, (GC) m_textGC, m_textBackgroundColour.GetPixel());
         XFillRectangle( (Display*) m_display, (Window) m_window,
                     (GC) m_textGC, x, y, cx, cy );


@@ -1563,11 +1581,13 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 
     XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
 #if !wxUSE_NANOX
 
     XSetFont( (Display*) m_display, (GC) m_textGC, xfont->fid );
 #if !wxUSE_NANOX

-    if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
+    // This may be a test for whether the font is 16-bit, but it also
+    // seems to fail for valid 8-bit fonts too.
+    if (1) // (xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))

 #endif
     {
 #endif
     {

-        XDrawString( (Display*) m_display, (Window) m_window, 
-            (GC) m_textGC, x, y + XFontStructGetAscent(xfont), text.c_str(), text.Len() );
+        XDrawString( (Display*) m_display, (Window) m_window,
+            (GC) m_textGC, x, y + XFontStructGetAscent(xfont), text.c_str(), text.length() );

     }
 
 #if 0
     }
 
 #if 0


@@ -1580,31 +1600,33 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
 
     width = wxCoord(width / m_scaleX);
     height = wxCoord(height / m_scaleY);
 
     width = wxCoord(width / m_scaleX);
     height = wxCoord(height / m_scaleY);

-    
+

     CalcBoundingBox (x + width, y + height);
     CalcBoundingBox (x, y);
 #endif
 #endif
 }
 
     CalcBoundingBox (x + width, y + height);
     CalcBoundingBox (x, y);
 #endif
 #endif
 }
 

-void wxWindowDC::DoDrawRotatedText( const wxString &text, wxCoord x, wxCoord y, double angle )
+void wxWindowDC::DoDrawRotatedText(const wxString& WXUNUSED(text),
+                                   wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
+                                   double WXUNUSED(angle))

 {
 {

-    // later
+    wxFAIL_MSG( "not implemented" );

 }
 
 void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
                                 wxCoord *descent, wxCoord *externalLeading,
 }
 
 void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoord *height,
                                 wxCoord *descent, wxCoord *externalLeading,

-                                wxFont *font ) const
+                                const wxFont *font ) const

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

-    if (string.IsEmpty())
+    if (string.empty())

     {
         if (width) (*width) = 0;
         if (height) (*height) = 0;
         return;
     }
     {
         if (width) (*width) = 0;
         if (height) (*height) = 0;
         return;
     }

-    
+

 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );
 
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );
 


@@ -1612,15 +1634,15 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
         pango_layout_set_font_description( layout, font->GetNativeFontInfo()->description );
     else
         pango_layout_set_font_description(layout, m_fontdesc);
         pango_layout_set_font_description( layout, font->GetNativeFontInfo()->description );
     else
         pango_layout_set_font_description(layout, m_fontdesc);

-        
+

     const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
     pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
     const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
     pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));

- 
+

     // Measure text.
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     // Measure text.
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);

-    
-    if (width) (*width) = (wxCoord) w; 
+
+    if (width) (*width) = (wxCoord) w;

     if (height) (*height) = (wxCoord) h;
     if (descent)
     {
     if (height) (*height) = (wxCoord) h;
     if (descent)
     {


@@ -1628,7 +1650,7 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
         (*descent) = 0;
     }
     if (externalLeading) (*externalLeading) = 0;  // ??
         (*descent) = 0;
     }
     if (externalLeading) (*externalLeading) = 0;  // ??

-    
+

     g_object_unref( G_OBJECT( layout ) );
 #else
     wxFont fontToUse = m_font;
     g_object_unref( G_OBJECT( layout ) );
 #else
     wxFont fontToUse = m_font;


@@ -1639,11 +1661,11 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
     XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
 
     wxCHECK_RET( xfont, wxT("invalid font") );
     XFontStruct *xfont = (XFontStruct*) fontToUse.GetFontStruct( m_scaleY, m_display );
 
     wxCHECK_RET( xfont, wxT("invalid font") );

-    
+

     int direction, ascent, descent2;
     XCharStruct overall;
 
     int direction, ascent, descent2;
     XCharStruct overall;
 

-    XTextExtents( xfont, (char*) string.c_str(), string.Len(), &direction,
+    XTextExtents( xfont, (const char*) string.c_str(), string.length(), &direction,

         &ascent, &descent2, &overall);
 
     if (width)
         &ascent, &descent2, &overall);
 
     if (width)


@@ -1660,22 +1682,20 @@ void wxWindowDC::DoGetTextExtent( const wxString &string, wxCoord *width, wxCoor
 wxCoord wxWindowDC::GetCharWidth() const
 {
     wxCHECK_MSG( Ok(), 0, wxT("invalid dc") );
 wxCoord wxWindowDC::GetCharWidth() const
 {
     wxCHECK_MSG( Ok(), 0, wxT("invalid dc") );

-    
+

 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );

-    
-    if (!m_fontdesc)
-    {
-        char *crash = NULL;
-        *crash = 0;
-    }
-    
-    pango_layout_set_font_description(layout, m_fontdesc);
+
+    if (m_fontdesc)
+        pango_layout_set_font_description(layout, m_fontdesc);
+    else
+        pango_layout_set_font_description(layout, this->GetFont().GetNativeFontInfo()->description);
+

     pango_layout_set_text(layout, "H", 1 );
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     g_object_unref( G_OBJECT( layout ) );
     pango_layout_set_text(layout, "H", 1 );
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     g_object_unref( G_OBJECT( layout ) );

-    
+

     return w;
 #else
     wxCHECK_MSG( m_font.Ok(), 0, wxT("invalid font") );
     return w;
 #else
     wxCHECK_MSG( m_font.Ok(), 0, wxT("invalid font") );


@@ -1686,9 +1706,9 @@ wxCoord wxWindowDC::GetCharWidth() const
 
     int direction, ascent, descent;
     XCharStruct overall;
 
     int direction, ascent, descent;
     XCharStruct overall;

-    
+

     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );

-        
+

     return (wxCoord)(overall.width / m_scaleX);
 #endif
 }
     return (wxCoord)(overall.width / m_scaleX);
 #endif
 }


@@ -1696,23 +1716,20 @@ wxCoord wxWindowDC::GetCharWidth() const
 wxCoord wxWindowDC::GetCharHeight() const
 {
     wxCHECK_MSG( Ok(), 0, wxT("invalid dc") );
 wxCoord wxWindowDC::GetCharHeight() const
 {
     wxCHECK_MSG( Ok(), 0, wxT("invalid dc") );

-    
+

 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );
 #if wxUSE_UNICODE
     PangoLayout *layout = pango_layout_new( m_context );

-    
-    if (!m_fontdesc)
-    {
-        char *crash = NULL;
-        *crash = 0;
-    }
-    
-    pango_layout_set_font_description(layout, m_fontdesc);
-    
+
+    if (m_fontdesc)
+        pango_layout_set_font_description(layout, m_fontdesc);
+    else
+        pango_layout_set_font_description(layout, this->GetFont().GetNativeFontInfo()->description);
+

     pango_layout_set_text(layout, "H", 1 );
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     g_object_unref( G_OBJECT( layout ) );
     pango_layout_set_text(layout, "H", 1 );
     int w,h;
     pango_layout_get_pixel_size(layout, &w, &h);
     g_object_unref( G_OBJECT( layout ) );

-    
+

     return h;
 #else
     wxCHECK_MSG( m_font.Ok(), 0, wxT("invalid font") );
     return h;
 #else
     wxCHECK_MSG( m_font.Ok(), 0, wxT("invalid font") );


@@ -1723,9 +1740,9 @@ wxCoord wxWindowDC::GetCharHeight() const
 
     int direction, ascent, descent;
     XCharStruct overall;
 
     int direction, ascent, descent;
     XCharStruct overall;

-    
+

     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );
     XTextExtents( xfont, "H", 1, &direction, &ascent, &descent, &overall );

-        
+

     return (wxCoord)((ascent+descent) / m_scaleY);
 #endif
 }
     return (wxCoord)((ascent+descent) / m_scaleY);
 #endif
 }


@@ -1765,6 +1782,10 @@ void wxWindowDC::SetFont( const wxFont &font )
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 
     m_font = font;
     wxCHECK_RET( Ok(), wxT("invalid dc") );
 
     m_font = font;

+
+#if wxUSE_UNICODE
+    m_fontdesc = font.GetNativeFontInfo()->description;
+#endif

 }
 
 void wxWindowDC::SetPen( const wxPen &pen )
 }
 
 void wxWindowDC::SetPen( const wxPen &pen )


@@ -1908,7 +1929,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
 
     m_brush.GetColour().CalcPixel( m_cmap );
     XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );
 
     m_brush.GetColour().CalcPixel( m_cmap );
     XSetForeground( (Display*) m_display, (GC) m_brushGC, m_brush.GetColour().GetPixel() );

-    
+

     XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
 
     if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))
     XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillSolid );
 
     if ((m_brush.GetStyle() == wxSTIPPLE) && (m_brush.GetStipple()->Ok()))


@@ -1931,7 +1952,7 @@ void wxWindowDC::SetBrush( const wxBrush &brush )
         XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
     }
 
         XSetStipple( (Display*) m_display, (GC) m_textGC, (Pixmap) m_brush.GetStipple()->GetMask()->GetBitmap() );
     }
 

-    if (IS_HATCH(m_brush.GetStyle()))
+    if (m_brush.IsHatch())

     {
         XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
         int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;
     {
         XSetFillStyle( (Display*) m_display, (GC) m_brushGC, FillStippled );
         int num = m_brush.GetStyle() - wxBDIAGONAL_HATCH;


@@ -1976,7 +1997,7 @@ void wxWindowDC::SetBackground( const wxBrush &brush )
         }
     }
 
         }
     }
 

-    if (IS_HATCH(m_backgroundBrush.GetStyle()))
+    if (m_backgroundBrush.IsHatch())

     {
         XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
         int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;
     {
         XSetFillStyle( (Display*) m_display, (GC) m_bgGC, FillStippled );
         int num = m_backgroundBrush.GetStyle() - wxBDIAGONAL_HATCH;


@@ -1996,7 +2017,7 @@ void wxWindowDC::SetLogicalFunction( int function )
     // VZ: shouldn't this be a CHECK?
     if (!m_window)
         return;
     // VZ: shouldn't this be a CHECK?
     if (!m_window)
         return;

-        
+

     switch (function)
     {
     case wxCLEAR:
     switch (function)
     {
     case wxCLEAR:


@@ -2057,7 +2078,7 @@ void wxWindowDC::SetLogicalFunction( int function )
     // operations (i.e. DrawText/DrawRotatedText).
     // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
     XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );
     // operations (i.e. DrawText/DrawRotatedText).
     // True, but mono-bitmaps use the m_textGC and they use ROPs as well.
     XSetFunction( (Display*) m_display, (GC) m_textGC, x_function );

-    
+

     m_logicalFunction = function;
 }
 
     m_logicalFunction = function;
 }
 


@@ -2119,7 +2140,7 @@ void wxWindowDC::SetBackgroundMode( int mode )
     }
 }
 
     }
 }
 

-void wxWindowDC::SetPalette( const wxPalette& palette )
+void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) )

 {
 #if 0
     if (m_window)
 {
 #if 0
     if (m_window)


@@ -2142,19 +2163,25 @@ void wxWindowDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoo
 
     if (!m_window) return;
 
 
     if (!m_window) return;
 

+    if (width <= 0)
+        width = 1;
+
+    if (height <= 0)
+        height = 1;
+

     wxRect rect;
     rect.x = XLOG2DEV(x);
     rect.y = YLOG2DEV(y);
     rect.width = XLOG2DEVREL(width);
     rect.height = YLOG2DEVREL(height);
 
     wxRect rect;
     rect.x = XLOG2DEV(x);
     rect.y = YLOG2DEV(y);
     rect.width = XLOG2DEVREL(width);
     rect.height = YLOG2DEVREL(height);
 

-    if (!m_currentClippingRegion.IsNull())
+    if (!m_currentClippingRegion.IsEmpty())

         m_currentClippingRegion.Intersect( rect );
     else
         m_currentClippingRegion.Intersect( rect );
     else

-        m_currentClippingRegion.Union( rect );
+        m_currentClippingRegion = rect;

 
 #if USE_PAINT_REGION
 
 #if USE_PAINT_REGION

-    if (!m_paintClippingRegion.IsNull())
+    if (!m_paintClippingRegion.IsEmpty())

         m_currentClippingRegion.Intersect( m_paintClippingRegion );
 #endif
 
         m_currentClippingRegion.Intersect( m_paintClippingRegion );
 #endif
 


@@ -2180,13 +2207,13 @@ void wxWindowDC::DoSetClippingRegionAsRegion( const wxRegion& region )
 
     if (!m_window) return;
 
 
     if (!m_window) return;
 

-    if (!m_currentClippingRegion.IsNull())
+    if (!m_currentClippingRegion.IsEmpty())

         m_currentClippingRegion.Intersect( region );
     else
         m_currentClippingRegion.Intersect( region );
     else

-        m_currentClippingRegion.Union( region );
+        m_currentClippingRegion = region;

 
 #if USE_PAINT_REGION
 
 #if USE_PAINT_REGION

-    if (!m_paintClippingRegion.IsNull())
+    if (!m_paintClippingRegion.IsEmpty())

         m_currentClippingRegion.Intersect( m_paintClippingRegion );
 #endif
 
         m_currentClippingRegion.Intersect( m_paintClippingRegion );
 #endif
 


@@ -2285,9 +2312,9 @@ wxClientDC::wxClientDC( wxWindow *window )
           : wxWindowDC( window )
 {
     wxCHECK_RET( window, _T("NULL window in wxClientDC::wxClientDC") );
           : wxWindowDC( window )
 {
     wxCHECK_RET( window, _T("NULL window in wxClientDC::wxClientDC") );

-    
+

     m_window = (WXWindow*) window->GetClientAreaWindow();
     m_window = (WXWindow*) window->GetClientAreaWindow();

-    
+

     // Adjust the client area when the wxWindow is not using 2 X11 windows.
     if (m_window == (WXWindow*) window->GetMainWindow())
     {
     // Adjust the client area when the wxWindow is not using 2 X11 windows.
     if (m_window == (WXWindow*) window->GetMainWindow())
     {


@@ -2339,8 +2366,15 @@ wxPaintDC::wxPaintDC(wxWindow* window)
 class wxDCModule : public wxModule
 {
 public:
 class wxDCModule : public wxModule
 {
 public:

-    bool OnInit();
-    void OnExit();
+    // we must be cleaned up before wxDisplayModule which closes the global
+    // display
+    wxDCModule()
+    {
+        AddDependency(wxClassInfo::FindClass(_T("wxX11DisplayModule")));
+    }
+
+    bool OnInit() { wxInitGCPool(); return true; }
+    void OnExit() { wxCleanUpGCPool(); }

 
 private:
     DECLARE_DYNAMIC_CLASS(wxDCModule)
 
 private:
     DECLARE_DYNAMIC_CLASS(wxDCModule)


@@ -2348,13 +2382,3 @@ private:
 
 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxDCModule, wxModule)
 

-bool wxDCModule::OnInit()
-{
-    wxInitGCPool();
-    return TRUE;
-}
-
-void wxDCModule::OnExit()
-{
-    wxCleanUpGCPool();
-}