Some more Motif work; included utils.h in fileconf.cpp (for wxGetHomeDir or something)

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@768 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/distrib/msw/motif.rsp b/distrib/msw/motif.rsp
index 953a64ed7f840428266f78e2dd60defc999c08c2..abcf194fee18d24ee5574b82c510c3d58b50ffa0 100644 (file)
--- a/distrib/msw/motif.rsp
+++ b/distrib/msw/motif.rsp
@@ -3,12 +3,15 @@ src/motif/*.c
 src/motif/*.h
 src/motif/makefile*
 src/motif/*.inc
 src/motif/*.h
 src/motif/makefile*
 src/motif/*.inc

+src/motif/*.xbm

 
 src/make.env
 src/makeprog.env
 
 include/wx/motif/*.h
 
 
 src/make.env
 src/makeprog.env
 
 include/wx/motif/*.h
 

+docs/motif/*.*
+

 lib/dummy
 
 
 lib/dummy
 
 

diff --git a/docs/motif/changes.txt b/docs/motif/changes.txt
new file mode 100644 (file)
index 0000000..561b697
--- /dev/null
+++ b/docs/motif/changes.txt
@@ -0,0 +1,13 @@
+wxMotif CHANGES
+---------------
+
+21/9/98
+-------
+
+Julian:
+
+- Made makefiles for wxMotif source directory and minimal sample.
+
+- First go at wxApp, wxWindow, wxDialog, wxPen, wxBrush, wxFont,
+  wxColour, wxButton, wxCheckBox, wxTextCtrl, wxStaticText,
+  wxMenu, wxMenuItem, wxMenuBar

diff --git a/docs/motif/todo.txt b/docs/motif/todo.txt
new file mode 100644 (file)
index 0000000..52f9d8e
--- /dev/null
+++ b/docs/motif/todo.txt
@@ -0,0 +1,73 @@
+wxMotif TODO
+------------
+
+Updated: 21/9/98
+
+         -------------------------------o-------------------------
+
+- wxDCs
+
+- wxBitmap, wxIcon, wxCursor, wxPalette. What about XPMs, can we assume
+  libxpm exists and use that? What about PNGs? Can we use gdk
+  as per wxGTK? Probably not.
+
+- wxRegion
+
+- Bitmap versions of widgets (wxBitmapButton etc.)
+
+- wxCheckBoxList
+
+- Remaining common widgets (wxListBox, wxRadioBox, wxRadioButton, wxChoice,
+  wxGauge, wxComboBox etc.). Use combobox.c code as bundled in wxWin 1.68.
+
+- wxTextCtrl text file loading and saving.
+
+- Scrolling in wxWindow.
+
+- A generic version of wxNotebook that can be used in wxMotif and
+  other toolkits that don't have a native control. Perhaps use wxTab as a
+  starting point.
+
+- MDI classes: use existing Motif widgets for this.
+
+- Miscellaneous classes e.g. wxJoystick (identical to GTK's one for
+  Linux)
+
+- Dialogs e.g. wxFileSelector. Use a native Motif wxMessageBox.
+  Some others need tidying, such as the colour and font selectors.
+
+- Write generic wxDirDialog (directory selector).
+
+- Use generic wxTreeCtrl, wxListCtrl: enhance these.
+
+- Write a better generic wxToolBar class than wxToolBarSimple.
+
+- Optimize colour management so we don't get clashes when e.g.
+  Netscape is running.
+
+- Print/preview framework in print.cpp (see wxGTK's).
+
+- Colour and font setting in widgets.
+
+- wxSystemSettings
+
+- wxTimer
+
+- wxThread (hopefully, similar to wxGTK)
+
+- Copy and paste, drag and drop. Use a standard X drag
+  and drop standard - see http://www.cco.caltech.edu/~jafl/xdnd/
+
+- Optimize screen refresh for non-native widgets, e.g. wxWindow
+  created with Create(), using technique in flicker patch for 1.68
+  (see JACS for latest patch).
+
+- Enhance event handling such that you override e.g. left-click
+  and unless you call the base OnMouseEvent, the click won't be
+  sent to the button. Required for Dialog Editor.
+
+- Write makefiles for all samples.
+
+- Create some samples for testing.
+
+- Get Dialog Editor working under Motif.

diff --git a/include/wx/defs.h b/include/wx/defs.h
index 6bda0903fada78b96548f1ea995416c1e019030f..0082470ae12dee632f30825ef8c9a06349420d06 100644 (file)
--- a/include/wx/defs.h
+++ b/include/wx/defs.h
@@ -104,6 +104,10 @@
 typedef unsigned int bool;
 #endif
 
 typedef unsigned int bool;
 #endif
 

+#if defined(_MSC_VER) && (_MSC_VER == 1020)
+#define bool unsigned int
+#endif
+

 #if ( defined(_MSC_VER) && (_MSC_VER <= 800) ) || defined(__GNUWIN32__)
 #define byte unsigned char
 #endif
 #if ( defined(_MSC_VER) && (_MSC_VER <= 800) ) || defined(__GNUWIN32__)
 #define byte unsigned char
 #endif

diff --git a/include/wx/generic/treectrl.h b/include/wx/generic/treectrl.h
index 8e9af202975f69432d9d9b4e0b119a9b8174bc1f..f969e3c3c1a0638538ed762e7e14520dc9a4bd61 100644 (file)
--- a/include/wx/generic/treectrl.h
+++ b/include/wx/generic/treectrl.h
@@ -311,7 +311,7 @@ public:
   bool SetItemState(long item, long state, long stateMask);
 
   void AdjustMyScrollbars();
   bool SetItemState(long item, long state, long stateMask);
 
   void AdjustMyScrollbars();

-  void PaintLevel( wxGenericTreeItem *item, wxPaintDC &dc, int level, int &y );
+  void PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y );

   void OnPaint( const wxPaintEvent &event );
   void OnSetFocus( const wxFocusEvent &event );
   void OnKillFocus( const wxFocusEvent &event );
   void OnPaint( const wxPaintEvent &event );
   void OnSetFocus( const wxFocusEvent &event );
   void OnKillFocus( const wxFocusEvent &event );


@@ -338,7 +338,7 @@ private:
   wxImageList         *m_imageList;
   wxImageList         *m_smallImageList;
 
   wxImageList         *m_imageList;
   wxImageList         *m_smallImageList;
 

-  void CalculateLevel( wxGenericTreeItem *item, wxPaintDC &dc, int level, int &y );
+  void CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y );

   void CalculatePositions();
   wxGenericTreeItem *FindItem( long itemId ) const;
   void RefreshLine( wxGenericTreeItem *item );
   void CalculatePositions();
   wxGenericTreeItem *FindItem( long itemId ) const;
   void RefreshLine( wxGenericTreeItem *item );

diff --git a/include/wx/memory.h b/include/wx/memory.h
index c1967741a975ae6d0bc6b03e0f8ac15240e00c7e..0f61ce0516254d7a0d439c2a9703280c1400a208 100644 (file)
--- a/include/wx/memory.h
+++ b/include/wx/memory.h
@@ -57,7 +57,7 @@ void wxDebugFree(void * buf, bool isVect = FALSE);
 void * operator new (size_t size, char * fileName, int lineNum);
 void operator delete (void * buf);
 
 void * operator new (size_t size, char * fileName, int lineNum);
 void operator delete (void * buf);
 

-#if !( defined (_MSC_VER) && (_MSC_VER <= 1000) )
+#if !( defined (_MSC_VER) && (_MSC_VER <= 1020) )

 void * operator new[] (size_t size, char * fileName, int lineNum);
 void operator delete[] (void * buf);
 #endif
 void * operator new[] (size_t size, char * fileName, int lineNum);
 void operator delete[] (void * buf);
 #endif

diff --git a/include/wx/motif/bitmap.h b/include/wx/motif/bitmap.h
index 104ec5beb3542d211ad34b6830a5080e3850dc84..4fec4f62c1342e60ee09506bdd695c88b3fb9d7d 100644 (file)
--- a/include/wx/motif/bitmap.h
+++ b/include/wx/motif/bitmap.h
@@ -54,13 +54,10 @@ public:
   bool Create(const wxBitmap& bitmap, int paletteIndex);
   bool Create(const wxBitmap& bitmap);
 
   bool Create(const wxBitmap& bitmap, int paletteIndex);
   bool Create(const wxBitmap& bitmap);
 

-/* TODO: platform-specific data access
-  // Implementation
-  inline WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
-  inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
+  inline WXPixmap GetPixmap() const { return m_pixmap; }
+

 protected:
 protected:

-  WXHBITMAP m_maskBitmap;
-*/
+  WXPixmap      m_pixmap;

 };
 
 class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData
 };
 
 class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData


@@ -81,8 +78,12 @@ public:
   wxPalette     m_bitmapPalette;
   int           m_quality;
 
   wxPalette     m_bitmapPalette;
   int           m_quality;
 

-/*  WXHBITMAP     m_hBitmap; TODO: platform-specific handle */

   wxMask *      m_bitmapMask; // Optional mask
   wxMask *      m_bitmapMask; // Optional mask

+
+  // Motif implementation
+public:
+  WXPixmap      m_pixmap;
+  WXDisplay*    m_display;

 };
 
 #define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
 };
 
 #define M_BITMAPDATA ((wxBitmapRefData *)m_refData)


@@ -182,16 +183,15 @@ public:
 
   static void InitStandardHandlers();
   static void CleanUpHandlers();
 
   static void InitStandardHandlers();
   static void CleanUpHandlers();

+
+  // Motif implementation
+public:
+  inline WXDisplay* GetDisplay() const { return M_BITMAPDATA->m_display; }
+  inline WXDisplay* GetPixmap() const { return M_BITMAPDATA->m_pixmap; }
+

 protected:
   static wxList sm_handlers;
 
 protected:
   static wxList sm_handlers;
 

-/*
-  // TODO: Implementation
-public:
-  void SetHBITMAP(WXHBITMAP bmp);
-  inline WXHBITMAP GetHBITMAP() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); }
-  bool FreeResource(bool force = FALSE);
-*/

 
 };
 #endif
 
 };
 #endif

diff --git a/include/wx/motif/colour.h b/include/wx/motif/colour.h
index 95282ea77a7599ef023e6ea21d38d109718cdbda..9ce941f2a8833f3ea8fa027fa5bede32da775465 100644 (file)
--- a/include/wx/motif/colour.h
+++ b/include/wx/motif/colour.h
@@ -53,17 +53,17 @@ public:
   inline bool operator != (const wxColour& colour) { return (!(m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue)); }
 
   inline int GetPixel() const { return m_pixel; };
   inline bool operator != (const wxColour& colour) { return (!(m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue)); }
 
   inline int GetPixel() const { return m_pixel; };

-  inline void SetPixel(int pixel) { m_pixel = pixel; };
+  inline void SetPixel(int pixel) { m_pixel = pixel; m_isInit = TRUE; };

 
   // Allocate a colour, or nearest colour, using the given display.
   // If realloc is TRUE, ignore the existing pixel, otherwise just return
   // the existing one.
 
   // Allocate a colour, or nearest colour, using the given display.
   // If realloc is TRUE, ignore the existing pixel, otherwise just return
   // the existing one.

-  // Returns FALSE if an exact match was not found, TRUE otherwise.
+  // Returns the allocated pixel.

 
   // TODO: can this handle mono displays? If not, we should have an extra
   // flag to specify whether this should be black or white by default.
 
 
   // TODO: can this handle mono displays? If not, we should have an extra
   // flag to specify whether this should be black or white by default.
 

-  bool AllocColour(WXDisplay* display, bool realloc);
+  int AllocColour(WXDisplay* display, bool realloc = FALSE);

 
  private:
   bool          m_isInit;
 
  private:
   bool          m_isInit;

diff --git a/include/wx/motif/dc.h b/include/wx/motif/dc.h
index 0b3cd868acdb5e86a76a62dd34861e2808c30fdd..485b64b47e9eb4338bd9291aa5b5334ad30a6e87 100644 (file)
--- a/include/wx/motif/dc.h
+++ b/include/wx/motif/dc.h
@@ -238,7 +238,7 @@ class WXDLLEXPORT wxDC: public wxObject
 
     virtual void SetAxisOrientation( bool xLeftRight, bool yBottomUp );
     
 
     virtual void SetAxisOrientation( bool xLeftRight, bool yBottomUp );
     

-    virtual void SetOptimization( bool WXUNUSED(optimize) ) {};
+    virtual void SetOptimization( bool optimize ) { m_optimize = optimize; };

     virtual bool GetOptimization(void) { return m_optimize; };
     
     virtual long DeviceToLogicalX(long x) const;
     virtual bool GetOptimization(void) { return m_optimize; };
     
     virtual long DeviceToLogicalX(long x) const;


@@ -293,6 +293,15 @@ class WXDLLEXPORT wxDC: public wxObject
          else
            return (long)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
        }
          else
            return (long)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
        }

+    // Without device translation, for backing pixmap purposes
+    long XLOG2DEV_2(long x) const
+       { 
+         long new_x = x - m_logicalOriginX;
+         if (new_x > 0)
+           return (long)((double)(new_x) * m_scaleX + 0.5) * m_signX;
+         else
+           return (long)((double)(new_x) * m_scaleX - 0.5) * m_signX;
+       }

     long XLOG2DEVREL(long x) const
        { 
          if (x > 0)
     long XLOG2DEVREL(long x) const
        { 
          if (x > 0)


@@ -308,6 +317,15 @@ class WXDLLEXPORT wxDC: public wxObject
          else
            return (long)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
        }
          else
            return (long)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
        }

+    // Without device translation, for backing pixmap purposes
+    long YLOG2DEV_2(long y) const
+       {
+         long new_y = y - m_logicalOriginY;
+         if (new_y > 0)
+           return (long)((double)(new_y) * m_scaleY + 0.5) * m_signY;
+         else
+           return (long)((double)(new_y) * m_scaleY - 0.5) * m_signY;
+       }

     long YLOG2DEVREL(long y) const
        { 
          if (y > 0)
     long YLOG2DEVREL(long y) const
        { 
          if (y > 0)


@@ -326,6 +344,8 @@ class WXDLLEXPORT wxDC: public wxObject
     // not sure, what these mean
     bool         m_clipping;      // Is clipping on right now ?
     bool         m_optimize;      // wxMSW only ?
     // not sure, what these mean
     bool         m_clipping;      // Is clipping on right now ?
     bool         m_optimize;      // wxMSW only ?

+    bool         m_isInteractive; // For wxPostScriptDC
+    wxString     m_filename;      // Ditto

     
     wxPen        m_pen;
     wxBrush      m_brush;
     
     wxPen        m_pen;
     wxBrush      m_brush;

diff --git a/include/wx/motif/dcclient.h b/include/wx/motif/dcclient.h
index 3ecc0f1e2e596df73a468ca3ada733a4dee6f1da..a4d303e885c35fca215c504c840f7881d204fb9d 100644 (file)
--- a/include/wx/motif/dcclient.h
+++ b/include/wx/motif/dcclient.h
@@ -28,9 +28,6 @@ class WXDLLEXPORT wxWindow;
 // Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented differently.
 // On many platforms, however, they will be the same.
 
 // Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented differently.
 // On many platforms, however, they will be the same.
 

-typedef wxWindowDC wxClientDC;
-typedef wxWindowDC wxPaintDC;
-

 //-----------------------------------------------------------------------------
 // wxWindowDC
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxWindowDC
 //-----------------------------------------------------------------------------


@@ -96,17 +93,22 @@ class WXDLLEXPORT wxWindowDC: public wxDC
     
     virtual void DrawOpenSpline( wxList *points );
 
     
     virtual void DrawOpenSpline( wxList *points );
 

+    // Motif-specific
+    void SetDCClipping (); // Helper function for setting clipping
+

 protected:
     WXGC         m_gc;
     WXGC         m_gcBacking;
     WXDisplay*   m_display;
     wxWindow*    m_window;
 protected:
     WXGC         m_gc;
     WXGC         m_gcBacking;
     WXDisplay*   m_display;
     wxWindow*    m_window;

-    WXRegion     m_clippingRegion;    
+    WXRegion     m_currentRegion; // Current clipping region (incl. paint clip region)
+    WXRegion     m_userRegion;    // User-defined clipping region
+    WXPixmap     m_pixmap;        // Pixmap for drawing on

 
     // Not sure if we'll need all of these
     int          m_backgroundPixel;
     wxColour     m_currentColour;
 
     // Not sure if we'll need all of these
     int          m_backgroundPixel;
     wxColour     m_currentColour;

-    int          m_currentBkMode;
+//    int          m_currentBkMode;

     int          m_currentPenWidth ;
     int          m_currentPenJoin ;
     int          m_currentPenCap ;
     int          m_currentPenWidth ;
     int          m_currentPenJoin ;
     int          m_currentPenCap ;


@@ -115,6 +117,23 @@ protected:
     wxBitmap     m_currentStipple ;
     int          m_currentStyle ;
     int          m_currentFill ;
     wxBitmap     m_currentStipple ;
     int          m_currentStyle ;
     int          m_currentFill ;

+    int          m_autoSetting ; // See comment in dcclient.cpp
+};
+
+class WXDLLEXPORT wxPaintDC: public wxWindowDC
+{
+  DECLARE_DYNAMIC_CLASS(wxPaintDC)
+public:
+  wxPaintDC() {}
+  wxPaintDC(wxWindow* win): wxWindowDC(win) {}
+};
+
+class WXDLLEXPORT wxClientDC: public wxWindowDC
+{
+  DECLARE_DYNAMIC_CLASS(wxClientDC)
+public:
+  wxClientDC() {}
+  wxClientDC(wxWindow* win): wxWindowDC(win) {}

 };
 
 #endif
 };
 
 #endif

diff --git a/include/wx/motif/dcmemory.h b/include/wx/motif/dcmemory.h
index c576655b05d3442eb756ef8d3bf4fbf13ea8e656..6edc56692556a04eae939b7c7e4eeaab6afb0dfd 100644 (file)
--- a/include/wx/motif/dcmemory.h
+++ b/include/wx/motif/dcmemory.h
@@ -18,7 +18,7 @@
 
 #include "wx/dcclient.h"
 
 
 #include "wx/dcclient.h"
 

-class WXDLLEXPORT wxMemoryDC: public wxPaintDC
+class WXDLLEXPORT wxMemoryDC: public wxWindowDC

 {
   DECLARE_DYNAMIC_CLASS(wxMemoryDC)
 
 {
   DECLARE_DYNAMIC_CLASS(wxMemoryDC)
 


@@ -29,9 +29,11 @@ class WXDLLEXPORT wxMemoryDC: public wxPaintDC
     virtual void SelectObject( const wxBitmap& bitmap );
     void GetSize( int *width, int *height ) const;
 
     virtual void SelectObject( const wxBitmap& bitmap );
     void GetSize( int *width, int *height ) const;
 

+    inline wxBitmap& GetBitmap() const { return (wxBitmap&) m_bitmap; }
+

   private: 
     friend wxPaintDC;
   private: 
     friend wxPaintDC;

-    wxBitmap  m_selected;
+    wxBitmap  m_bitmap;

 };
 
 #endif
 };
 
 #endif

diff --git a/include/wx/motif/icon.h b/include/wx/motif/icon.h
index 48ebe34c5e4c3f510bf88f929f5b397e4596cfc4..012fd0754d45b23e3d7814e5cb44298ee2155909 100644 (file)
--- a/include/wx/motif/icon.h
+++ b/include/wx/motif/icon.h
@@ -25,11 +25,6 @@ class WXDLLEXPORT wxIconRefData: public wxBitmapRefData
 public:
     wxIconRefData();
     ~wxIconRefData();
 public:
     wxIconRefData();
     ~wxIconRefData();

-
-public:
-/* TODO: whatever your actual icon handle is
-  WXHICON m_hIcon;
-*/

 };
 
 #define M_ICONDATA ((wxIconRefData *)m_refData)
 };
 
 #define M_ICONDATA ((wxIconRefData *)m_refData)


@@ -59,11 +54,6 @@ public:
   inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; }
   inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; }
 
   inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; }
   inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; }
 

-/* TODO: implementation
-  void SetHICON(WXHICON ico);
-  inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); }
-*/
-

 /* TODO */
   virtual bool Ok() const { return (m_refData != NULL) ; }
 };
 /* TODO */
   virtual bool Ok() const { return (m_refData != NULL) ; }
 };

diff --git a/include/wx/motif/palette.h b/include/wx/motif/palette.h
index 6364d677d944ec6c345b33769e63114d0bdb742f..4bc644cb7fc5b0323dd62e38ce290c42cf5ad2dc 100644 (file)
--- a/include/wx/motif/palette.h
+++ b/include/wx/motif/palette.h
@@ -26,10 +26,9 @@ class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData
 public:
     wxPaletteRefData();
     ~wxPaletteRefData();
 public:
     wxPaletteRefData();
     ~wxPaletteRefData();

-/* TODO: implementation
+

 protected:
 protected:

- WXHPALETTE m_hPalette;
-*/
+    WXColormap  m_colormap;

 };
 
 #define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
 };
 
 #define M_PALETTEDATA ((wxPaletteRefData *)m_refData)


@@ -55,10 +54,7 @@ public:
   inline bool operator == (const wxPalette& palette) { return m_refData == palette.m_refData; }
   inline bool operator != (const wxPalette& palette) { return m_refData != palette.m_refData; }
 
   inline bool operator == (const wxPalette& palette) { return m_refData == palette.m_refData; }
   inline bool operator != (const wxPalette& palette) { return m_refData != palette.m_refData; }
 

-/* TODO: implementation
-  inline WXHPALETTE GetHPALETTE() const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); }
-  void SetHPALETTE(WXHPALETTE pal);
-*/
+  WXColormap GetXColormap() const { return (M_PALETTEDATA->m_colormap); }

 };
 
 #endif
 };
 
 #endif

diff --git a/include/wx/motif/pen.h b/include/wx/motif/pen.h
index 60c375a42a2479e90ac3711ee8f86d9860673959..e8ac082a8096bd26f33fd59a02922372557c0390 100644 (file)
--- a/include/wx/motif/pen.h
+++ b/include/wx/motif/pen.h
@@ -84,6 +84,8 @@ public:
   inline int GetDashes(wxDash **ptr) const {
      *ptr = (M_PENDATA ? M_PENDATA->m_dash : (wxDash*) NULL); return (M_PENDATA ? M_PENDATA->m_nbDash : 0);
   }
   inline int GetDashes(wxDash **ptr) const {
      *ptr = (M_PENDATA ? M_PENDATA->m_dash : (wxDash*) NULL); return (M_PENDATA ? M_PENDATA->m_nbDash : 0);
   }

+  inline int GetDashCount() const { return (M_PENDATA->m_nbDash); }
+  inline wxDash* GetDash() const { return (M_PENDATA->m_dash); }

 
   inline wxBitmap *GetStipple() const { return (M_PENDATA ? (& M_PENDATA->m_stipple) : (wxBitmap*) NULL); };
 
 
   inline wxBitmap *GetStipple() const { return (M_PENDATA ? (& M_PENDATA->m_stipple) : (wxBitmap*) NULL); };
 

diff --git a/include/wx/motif/window.h b/include/wx/motif/window.h
index 5314bd46f64785730ac92c7fdba4a84989bc83bc..031695ff677986ca3b2c29936eb67e089a09cb94 100644 (file)
--- a/include/wx/motif/window.h
+++ b/include/wx/motif/window.h
@@ -85,8 +85,8 @@ class WXDLLEXPORT wxWindow: public wxEvtHandler
 {
   DECLARE_ABSTRACT_CLASS(wxWindow)
 
 {
   DECLARE_ABSTRACT_CLASS(wxWindow)
 

-  friend class wxDC;
-  friend class wxPaintDC;
+  friend class WXDLLEXPORT wxDC;
+  friend class WXDLLEXPORT wxWindowDC;

 
 public:
   wxWindow();
 
 public:
   wxWindow();


@@ -479,7 +479,11 @@ public:
   // Get the underlying X window and display
   virtual WXWindow GetXWindow() const;
   virtual WXDisplay *GetXDisplay() const;
   // Get the underlying X window and display
   virtual WXWindow GetXWindow() const;
   virtual WXDisplay *GetXDisplay() const;

+

   virtual WXPixmap GetBackingPixmap() const { return m_backingPixmap; }
   virtual WXPixmap GetBackingPixmap() const { return m_backingPixmap; }

+  inline int GetPixmapWidth() const { return m_pixmapWidth; }
+  inline int GetPixmapHeight() const { return m_pixmapHeight; }
+  virtual WXRegion GetPaintRegion() const { return m_paintRegion; }

 
   // Change properties
   virtual void ChangeColour(WXWidget widget);
 
   // Change properties
   virtual void ChangeColour(WXWidget widget);


@@ -548,6 +552,7 @@ public:
   int                   m_lastButton;  // last pressed button
   wxList                m_updateRects;     // List of wxRectangles representing damaged region
   bool                  m_isShown;
   int                   m_lastButton;  // last pressed button
   wxList                m_updateRects;     // List of wxRectangles representing damaged region
   bool                  m_isShown;

+  WXRegion              m_paintRegion; // Clip region generated by expose event

 protected:
   WXWidget              m_mainWidget;
   WXWidget              m_hScrollBar;
 protected:
   WXWidget              m_mainWidget;
   WXWidget              m_hScrollBar;

diff --git a/src/common/config.cpp b/src/common/config.cpp
index e099f0af2ce630f068cd833059b39a7f66f61156..9707475ac918ca0d9dc4afee91c474cbc9376c66 100644 (file)
--- a/src/common/config.cpp
+++ b/src/common/config.cpp
@@ -37,6 +37,7 @@
 #include  <wx/log.h>
 #include  <wx/textfile.h>
 #include  <wx/confbase.h>
 #include  <wx/log.h>
 #include  <wx/textfile.h>
 #include  <wx/confbase.h>

+#include  <wx/utils.h>

 
 // we must include (one of) these files for wxConfigBase::Create
 #if defined(__WXMSW__) && defined(wxCONFIG_WIN32_NATIVE)
 
 // we must include (one of) these files for wxConfigBase::Create
 #if defined(__WXMSW__) && defined(wxCONFIG_WIN32_NATIVE)


@@ -134,7 +135,7 @@ bool wxConfigBase::Read(const wxString& key, long *pl, long defVal) const
 bool wxConfigBase::Read(const wxString& key, double* val) const
 {
     wxString str;
 bool wxConfigBase::Read(const wxString& key, double* val) const
 {
     wxString str;

-    if (Read(key, str))
+    if (Read(key, & str))

     {
         *val = atof(str);
         return TRUE;
     {
         *val = atof(str);
         return TRUE;

diff --git a/src/common/fileconf.cpp b/src/common/fileconf.cpp
index a925bbae8ea4e34af9644531fa7bd503eeec57c9..1177370dfc6262b6cf8c6c25087c2dd9a9f09259 100644 (file)
--- a/src/common/fileconf.cpp
+++ b/src/common/fileconf.cpp
@@ -39,6 +39,7 @@
 #include  <wx/textfile.h>
 #include  <wx/config.h>
 #include  <wx/fileconf.h>
 #include  <wx/textfile.h>
 #include  <wx/config.h>
 #include  <wx/fileconf.h>

+#include  <wx/utils.h>

 
 // _WINDOWS_ is defined when windows.h is included,
 // __WXMSW__ is defined for MS Windows compilation
 
 // _WINDOWS_ is defined when windows.h is included,
 // __WXMSW__ is defined for MS Windows compilation

diff --git a/src/common/memory.cpp b/src/common/memory.cpp
index 70b4155d09f15c3b4604aee93b61d8263497332a..8ff4ae193c21d95b2926b3771ddbeab7b177c9a8 100644 (file)
--- a/src/common/memory.cpp
+++ b/src/common/memory.cpp
@@ -912,7 +912,7 @@ void * operator new (size_t size, char * fileName, int lineNum)
 #endif
 }
 
 #endif
 }
 

-#if !( defined (_MSC_VER) && (_MSC_VER <= 1000) )
+#if !( defined (_MSC_VER) && (_MSC_VER <= 1020) )

 void * operator new[] (size_t size, char * fileName, int lineNum)
 {
 #ifdef NO_DEBUG_ALLOCATION
 void * operator new[] (size_t size, char * fileName, int lineNum)
 {
 #ifdef NO_DEBUG_ALLOCATION


@@ -932,7 +932,7 @@ void operator delete (void * buf)
 #endif
 }
 
 #endif
 }
 

-#if !( defined (_MSC_VER) && (_MSC_VER <= 1000) )
+#if !( defined (_MSC_VER) && (_MSC_VER <= 1020) )

 void operator delete[] (void * buf)
 {
 #ifdef NO_DEBUG_ALLOCATION
 void operator delete[] (void * buf)
 {
 #ifdef NO_DEBUG_ALLOCATION

diff --git a/src/common/postscrp.cpp b/src/common/postscrp.cpp
index 99d1baa0954edcf02fdd271a8c575b3d8f55f87a..d332f426f771cac47e6665732cb4bc8cbfbec7d8 100644 (file)
--- a/src/common/postscrp.cpp
+++ b/src/common/postscrp.cpp
@@ -351,7 +351,7 @@ void wxPostScriptDC::DrawArc (long x1, long y1, long x2, long y2, long xc, long
 
     long dx = x1 - xc;
     long dy = y1 - yc;
 
     long dx = x1 - xc;
     long dy = y1 - yc;

-    long radius = (long) sqrt(dx*dx+dy*dy);
+    long radius = (long) sqrt((double) (dx*dx+dy*dy));

     double alpha1, alpha2;
 
     if (x1 == x2 && y1 == y2) {
     double alpha1, alpha2;
 
     if (x1 == x2 && y1 == y2) {


@@ -1214,8 +1214,8 @@ void wxPostScriptDC::EndDoc (void)
   // The Adobe specifications call for integers; we round as to make
   // the bounding larger.
   *m_pstream << "%%BoundingBox: "
   // The Adobe specifications call for integers; we round as to make
   // the bounding larger.
   *m_pstream << "%%BoundingBox: "

-      << floor(llx) << " " << floor(lly) << " "
-      << ceil(urx)  << " " << ceil(ury)  << "\n";
+      << floor((double)llx) << " " << floor((double)lly) << " "
+      << ceil((double)urx)  << " " << ceil((double)ury)  << "\n";

   *m_pstream << "%%Pages: " << wxPageNumber - 1 << "\n";
   *m_pstream << "%%EndComments\n\n";
 
   *m_pstream << "%%Pages: " << wxPageNumber - 1 << "\n";
   *m_pstream << "%%EndComments\n\n";
 


@@ -1417,10 +1417,10 @@ Blit (long xdest, long ydest, long fwidth, long fheight,
 
   if (!source->IsKindOf(CLASSINFO(wxPaintDC))) return FALSE;
 
 
   if (!source->IsKindOf(CLASSINFO(wxPaintDC))) return FALSE;
 

-  width = (long)floor(fwidth);
-  height = (long)floor(fheight);
-  x = (long)floor(xsrc);
-  y = (long)floor(ysrc);
+  width = (long)floor((double)fwidth);
+  height = (long)floor((double)fheight);
+  x = (long)floor((double)xsrc);
+  y = (long)floor((double)ysrc);

 
   /* PostScript setup: */
   *m_pstream << "gsave\n";
 
   /* PostScript setup: */
   *m_pstream << "gsave\n";

diff --git a/src/generic/statusbr.cpp b/src/generic/statusbr.cpp
index 8ea6f36bd73d45391313085885e7cb7ca6aa91d0..58a104aa7e0efd74b0d9e37d87af5a2a5b49b77d 100644 (file)
--- a/src/generic/statusbr.cpp
+++ b/src/generic/statusbr.cpp
@@ -318,7 +318,7 @@ void wxStatusBar::InitColours(void)
     m_hilightPen = wxPen("WHITE", 1, wxSOLID);
 #endif
 
     m_hilightPen = wxPen("WHITE", 1, wxSOLID);
 #endif
 

-       m_defaultStatusBarFont = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
+    m_defaultStatusBarFont = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);

     SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
 }
 
     SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
 }
 

diff --git a/src/generic/treectrl.cpp b/src/generic/treectrl.cpp
index 109827378a02a37482c865ad0744c3cca0331047..2008aa3fba9a3cc3e343bf09369ce1ac04049615 100644 (file)
--- a/src/generic/treectrl.cpp
+++ b/src/generic/treectrl.cpp
@@ -934,7 +934,7 @@ void wxTreeCtrl::AdjustMyScrollbars()
   }
 }
 
   }
 }
 

-void wxTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxPaintDC &dc, int level, int &y )
+void wxTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )

 {
   int horizX = level*m_indent;
 
 {
   int horizX = level*m_indent;
 


@@ -1088,7 +1088,7 @@ void wxTreeCtrl::OnMouse( const wxMouseEvent &event )
   }
 }
 
   }
 }
 

-void wxTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxPaintDC &dc, int level, int &y )
+void wxTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )

 {
   int horizX = level*m_indent;
 
 {
   int horizX = level*m_indent;
 

diff --git a/src/motif/bdiag.xbm b/src/motif/bdiag.xbm
new file mode 100644 (file)
index 0000000..9ff0a18
--- /dev/null
+++ b/src/motif/bdiag.xbm
@@ -0,0 +1,6 @@
+#define bdiag_width 16
+#define bdiag_height 16
+static char bdiag_bits[] = {
+   0x80, 0x80, 0x40, 0x40, 0x20, 0x20, 0x10, 0x10, 0x08, 0x08, 0x04, 0x04,
+   0x02, 0x02, 0x01, 0x01, 0x80, 0x80, 0x40, 0x40, 0x20, 0x20, 0x10, 0x10,
+   0x08, 0x08, 0x04, 0x04, 0x02, 0x02, 0x01, 0x01};

diff --git a/src/motif/bitmap.cpp b/src/motif/bitmap.cpp
index ed30fc8bdcaf370c9286482cbf356ed8671de1da..865b319997a2c4091c6862a8d70fa7abd83105b8 100644 (file)
--- a/src/motif/bitmap.cpp
+++ b/src/motif/bitmap.cpp
@@ -34,6 +34,9 @@ wxBitmapRefData::wxBitmapRefData()
     m_quality = 0;
     m_numColors = 0;
     m_bitmapMask = NULL;
     m_quality = 0;
     m_numColors = 0;
     m_bitmapMask = NULL;

+
+    m_pixmap = (WXPixmap) 0;
+    m_display = (WXDisplay*) 0;

 }
 
 wxBitmapRefData::~wxBitmapRefData()
 }
 
 wxBitmapRefData::~wxBitmapRefData()


@@ -296,18 +299,15 @@ wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
 
 wxMask::wxMask()
 {
 
 wxMask::wxMask()
 {

-/* TODO
-    m_maskBitmap = 0;
-*/
+    m_pixmap = (WXPixmap) 0;

 }
 
 // Construct a mask from a bitmap and a colour indicating
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 {
 }
 
 // Construct a mask from a bitmap and a colour indicating
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 {

-/* TODO
-    m_maskBitmap = 0;
-*/
+    m_pixmap = (WXPixmap) 0;
+

     Create(bitmap, colour);
 }
 
     Create(bitmap, colour);
 }
 


@@ -315,9 +315,7 @@ wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 {
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 {

-/* TODO
-    m_maskBitmap = 0;
-*/
+    m_pixmap = (WXPixmap) 0;

 
     Create(bitmap, paletteIndex);
 }
 
     Create(bitmap, paletteIndex);
 }


@@ -325,9 +323,7 @@ wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 // Construct a mask from a mono bitmap (copies the bitmap).
 wxMask::wxMask(const wxBitmap& bitmap)
 {
 // Construct a mask from a mono bitmap (copies the bitmap).
 wxMask::wxMask(const wxBitmap& bitmap)
 {

-/* TODO
-    m_maskBitmap = 0;
-*/
+    m_pixmap = (WXPixmap) 0;

 
     Create(bitmap);
 }
 
     Create(bitmap);
 }

diff --git a/src/motif/cdiag.xbm b/src/motif/cdiag.xbm
new file mode 100644 (file)
index 0000000..15dc7ba
--- /dev/null
+++ b/src/motif/cdiag.xbm
@@ -0,0 +1,6 @@
+#define cdiag_width 16
+#define cdiag_height 16
+static char cdiag_bits[] = {
+   0x81, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18, 0x18, 0x18, 0x24, 0x24,
+   0x42, 0x42, 0x81, 0x81, 0x81, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18,
+   0x18, 0x18, 0x24, 0x24, 0x42, 0x42, 0x81, 0x81};

diff --git a/src/motif/colour.cpp b/src/motif/colour.cpp
index 4aa74d14c07443ced73acbde4dad3c71cc4571fd..c3dca7072c0a83f3eaf509d9a488985d9365c5b9 100644 (file)
--- a/src/motif/colour.cpp
+++ b/src/motif/colour.cpp
@@ -128,15 +128,15 @@ void wxColour::Set (unsigned char r, unsigned char g, unsigned char b)
 // Allocate a colour, or nearest colour, using the given display.
 // If realloc is TRUE, ignore the existing pixel, otherwise just return
 // the existing one.
 // Allocate a colour, or nearest colour, using the given display.
 // If realloc is TRUE, ignore the existing pixel, otherwise just return
 // the existing one.

-// Returns FALSE if an exact match was not found, TRUE otherwise.
+// Returns the old or allocated pixel.

 
 // TODO: can this handle mono displays? If not, we should have an extra
 // flag to specify whether this should be black or white by default.
 
 
 // TODO: can this handle mono displays? If not, we should have an extra
 // flag to specify whether this should be black or white by default.
 

-bool wxColour::AllocColour(WXDisplay* display, bool realloc)
+int wxColour::AllocColour(WXDisplay* display, bool realloc)

 {
     if ((m_pixel != -1) && !realloc)
 {
     if ((m_pixel != -1) && !realloc)

-       return TRUE;
+       return m_pixel;

 
     XColor color;
     color.red = (unsigned short) Red ();
 
     XColor color;
     color.red = (unsigned short) Red ();


@@ -153,12 +153,12 @@ bool wxColour::AllocColour(WXDisplay* display, bool realloc)
     if (!XAllocColor ((Display*) display, (Colormap) cmap, &color))
     {
        m_pixel = wxGetBestMatchingPixel((Display*) display, &color,(Colormap) cmap);
     if (!XAllocColor ((Display*) display, (Colormap) cmap, &color))
     {
        m_pixel = wxGetBestMatchingPixel((Display*) display, &color,(Colormap) cmap);

-       return FALSE;
+       return m_pixel;

     }
     else
     {
        m_pixel = (int) color.pixel;
     }
     else
     {
        m_pixel = (int) color.pixel;

-       return TRUE;
+       return m_pixel;

     }
 }
 
     }
 }
 

diff --git a/src/motif/cross.xbm b/src/motif/cross.xbm
new file mode 100644 (file)
index 0000000..b07cbe7
--- /dev/null
+++ b/src/motif/cross.xbm
@@ -0,0 +1,6 @@
+#define cross_width 15
+#define cross_height 15
+static char cross_bits[] = {
+   0x84, 0x10, 0x84, 0x10, 0xff, 0x7f, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10,
+   0x84, 0x10, 0xff, 0x7f, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10,
+   0xff, 0x7f, 0x84, 0x10, 0x84, 0x10};

diff --git a/src/motif/dc.cpp b/src/motif/dc.cpp
index a7508a94ba6f8f34cec20eff0e8e53d2cdc1685d..0f8cf20522f11827328a06e3bd41e03b4c3a6258 100644 (file)
--- a/src/motif/dc.cpp
+++ b/src/motif/dc.cpp
@@ -80,6 +80,8 @@ wxDC::wxDC(void)
   m_font = *wxNORMAL_FONT;
   m_brush = *wxTRANSPARENT_BRUSH;
   m_backgroundBrush = *wxWHITE_BRUSH;
   m_font = *wxNORMAL_FONT;
   m_brush = *wxTRANSPARENT_BRUSH;
   m_backgroundBrush = *wxWHITE_BRUSH;

+
+  m_isInteractive = FALSE;

   
 //  m_palette = wxAPP_COLOURMAP;
 };
   
 //  m_palette = wxAPP_COLOURMAP;
 };

diff --git a/src/motif/dcclient.cpp b/src/motif/dcclient.cpp
index cf9f83f7cd115efcb17cb9418214f10d0f6d80d7..7ef4bf61efe252cb5ab883e87ce4c459da0894cb 100644 (file)
--- a/src/motif/dcclient.cpp
+++ b/src/motif/dcclient.cpp
@@ -6,9 +6,29 @@
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart

-// Licence:    wxWindows licence
+// Licence:       wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

+/*
+   About pens, brushes, and the autoSetting flag:
+
+   Under X, pens and brushes control some of the same X drawing 
+   parameters. Therefore, it is impossible to independently maintain
+   the current pen and the current brush. Also, some settings depend
+   on the current logical function. The m_currentFill, etc. instance
+   variables remember state across the brush and pen.
+
+   Since pens are used more than brushes, the autoSetting flag
+   is used to indicate that a brush was recently used, and SetPen
+   must be called to reinstall the current pen's parameters.
+   If autoSetting includes 0x2, then the pens color may need
+   to be set based on XOR.
+
+   There is, unfortunately, some confusion between setting the
+   current pen/brush and actually installing the brush/pen parameters.
+   Both functionalies are perform by SetPen and SetBrush. C'est la vie.
+*/
+

 #ifdef __GNUG__
 #pragma implementation "dcclient.h"
 #endif
 #ifdef __GNUG__
 #pragma implementation "dcclient.h"
 #endif


@@ -16,29 +36,40 @@
 #include "wx/dcclient.h"
 #include "wx/dcmemory.h"
 #include "wx/window.h"
 #include "wx/dcclient.h"
 #include "wx/dcmemory.h"
 #include "wx/window.h"

+#include "wx/app.h"

 #include <math.h>
 
 #include <Xm/Xm.h>
 
 #include "wx/motif/private.h"
 
 #include <math.h>
 
 #include <Xm/Xm.h>
 
 #include "wx/motif/private.h"
 

+#include "bdiag.xbm"
+#include "fdiag.xbm"
+#include "cdiag.xbm"
+#include "horiz.xbm"
+#include "verti.xbm"
+#include "cross.xbm"
+
+static Pixmap bdiag, cdiag, fdiag, cross, horiz, verti;
+

 //-----------------------------------------------------------------------------
 // constants
 //-----------------------------------------------------------------------------
 
 #define RAD2DEG 57.2957795131
 //-----------------------------------------------------------------------------
 // constants
 //-----------------------------------------------------------------------------
 
 #define RAD2DEG 57.2957795131

+// Fudge factor. Obsolete?
+#define WX_GC_CF 0

 
 //-----------------------------------------------------------------------------
 // wxWindowDC
 //-----------------------------------------------------------------------------
 
 #if !USE_SHARED_LIBRARY
 
 //-----------------------------------------------------------------------------
 // wxWindowDC
 //-----------------------------------------------------------------------------
 
 #if !USE_SHARED_LIBRARY

-//IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC)
-//IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
+IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC)

 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
 #endif
 
 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
 #endif
 

-

 wxWindowDC::wxWindowDC(void)
 {
     m_gc = (WXGC) 0;
 wxWindowDC::wxWindowDC(void)
 {
     m_gc = (WXGC) 0;


@@ -51,18 +82,22 @@ wxWindowDC::wxWindowDC(void)
     m_currentPenDash = (char*) NULL;
     m_currentStyle = -1;
     m_currentFill = -1;
     m_currentPenDash = (char*) NULL;
     m_currentStyle = -1;
     m_currentFill = -1;

-    m_currentBkMode = wxTRANSPARENT;
+//    m_currentBkMode = wxTRANSPARENT;

     m_colour = wxColourDisplay();
     m_display = (WXDisplay*) NULL;
     m_colour = wxColourDisplay();
     m_display = (WXDisplay*) NULL;

-    m_clippingRegion = (WXRegion) 0;
+    m_currentRegion = (WXRegion) 0;
+    m_userRegion = (WXRegion) 0;
+    m_pixmap = (WXPixmap) 0;
+    m_autoSetting = 0;

 };
 
 wxWindowDC::wxWindowDC( wxWindow *window )
 {
 };
 
 wxWindowDC::wxWindowDC( wxWindow *window )
 {

+    wxASSERT_MSG( (window != (wxWindow*) NULL), "You must pass a valid wxWindow to wxWindowDC/wxClientDC/wxPaintDC constructor." );
+

     m_window = window;
     m_gc = (WXGC) 0;
     m_gcBacking = (WXGC) 0;
     m_window = window;
     m_gc = (WXGC) 0;
     m_gcBacking = (WXGC) 0;

-    m_window = NULL;

     m_backgroundPixel = -1;
     m_currentPenWidth = 1;
     m_currentPenJoin = -1;
     m_backgroundPixel = -1;
     m_currentPenWidth = 1;
     m_currentPenJoin = -1;


@@ -70,11 +105,37 @@ wxWindowDC::wxWindowDC( wxWindow *window )
     m_currentPenDash = (char*) NULL;
     m_currentStyle = -1;
     m_currentFill = -1;
     m_currentPenDash = (char*) NULL;
     m_currentStyle = -1;
     m_currentFill = -1;

-    m_currentBkMode = wxTRANSPARENT;
+//    m_currentBkMode = wxTRANSPARENT;

     m_colour = wxColourDisplay();
     m_colour = wxColourDisplay();

-    m_display = window->GetXDisplay();
-    m_clippingRegion = (WXRegion) 0;
+    m_currentRegion = (WXRegion) 0;
+    m_userRegion = (WXRegion) 0;

     m_ok = TRUE;
     m_ok = TRUE;

+    m_autoSetting = 0;
+
+    m_display = window->GetXDisplay();
+    m_pixmap = window->GetXWindow();
+    Display* display = (Display*) m_display;
+
+    XSetWindowColormap (display, (Pixmap) m_pixmap, (Colormap) wxTheApp->GetMainColormap(m_display));
+
+    XGCValues gcvalues;
+    gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
+    gcvalues.background = WhitePixel (display, DefaultScreen (display));
+    gcvalues.graphics_exposures = False;
+    gcvalues.line_width = 1;
+    m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
+        GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
+          &gcvalues);
+
+    if (m_window->GetBackingPixmap())
+    {
+      m_gcBacking = (WXGC) XCreateGC (display, RootWindow (display,
+                          DefaultScreen (display)),
+        GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth,
+             &gcvalues);
+    }
+
+    m_backgroundPixel = (int) gcvalues.background;

 };
 
 wxWindowDC::~wxWindowDC(void)
 };
 
 wxWindowDC::~wxWindowDC(void)


@@ -87,262 +148,612 @@ wxWindowDC::~wxWindowDC(void)
         XFreeGC ((Display*) m_display, (GC) m_gcBacking);
     m_gcBacking = (WXGC) 0;
 
         XFreeGC ((Display*) m_display, (GC) m_gcBacking);
     m_gcBacking = (WXGC) 0;
 

-    if (m_clippingRegion)
-        XDestroyRegion ((Region) m_clippingRegion);
-    m_clippingRegion = (WXRegion) 0;
+    if (m_currentRegion)
+        XDestroyRegion ((Region) m_currentRegion);
+    m_currentRegion = (WXRegion) 0;
+
+    if (m_userRegion)
+        XDestroyRegion ((Region) m_userRegion);
+    m_userRegion = (WXRegion) 0;

 };
 
 void wxWindowDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1), 
   wxColour* WXUNUSED(col), int WXUNUSED(style) )
 {
 };
 
 void wxWindowDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1), 
   wxColour* WXUNUSED(col), int WXUNUSED(style) )
 {

+  // TODO

 };
 
 bool wxWindowDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
 {
 };
 
 bool wxWindowDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const
 {

+  // TODO

   return FALSE;
 };
 
 void wxWindowDC::DrawLine( long x1, long y1, long x2, long y2 )
 {
   if (!Ok()) return;
   return FALSE;
 };
 
 void wxWindowDC::DrawLine( long x1, long y1, long x2, long y2 )
 {
   if (!Ok()) return;

-#if 0  
+

   int x1d, y1d, x2d, y2d;
 
   int x1d, y1d, x2d, y2d;
 

-  /* MATTHEW: [7] Implement GetPixel */
-  FreeGetPixelCache();
+  //  FreeGetPixelCache();

 
   x1d = XLOG2DEV(x1);
   y1d = YLOG2DEV(y1);
   x2d = XLOG2DEV(x2);
   y2d = YLOG2DEV(y2);
 
 
   x1d = XLOG2DEV(x1);
   y1d = YLOG2DEV(y1);
   x2d = XLOG2DEV(x2);
   y2d = YLOG2DEV(y2);
 

-  if (current_pen && autoSetting)
-    SetPen (current_pen);
-  XDrawLine (display, pixmap, gc, x1d, y1d, x2d, y2d);
+  if (m_autoSetting)
+    SetPen (m_pen);
+
+  XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, x1d, y1d, x2d, y2d);

 
 

-  if (canvas && canvas->is_retained)
-    XDrawLine (display, canvas->backingPixmap, gcBacking, 
-              XLOG2DEV_2(x1), YLOG2DEV_2(y1),
-              XLOG2DEV_2(x2), YLOG2DEV_2(y2));
+  if (m_window && m_window->GetBackingPixmap())
+    XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking, 
+           XLOG2DEV_2(x1), YLOG2DEV_2(y1),
+           XLOG2DEV_2(x2), YLOG2DEV_2(y2));

 
   CalcBoundingBox(x1, y1);
   CalcBoundingBox(x2, y2);
 
   CalcBoundingBox(x1, y1);
   CalcBoundingBox(x2, y2);

-#endif

 };
 
 void wxWindowDC::CrossHair( long x, long y )
 {
   if (!Ok()) return;
 };
 
 void wxWindowDC::CrossHair( long x, long y )
 {
   if (!Ok()) return;

-  
+
+  if (m_autoSetting)
+    SetPen (m_pen);
+
+  int xx = XLOG2DEV (x);
+  int yy = YLOG2DEV (y);
+  int ww, hh;
+  wxDisplaySize (&ww, &hh);
+  XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, yy,
+         ww, yy);
+  XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xx, 0,
+         xx, hh);
+
+  if (m_window && m_window->GetBackingPixmap())
+    {
+      xx = XLOG2DEV_2 (x);
+      yy = YLOG2DEV_2 (y);
+      XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+         0, yy,
+         ww, yy);
+      XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+         xx, 0,
+         xx, hh);
+    }

 };
 
 void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
 {
   if (!Ok()) return;
   
 };
 
 void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long yc )
 {
   if (!Ok()) return;
   

-  long xx1 = XLOG2DEV(x1); 
-  long yy1 = YLOG2DEV(y1);
-  long xx2 = XLOG2DEV(x2); 
-  long yy2 = YLOG2DEV(y2);
-  long xxc = XLOG2DEV((long)xc); 
-  long yyc = YLOG2DEV((long)yc);
-  double dx = xx1 - xxc; 
-  double dy = yy1 - yyc;
-  double radius = sqrt(dx*dx+dy*dy);
-  long   r      = (long)radius;
+//  FreeGetPixelCache();
+
+  int xx1 = XLOG2DEV (x1);
+  int yy1 = YLOG2DEV (y1);
+  int xx2 = XLOG2DEV (x2);
+  int yy2 = YLOG2DEV (y2);
+  int xxc = XLOG2DEV (xc);
+  int yyc = YLOG2DEV (yc);
+  int xxc_2 = XLOG2DEV_2 (xc);
+  int yyc_2 = YLOG2DEV_2 (yc);
+
+  long dx = xx1 - xxc;
+  long dy = yy1 - yyc;
+  double radius = sqrt (dx * dx + dy * dy);
+  long r = (long) radius;
+

   double radius1, radius2;
 
   double radius1, radius2;
 

-  if (xx1 == xx2 && yy1 == yy2) 
-  {
-    radius1 = 0.0;
-    radius2 = 360.0;
-  } 
-  else 
-  if (radius == 0.0) 
-  {
+  if (xx1 == xx2 && yy1 == yy2)
+    {
+      radius1 = 0.0;
+      radius2 = 360.0;
+    }
+  else if (radius == 0.0)

     radius1 = radius2 = 0.0;
     radius1 = radius2 = 0.0;

-  } 
-  else 
-  {
-    radius1 = (xx1 - xxc == 0) ?
-           (yy1 - yyc < 0) ? 90.0 : -90.0 :
-           -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG;
-    radius2 = (xx2 - xxc == 0) ?
-           (yy2 - yyc < 0) ? 90.0 : -90.0 :
-           -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG;
-  };
-  long alpha1 = long(radius1 * 64.0);
-  long alpha2 = long((radius2 - radius1) * 64.0);
-  while (alpha2 <= 0) alpha2 += 360*64;
-  while (alpha1 > 360*64) alpha1 -= 360*64;
-
-  if (m_brush.GetStyle() != wxTRANSPARENT) {};
-    
-  if (m_pen.GetStyle() != wxTRANSPARENT) {};
-  
+  else
+    {
+      if (xx1 - xxc == 0)
+    if (yy1 - yyc < 0)
+      radius1 = 90.0;
+    else
+      radius1 = -90.0;
+      else
+    radius1 = -atan2 ((double) (yy1 - yyc), (double) (xx1 - xxc)) * 360.0 / (2 * M_PI);
+
+      if (xx2 - xxc == 0)
+    if (yy2 - yyc < 0)
+      radius2 = 90.0;
+    else
+      radius2 = -90.0;
+      else
+    radius2 = -atan2 ((double) (yy2 - yyc), (double) (xx2 - xxc)) * 360.0 / (2 * M_PI);
+    }
+  radius1 *= 64.0;
+  radius2 *= 64.0;
+  int alpha1 = (int) radius1;
+  int alpha2 = (int) (radius2 - radius1);
+  while (alpha2 <= 0)
+    alpha2 += 360 * 64;
+  while (alpha2 > 360 * 64)
+    alpha2 -= 360 * 64;
+
+  if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    {
+      SetBrush (m_brush);
+      XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) (GC) m_gc,
+        xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
+
+      if (m_window && m_window->GetBackingPixmap())
+      XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+         xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
+
+    }
+
+  if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    {
+        if (m_autoSetting)
+            SetPen (m_pen);
+      XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc,
+           xxc - r, yyc - r, 2 * r, 2 * r, alpha1, alpha2);
+
+      if (m_window && m_window->GetBackingPixmap())
+        XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+           xxc_2 - r, yyc_2 - r, 2 * r, 2 * r, alpha1, alpha2);
+    }
+  CalcBoundingBox (x1, y1);
+  CalcBoundingBox (x2, y2);

 };
 
 void wxWindowDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
 {
   if (!Ok()) return;
   
 };
 
 void wxWindowDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea )
 {
   if (!Ok()) return;
   

-  long xx = XLOG2DEV(x);    
-  long yy = YLOG2DEV(y);
-  long ww = m_signX * XLOG2DEVREL(width); 
-  long hh = m_signY * YLOG2DEVREL(height);
-  
-  // CMB: handle -ve width and/or height
-  if (ww < 0) { ww = -ww; xx = xx - ww; }
-  if (hh < 0) { hh = -hh; yy = yy - hh; }
-  
-  long start = long(sa * 64.0);
-  long end = long(ea * 64.0);
-  if (m_brush.GetStyle() != wxTRANSPARENT) {};
-  
-  if (m_pen.GetStyle() != wxTRANSPARENT) {};
+  int xd, yd, wd, hd;
+
+  xd = XLOG2DEV(x);
+  yd = YLOG2DEV(y);
+  wd = XLOG2DEVREL(width);
+  hd = YLOG2DEVREL(height);
+
+  if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
+  if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
+  int start = int(sa*64);
+  int end   = int(ea*64);
+  if (start<0) start+=360*64;
+  if (end  <0) end  +=360*64;
+  if (end>start) end-=start;
+  else end+=360*64-start;
+
+  if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    {
+      m_autoSetting = TRUE;    // must be reset
+
+      SetBrush (m_brush);
+      XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start, end);
+
+      if (m_window && m_window->GetBackingPixmap())
+       XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+          XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
+    }
+
+  if (!m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    {
+      if (m_autoSetting)
+    SetPen (m_pen);
+      XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, start,end);
+      if (m_window && m_window->GetBackingPixmap())
+        XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+          XLOG2DEV_2 (x), YLOG2DEV_2 (y),wd,hd,start,end);
+    }
+  CalcBoundingBox (x, y);
+  CalcBoundingBox (x + width, y + height);

 };
 
 void wxWindowDC::DrawPoint( long x, long y )
 {
   if (!Ok()) return;
   
 };
 
 void wxWindowDC::DrawPoint( long x, long y )
 {
   if (!Ok()) return;
   

-  if (m_pen.GetStyle() != wxTRANSPARENT) {};
+//  FreeGetPixelCache();
+
+  if (m_pen.Ok() && m_autoSetting)
+    SetPen (m_pen);
+
+  XDrawPoint ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y));
+  if (m_window && m_window->GetBackingPixmap())
+    XDrawPoint ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, XLOG2DEV_2 (x), YLOG2DEV_2 (y));
+
+  CalcBoundingBox (x, y);

 };
 
 void wxWindowDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset )
 {
   if (!Ok()) return;
   
 };
 
 void wxWindowDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset )
 {
   if (!Ok()) return;
   

-  if (m_pen.GetStyle() == wxTRANSPARENT) return;
-  
-  for (int i = 0; i < n-1; i++)
-  {
-    long x1 = XLOG2DEV(points[i].x + xoffset);
-    long x2 = XLOG2DEV(points[i+1].x + xoffset);
-    long y1 = YLOG2DEV(points[i].y + yoffset);     // oh, what a waste
-    long y2 = YLOG2DEV(points[i+1].y + yoffset);
-  };
+//  FreeGetPixelCache();
+
+  if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    {
+      if (m_autoSetting)
+    SetPen (m_pen);
+
+      XPoint *xpoints = new XPoint[n];
+      int i;
+
+      for (i = 0; i < n; i++)
+    {
+      xpoints[i].x = XLOG2DEV (points[i].x + xoffset);
+      xpoints[i].y = YLOG2DEV (points[i].y + yoffset);
+    }
+      XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints, n, 0);
+
+    if (m_window && m_window->GetBackingPixmap())
+    {
+      for (i = 0; i < n; i++)
+        {
+          xpoints[i].x = XLOG2DEV_2 (points[i].x + xoffset);
+          xpoints[i].y = YLOG2DEV_2 (points[i].y + yoffset);
+        }
+      XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints, n, 0);
+    }
+    delete[]xpoints;
+  }

 };
 
 };
 

-void wxWindowDC::DrawLines( wxList *points, long xoffset, long yoffset )
+void wxWindowDC::DrawLines( wxList *list, long xoffset, long yoffset )

 {
   if (!Ok()) return;
   
   if (m_pen.GetStyle() == wxTRANSPARENT) return;
   
 {
   if (!Ok()) return;
   
   if (m_pen.GetStyle() == wxTRANSPARENT) return;
   

-  wxNode *node = points->First();
-  while (node->Next())
-  {
-    wxPoint *point = (wxPoint*)node->Data();
-    wxPoint *npoint = (wxPoint*)node->Next()->Data();
-    long x1 = XLOG2DEV(point->x + xoffset);
-    long x2 = XLOG2DEV(npoint->x + xoffset);
-    long y1 = YLOG2DEV(point->y + yoffset);    // and again...
-    long y2 = YLOG2DEV(npoint->y + yoffset);
-    node = node->Next();
-  };
+  int n = list->Number();
+  wxPoint *points = new wxPoint[n];
+
+  int i = 0;
+  for(wxNode *node = list->First(); node; node = node->Next()) {
+    wxPoint *point = (wxPoint *)node->Data();
+    points[i].x = point->x;
+    points[i++].y = point->y;
+  }
+  DrawLines(n, points, xoffset, yoffset);
+  delete []points;

 };
 
 };
 

-void wxWindowDC::DrawPolygon( int WXUNUSED(n), wxPoint WXUNUSED(points)[], 
-  long WXUNUSED(xoffset), long WXUNUSED(yoffset), int WXUNUSED(fillStyle) )
+void wxWindowDC::DrawPolygon( int n, wxPoint points[],
+  long xoffset, long yoffset, int fillStyle )

 {
 {

-  if (!Ok()) return;
+//  FreeGetPixelCache();
+
+  XPoint *xpoints1 = new XPoint[n + 1];
+  XPoint *xpoints2 = new XPoint[n + 1];
+  int i;
+  for (i = 0; i < n; i++)
+    {
+      xpoints1[i].x = XLOG2DEV (points[i].x + xoffset);
+      xpoints1[i].y = YLOG2DEV (points[i].y + yoffset);
+      xpoints2[i].x = XLOG2DEV_2 (points[i].x + xoffset);
+      xpoints2[i].y = YLOG2DEV_2 (points[i].y + yoffset);
+      CalcBoundingBox (points[i].x + xoffset, points[i].y + yoffset);
+    }
+
+  // Close figure for XDrawLines (not needed for XFillPolygon)
+  xpoints1[i].x = xpoints1[0].x;
+  xpoints1[i].y = xpoints1[0].y;
+  xpoints2[i].x = xpoints2[0].x;
+  xpoints2[i].y = xpoints2[0].y;
+
+  if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    {
+      SetBrush (m_brush);
+      XSetFillRule ((Display*) m_display, (GC) m_gc, fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
+      XFillPolygon ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n, Complex, 0);
+      XSetFillRule ((Display*) m_display, (GC) m_gc, EvenOddRule);    // default mode
+      if (m_window && m_window->GetBackingPixmap())
+      {
+         XSetFillRule ((Display*) m_display,(GC) m_gcBacking,
+             fillStyle == wxODDEVEN_RULE ? EvenOddRule : WindingRule);
+         XFillPolygon ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n, Complex, 0);
+         XSetFillRule ((Display*) m_display,(GC) m_gcBacking, EvenOddRule);    // default mode
+      }
+  }
+
+  if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    {
+      if (m_autoSetting)
+        SetPen (m_pen);
+      XDrawLines ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xpoints1, n + 1, 0);
+
+      if (m_window && m_window->GetBackingPixmap())
+        XDrawLines ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, xpoints2, n + 1, 0);
+    }
+
+  delete[]xpoints1;
+  delete[]xpoints2;

 };
 
 };
 

-void wxWindowDC::DrawPolygon( wxList *WXUNUSED(lines), long WXUNUSED(xoffset), 
-                             long WXUNUSED(yoffset), int WXUNUSED(fillStyle) )
+void wxWindowDC::DrawPolygon( wxList *list, long xoffset,
+                             long yoffset, int fillStyle )

 {
   if (!Ok()) return;
 {
   if (!Ok()) return;

+
+  int n = list->Number();
+  wxPoint *points = new wxPoint[n];
+
+  int i = 0;
+  for(wxNode *node = list->First(); node; node = node->Next()) {
+    wxPoint *point = (wxPoint *)node->Data();
+    points[i].x = point->x;
+    points[i++].y = point->y;
+  }
+  DrawPolygon(n, points, xoffset, yoffset,fillStyle);
+  delete[] points;

 };
 
 void wxWindowDC::DrawRectangle( long x, long y, long width, long height )
 {
   if (!Ok()) return;
 
 };
 
 void wxWindowDC::DrawRectangle( long x, long y, long width, long height )
 {
   if (!Ok()) return;
 

-  long xx = XLOG2DEV(x);
-  long yy = YLOG2DEV(y);
-  long ww = m_signX * XLOG2DEVREL(width);
-  long hh = m_signY * YLOG2DEVREL(height);
-    
-  // CMB: draw nothing if transformed w or h is 0
-  if (ww == 0 || hh == 0) return;
+//  FreeGetPixelCache();

 
 

-  // CMB: handle -ve width and/or height
-  if (ww < 0) { ww = -ww; xx = xx - ww; }
-  if (hh < 0) { hh = -hh; yy = yy - hh; }
+  int xd, yd, wfd, hfd, wd, hd;

 
 

-  if (m_brush.GetStyle() != wxTRANSPARENT) {};
-    
-  if (m_pen.GetStyle() != wxTRANSPARENT) {};
+  xd = XLOG2DEV(x);
+  yd = YLOG2DEV(y);
+  wfd = XLOG2DEVREL(width);
+  wd = wfd - WX_GC_CF;
+  hfd = YLOG2DEVREL(height);
+  hd = hfd - WX_GC_CF;
+
+  if (wfd == 0 || hfd == 0) return;
+  if (wd < 0) { wd = - wd; xd = xd - wd; }
+  if (hd < 0) { hd = - hd; yd = yd - hd; }
+
+  if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    {
+      SetBrush (m_brush);
+      XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wfd, hfd);
+
+      if (m_window && m_window->GetBackingPixmap())
+    XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            XLOG2DEV_2 (x), YLOG2DEV_2 (y),
+            wfd, hfd);
+    }
+
+  if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    {
+      if (m_autoSetting)
+    SetPen (m_pen);
+      XDrawRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd);
+
+      if (m_window && m_window->GetBackingPixmap())
+    XDrawRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            XLOG2DEV_2 (x), YLOG2DEV_2 (y),
+            wd, hd);
+    }
+  CalcBoundingBox (x, y);
+  CalcBoundingBox (x + width, y + height);

 };
 
 void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius )
 {
   if (!Ok()) return;
   
 };
 
 void wxWindowDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius )
 {
   if (!Ok()) return;
   

+//  FreeGetPixelCache();
+
+  // If radius is negative, it's a proportion of the smaller dimension.
+

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

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

 
 

-  // CMB: handle -ve width and/or height
-  if (ww < 0) { ww = -ww; xx = xx - ww; }
-  if (hh < 0) { hh = -hh; yy = yy - hh; }
+  int xd = XLOG2DEV (x);
+  int yd = YLOG2DEV (y);
+  int rd = XLOG2DEVREL ((long) radius);
+  int wd = XLOG2DEVREL (width) - WX_GC_CF;
+  int hd = YLOG2DEVREL (height) - WX_GC_CF;
+
+  int rw_d = rd * 2;
+  int rh_d = rw_d;

 
 

-  // CMB: if radius is zero use DrawRectangle() instead to avoid
+  // If radius is zero use DrawRectangle() instead to avoid

   // X drawing errors with small radii
   // X drawing errors with small radii

-  if (rr == 0)
+  if (rd == 0)

   {
     DrawRectangle( x, y, width, height );
     return;
   }
 
   {
     DrawRectangle( x, y, width, height );
     return;
   }
 

-  // CMB: draw nothing if transformed w or h is 0
-  if (ww == 0 || hh == 0) return;
+  // Draw nothing if transformed w or h is 0
+  if (wd == 0 || hd == 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)
   {

-    ww--;
-    hh--;
+    wd--;
+    hd--;

   }
 
   // CMB: ensure dd is not larger than rectangle otherwise we
   // get an hour glass shape
   }
 
   // CMB: ensure dd is not larger than rectangle otherwise we
   // get an hour glass shape

-  long dd = 2 * rr;
-  if (dd > ww) dd = ww;
-  if (dd > hh) dd = hh;
-  rr = dd / 2;
+  if (rw_d > wd) rw_d = wd;
+  if (rw_d > hd) rw_d = hd;
+  rd = rw_d / 2;

 
 

-  if (m_brush.GetStyle() != wxTRANSPARENT)
+  // For backing pixmap
+  int xd2 = XLOG2DEV_2 (x);
+  int yd2 = YLOG2DEV_2 (y);
+  int rd2 = XLOG2DEVREL ((long) radius);
+  int wd2 = XLOG2DEVREL (width) ;
+  int hd2 = YLOG2DEVREL (height) ;
+
+  int rw_d2 = rd2 * 2;
+  int rh_d2 = rw_d2;
+
+  if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)

   {
   {

-  };
-  
-  if (m_pen.GetStyle() != wxTRANSPARENT)
+      SetBrush (m_brush);
+
+      XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
+              wd - rw_d, hd);
+      XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
+              wd, hd - rh_d);
+
+      // Arcs start from 3 o'clock, positive angles anticlockwise
+      // Top-left
+      XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,
+        rw_d, rh_d, 90 * 64, 90 * 64);
+      // Top-right
+      XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d, yd,
+//        rw_d, rh_d, 0, 90 * 64);
+        rw_d, rh_d, 0, 91 * 64);
+      // Bottom-right
+      XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d,
+        yd + hd - rh_d,
+//        rw_d, rh_d, 270 * 64, 90 * 64);
+        rw_d, rh_d, 269 * 64, 92 * 64);
+      // Bottom-left
+      XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
+        rw_d, rh_d, 180 * 64, 90 * 64);
+
+    if (m_window && m_window->GetBackingPixmap())
+    {
+      XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+              xd2 + rd2, yd2, wd2 - rw_d2, hd2);
+      XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+              xd2, yd2 + rd2, wd2, hd2 - rh_d2);
+
+      XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+       xd2, yd2, rw_d2, rh_d2, 90 * 64, 90 * 64);
+      XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            xd2 + wd2 - rw_d2, yd2,
+//            rw_d2, rh_d2, 0, 90 * 64);
+            rw_d2, rh_d2, 0, 91 * 64);
+      XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            xd2 + wd2 - rw_d2,
+            yd2 + hd2 - rh_d2,
+//            rw_d2, rh_d2, 270 * 64, 90 * 64);
+            rw_d2, rh_d2, 269 * 64, 92 * 64);
+      XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            xd2, yd2 + hd2 - rh_d2,
+            rw_d2, rh_d2, 180 * 64, 90 * 64);
+    }
+  }
+
+  if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)

   {
   {

-  };
+      SetPen (m_pen);
+      XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd,
+         xd + wd - rd + 1, yd);
+      XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + rd, yd + hd,
+         xd + wd - rd, yd + hd);
+
+      XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + rd,
+         xd, yd + hd - rd);
+      XDrawLine ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd, yd + rd,
+         xd + wd, yd + hd - rd + 1);
+      XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd,
+        rw_d, rh_d, 90 * 64, 90 * 64);
+      XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d, yd,
+//        rw_d, rh_d, 0, 90 * 64);
+        rw_d, rh_d, 0, 91 * 64);
+      XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd + wd - rw_d,
+        yd + hd - rh_d,
+        rw_d, rh_d, 269 * 64, 92 * 64);
+      XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd + hd - rh_d,
+        rw_d, rh_d, 180 * 64, 90 * 64);
+
+      if (m_window && m_window->GetBackingPixmap())
+    {
+      XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+             xd2 + rd2, yd2,
+             xd2 + wd2 - rd2 + 1, yd2);
+      XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+             xd2 + rd2, yd2 + hd2,
+          xd2 + wd2 - rd2, yd2 + hd2);
+
+      XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+             xd2, yd2 + rd2,
+             xd2, yd2 + hd2 - rd2);
+      XDrawLine ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+             xd2 + wd2, yd2 + rd2,
+          xd2 + wd2, yd2 + hd2 - rd2 + 1);
+      XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            xd2, yd2,
+            rw_d2, rh_d2, 90 * 64, 90 * 64);
+      XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            xd2 + wd2 - rw_d2, yd2,
+//            rw_d2, rh_d2, 0, 90 * 64);
+            rw_d2, rh_d2, 0, 91 * 64);
+      XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            xd2 + wd2 - rw_d2,
+            yd2 + hd2 - rh_d2,
+            rw_d2, rh_d2, 269 * 64, 92 * 64);
+      XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            xd2, yd2 + hd2 - rh_d2,
+            rw_d2, rh_d2, 180 * 64, 90 * 64);
+    }
+  }
+  CalcBoundingBox (x, y);
+  CalcBoundingBox (x + width, y + height);
+
+

 };
 
 void wxWindowDC::DrawEllipse( long x, long y, long width, long height )
 {
   if (!Ok()) return;
   
 };
 
 void wxWindowDC::DrawEllipse( long x, long y, long width, long height )
 {
   if (!Ok()) return;
   

-  long xx = XLOG2DEV(x);    
-  long yy = YLOG2DEV(y);
-  long ww = m_signX * XLOG2DEVREL(width); 
-  long hh = m_signY * YLOG2DEVREL(height);
-
-  // 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_brush.GetStyle() != wxTRANSPARENT) {};
-  
-  if (m_pen.GetStyle() != wxTRANSPARENT) {};
+  // Check for negative width and height
+  if (height < 0)
+  {
+    y = y + height;
+    height = - height ;
+  }
+
+  if (width < 0)
+  {
+    x = x + width;
+    width = - width ;
+  }
+
+//  FreeGetPixelCache();
+
+  static const int angle = 23040;
+
+  int xd, yd, wd, hd;
+
+  xd = XLOG2DEV(x);
+  yd = YLOG2DEV(y);
+  wd = XLOG2DEVREL(width) ;
+  hd = YLOG2DEVREL(height) ;
+
+  if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
+    {
+      SetBrush (m_brush);
+      XFillArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
+      if (m_window && m_window->GetBackingPixmap())
+        XFillArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+          XLOG2DEV_2 (x), YLOG2DEV_2 (y),
+          XLOG2DEVREL (width) - WX_GC_CF,
+          YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
+    }
+
+  if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+    {
+      if (m_autoSetting)
+    SetPen (m_pen);
+      XDrawArc ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, xd, yd, wd, hd, 0, angle);
+      if (m_window && m_window->GetBackingPixmap())
+        XDrawArc ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+          XLOG2DEV_2 (x), YLOG2DEV_2 (y),
+          XLOG2DEVREL (width) - WX_GC_CF,
+          YLOG2DEVREL (height) - WX_GC_CF, 0, angle);
+    }
+  CalcBoundingBox (x, y);
+  CalcBoundingBox (x + width, y + height);
+

 };
 
 bool wxWindowDC::CanDrawBitmap(void) const
 };
 
 bool wxWindowDC::CanDrawBitmap(void) const


@@ -350,54 +761,441 @@ bool wxWindowDC::CanDrawBitmap(void) const
   return TRUE;
 };
 
   return TRUE;
 };
 

+/* Used when copying between drawables on different (Display*) m_displays.
+   Not very fast, but better than giving up.
+ */
+
+static void XCopyRemote(Display *src_display, Display *dest_display,
+            Drawable src, Drawable dest,
+            GC destgc,
+            int srcx, int srcy,
+            unsigned int w, unsigned int h,
+            int destx, int desty,
+            bool more, XImage **cache)
+{
+  XImage *image, *destimage;
+  Colormap destcm, srccm;
+#define CACHE_SIZE 256
+  unsigned int i, j;
+  unsigned long cachesrc[CACHE_SIZE], cachedest[CACHE_SIZE];
+  int k, cache_pos, all_cache;
+
+  if (!cache || !*cache)
+    image = XGetImage(src_display, src, srcx, srcy, w, h, AllPlanes, ZPixmap);
+  else
+    image = *cache;
+
+  destimage = XGetImage(dest_display, dest, destx, desty, w, h, AllPlanes, ZPixmap);
+
+  srccm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) src_display);
+  destcm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dest_display);
+
+  cache_pos = 0;
+  all_cache = FALSE;
+
+  for (i = 0; i < w; i++)
+    for (j = 0; j < h; j++) {
+      unsigned long pixel;
+      XColor xcol;
+
+      pixel = XGetPixel(image, i, j);
+      for (k = cache_pos; k--; )
+    if (cachesrc[k] == pixel) {
+      pixel = cachedest[k];
+      goto install;
+    }
+      if (all_cache)
+    for (k = CACHE_SIZE; k-- > cache_pos; )
+      if (cachesrc[k] == pixel) {
+        pixel = cachedest[k];
+        goto install;
+      }
+
+      cachesrc[cache_pos] = xcol.pixel = pixel;
+      XQueryColor(src_display, srccm, &xcol);
+      if (!XAllocColor(dest_display, destcm, &xcol))
+    xcol.pixel = 0;
+      cachedest[cache_pos] = pixel = xcol.pixel;
+      
+      if (++cache_pos >= CACHE_SIZE) {
+    cache_pos = 0;
+    all_cache = TRUE;
+      }
+
+    install:
+      XPutPixel(destimage, i, j, pixel);
+    }
+
+  XPutImage(dest_display, dest, destgc, destimage, 0, 0, destx, desty, w, h);
+  XDestroyImage(destimage);
+
+  if (more)
+    *cache = image;
+  else
+    XDestroyImage(image);
+}
+

 void wxWindowDC::DrawIcon( const wxIcon &icon, long x, long y, bool useMask )
 {
   if (!Ok()) return;
   
   if (!icon.Ok()) return;
   
 void wxWindowDC::DrawIcon( const wxIcon &icon, long x, long y, bool useMask )
 {
   if (!Ok()) return;
   
   if (!icon.Ok()) return;
   

-  int xx = XLOG2DEV(x);
-  int yy = YLOG2DEV(y);
-  
+//  FreeGetPixelCache();
+
+  // Be sure that foreground pixels (1) of
+  // the Icon will be painted with pen colour. [m_pen.SetColour()]
+  // Background pixels (0) will be painted with
+  // last selected background color. [::SetBackground]
+  if (m_pen.Ok() && m_autoSetting)
+    SetPen (m_pen);
+
+  int width, height;
+  Pixmap iconPixmap = (Pixmap) icon.GetPixmap();
+  width = icon.GetWidth();
+  height = icon.GetHeight();
+  if (icon.GetDisplay() == m_display)
+  {
+   if (icon.GetDepth() <= 1)
+   {
+       XCopyPlane  ((Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
+                    0, 0, width, height,
+                    (int) XLOG2DEV (x), (int) YLOG2DEV (y), 1);
+   }
+   else
+   {
+       XCopyArea  ((Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
+                  0, 0, width, height,
+                  (int) XLOG2DEV (x), (int) YLOG2DEV (y));
+   }
+
+
+  if (m_window && m_window->GetBackingPixmap())
+  {
+     if (icon.GetDepth() <= 1)
+     {
+        XCopyPlane ((Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+          0, 0, width, height, (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y), 1);
+     }
+     else
+     {
+       XCopyArea  ((Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+                  0, 0, width, height,
+                  (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y));
+     }
+  }
+  } else { /* Remote copy (different (Display*) m_displays) */
+    XImage *cache = NULL;
+    if (m_window && m_window->GetBackingPixmap())
+      XCopyRemote((Display*) icon.GetDisplay(), (Display*) m_display, iconPixmap, (Pixmap) m_window->GetBackingPixmap(),
+         (GC) m_gcBacking, 0, 0, width, height,
+          (int) XLOG2DEV_2 (x), (int) YLOG2DEV_2 (y), TRUE, &cache);
+    XCopyRemote((Display*) icon.GetDisplay(), (Display*) m_display, iconPixmap, (Pixmap) m_pixmap, (GC) m_gc,
+        0, 0, width, height,
+        (int) XLOG2DEV (x), (int) YLOG2DEV (y), FALSE, &cache);
+  }
+  CalcBoundingBox (x, y);
+

 };
 
 bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,
 };
 
 bool wxWindowDC::Blit( long xdest, long ydest, long width, long height,

-       wxDC *source, long xsrc, long ysrc, int WXUNUSED(logical_func), bool WXUNUSED(useMask) )
+       wxDC *source, long xsrc, long ysrc, int rop, bool useMask )

 {
   if (!Ok()) return FALSE;
 {
   if (!Ok()) return FALSE;

+
+  wxASSERT_MSG( (source->IsKindOf(CLASSINFO(wxWindowDC))), "Blit source DC must be wxWindowDC or derived class." );
+
+  wxWindowDC* sourceDC = (wxWindowDC*) source;

   
   

-  // CMB 20/5/98: add blitting of bitmaps
-  if (source->IsKindOf(CLASSINFO(wxMemoryDC)))
-  {
-    wxMemoryDC* srcDC = (wxMemoryDC*)source;
-    /*
-     GdkBitmap* bmap = srcDC->m_selected.GetBitmap();
-    if (bmap)
-    {
-      gdk_draw_bitmap (
-          m_window,
-          m_textGC,
-          bmap,
-          source->DeviceToLogicalX(xsrc), source->DeviceToLogicalY(ysrc),
-          XLOG2DEV(xdest), YLOG2DEV(ydest),
-          source->DeviceToLogicalXRel(width), source->DeviceToLogicalYRel(height)
-          );
-      return TRUE;
-    }
-    */
-  }
+//  FreeGetPixelCache();

 
 

-  return TRUE;
+  // Be sure that foreground pixels (1) of
+  // the Icon will be painted with pen colour. [m_pen.SetColour()]
+  // Background pixels (0) will be painted with
+  // last selected background color. [::SetBackground]
+  if (m_pen.Ok() && m_autoSetting)
+    SetPen (m_pen);
+
+  if (m_pixmap && sourceDC->m_pixmap)
+    {
+      /* MATTHEW: [9] */
+      int orig = m_logicalFunction;
+
+      SetLogicalFunction (rop);
+
+      if (m_display != sourceDC->m_display)
+      {
+        XImage *cache = NULL;
+
+        if (m_window && m_window->GetBackingPixmap())
+            XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display,
+              (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),
+             (GC) m_gcBacking,
+              source->LogicalToDeviceX (xsrc),
+              source->LogicalToDeviceY (ysrc),
+              source->LogicalToDeviceXRel(width),
+              source->LogicalToDeviceYRel(height),
+              XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest),
+              TRUE, &cache);
+
+        if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
+        {
+            wxMemoryDC *memDC = (wxMemoryDC *)source;
+            wxBitmap& sel = memDC->GetBitmap();
+            if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetPixmap() )
+            {
+                XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetPixmap());
+                XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
+            }
+        }
+
+        XCopyRemote((Display*) sourceDC->m_display, (Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
+            source->LogicalToDeviceX (xsrc),
+            source->LogicalToDeviceY (ysrc),
+            source->LogicalToDeviceXRel(width),
+            source->LogicalToDeviceYRel(height),
+            XLOG2DEV (xdest), YLOG2DEV (ydest),
+            FALSE, &cache);
+
+        if ( useMask )
+        {
+            XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
+            XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
+        }
+    
+    } else
+    {
+      if (m_window && m_window->GetBackingPixmap())
+      {
+// +++ MARKUS (mho@comnets.rwth-aachen): error on blitting bitmaps with depth 1
+        if (source->IsKindOf(CLASSINFO(wxMemoryDC)) && ((wxMemoryDC*) source)->GetBitmap().GetDepth() == 1)
+        {
+           XCopyPlane ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+                   source->LogicalToDeviceX (xsrc),
+                  source->LogicalToDeviceY (ysrc),
+                  source->LogicalToDeviceXRel(width),
+                  source->LogicalToDeviceYRel(height),
+                  XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest), 1);
+        }
+      else
+        {
+           XCopyArea ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+                  source->LogicalToDeviceX (xsrc),
+                 source->LogicalToDeviceY (ysrc),
+                 source->LogicalToDeviceXRel(width),
+                 source->LogicalToDeviceYRel(height),
+                 XLOG2DEV_2 (xdest), YLOG2DEV_2 (ydest));
+        }
+    }
+    if ( useMask && source->IsKindOf(CLASSINFO(wxMemoryDC)) )
+    {
+        wxMemoryDC *memDC = (wxMemoryDC *)source;
+        wxBitmap& sel = memDC->GetBitmap();
+        if ( sel.Ok() && sel.GetMask() && sel.GetMask()->GetPixmap() )
+        {
+            XSetClipMask   ((Display*) m_display, (GC) m_gc, (Pixmap) sel.GetMask()->GetPixmap());
+            XSetClipOrigin ((Display*) m_display, (GC) m_gc, XLOG2DEV (xdest), YLOG2DEV (ydest));
+        }
+    }
+
+      // Check if we're copying from a mono bitmap
+      if (source->IsKindOf(CLASSINFO(wxMemoryDC)) &&
+          ((wxMemoryDC*)source)->GetBitmap().Ok() && (((wxMemoryDC*)source)->GetBitmap().GetDepth () == 1))
+      {
+        XCopyPlane ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
+              source->LogicalToDeviceX (xsrc),
+              source->LogicalToDeviceY (ysrc),
+              source->LogicalToDeviceXRel(width),
+              source->LogicalToDeviceYRel(height),
+              XLOG2DEV (xdest), YLOG2DEV (ydest), 1);
+      }
+      else
+      {
+        XCopyArea ((Display*) m_display, (Pixmap) sourceDC->m_pixmap, (Pixmap) m_pixmap, (GC) m_gc,
+             source->LogicalToDeviceX (xsrc),
+             source->LogicalToDeviceY (ysrc),
+             source->LogicalToDeviceXRel(width),
+             source->LogicalToDeviceYRel(height),
+             XLOG2DEV (xdest), YLOG2DEV (ydest));
+
+      }
+    if ( useMask )
+    {
+        XSetClipMask   ((Display*) m_display, (GC) m_gc, None);
+        XSetClipOrigin ((Display*) m_display, (GC) m_gc, 0, 0);
+    }
+
+    } /* Remote/local (Display*) m_display */
+    CalcBoundingBox (xdest, ydest);
+    CalcBoundingBox (xdest + width, ydest + height);
+    
+    SetLogicalFunction(orig);
+
+    return TRUE;
+  }
+  return FALSE;

 };
 
 };
 

-void wxWindowDC::DrawText( const wxString &text, long x, long y, bool
-WXUNUSED(use16) )
+/* Helper function for 16-bit fonts */
+static int str16len(const char *s)
+{
+  int count = 0;
+
+  while (s[0] && s[1]) {
+    count++;
+    s += 2;
+  }
+
+  return count;
+}
+
+void wxWindowDC::DrawText( const wxString &text, long x, long y, bool use16 )

 {
   if (!Ok()) return;
 
 {
   if (!Ok()) return;
 

-};
+  // Since X draws from the baseline of the text, must
+  // add the text height
+  int cx = 0;
+  int cy = 0;
+  int ascent = 0;
+  int slen;
+
+  if (use16)
+    slen = str16len(text);
+  else
+    slen = strlen(text);
+
+  if (m_font.Ok())
+    {
+      WXFontStructPtr pFontStruct = m_font.FindOrCreateFontStruct(m_userScaleY*m_logicalScaleY);
+      int direction, descent;
+      XCharStruct overall_return;
+      if (use16)
+        (void)XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *)(const char*) text, slen, &direction,
+                 &ascent, &descent, &overall_return);
+      else
+        (void)XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) text, slen, &direction,
+               &ascent, &descent, &overall_return);
+      cx = overall_return.width;
+      cy = ascent + descent;
+    }
+
+  // First draw a rectangle representing the text background,
+  // if a text background is specified
+  if (m_textBackgroundColour.Ok () && (m_backgroundMode != wxTRANSPARENT))
+    {
+      wxColour oldPenColour = m_currentColour;
+      m_currentColour = m_textBackgroundColour;
+      bool sameColour = (oldPenColour.Ok () && m_textBackgroundColour.Ok () &&
+        (oldPenColour.Red () == m_textBackgroundColour.Red ()) &&
+          (oldPenColour.Blue () == m_textBackgroundColour.Blue ()) &&
+        (oldPenColour.Green () == m_textBackgroundColour.Green ()));
+
+      // This separation of the big && test required for gcc2.7/HP UX 9.02
+      // or pixel value can be corrupted!
+      sameColour = (sameColour &&
+           (oldPenColour.GetPixel() == m_textBackgroundColour.GetPixel()));
+
+      if (!sameColour || !GetOptimization())
+      {
+        int pixel = m_textBackgroundColour.AllocColour(m_display);
+        m_currentColour = m_textBackgroundColour;
+
+        // Set the GC to the required colour
+        if (pixel > -1)
+        {
+          XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
+          if (m_window && m_window->GetBackingPixmap())
+            XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+        }
+      }
+      else
+        m_textBackgroundColour = oldPenColour ;
+
+      XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y), cx, cy);
+      if (m_window && m_window->GetBackingPixmap())
+        XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking,
+            XLOG2DEV_2 (x), YLOG2DEV_2 (y), cx, cy);
+    }

 
 

+  // Now set the text foreground and draw the text
+  if (m_textForegroundColour.Ok ())
+  {
+      wxColour oldPenColour = m_currentColour;
+      m_currentColour = m_textForegroundColour;
+      bool sameColour = (oldPenColour.Ok () && m_currentColour.Ok () &&
+              (oldPenColour.Red () == m_currentColour.Red ()) &&
+               (oldPenColour.Blue () == m_currentColour.Blue ()) &&
+             (oldPenColour.Green () == m_currentColour.Green ()) &&
+              (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
+
+      if (!sameColour || !GetOptimization())
+      {
+        int pixel = -1;
+        if (!m_colour) // Mono display
+        {
+          // Unless foreground is really white, draw it in black
+          unsigned char red = m_textForegroundColour.Red ();
+          unsigned char blue = m_textForegroundColour.Blue ();
+          unsigned char green = m_textForegroundColour.Green ();
+          if (red == (unsigned char) 255 && blue == (unsigned char) 255
+                && green == (unsigned char) 255)
+          {
+            m_currentColour = *wxWHITE;
+            pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
+            m_currentColour.SetPixel(pixel);
+            m_textForegroundColour.SetPixel(pixel);
+          }
+          else
+          {
+            m_currentColour = *wxBLACK;
+            pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
+            m_currentColour.SetPixel(pixel);
+            m_textForegroundColour.SetPixel(pixel);
+          }
+        }
+        else
+        {
+            pixel = m_textForegroundColour.AllocColour((Display*) m_display);
+            m_currentColour.SetPixel(pixel);
+        }
+
+        // Set the GC to the required colour
+        if (pixel > -1)
+        {
+            XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
+            if (m_window && m_window->GetBackingPixmap())
+              XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+        }
+      }
+      else
+        m_textForegroundColour = oldPenColour;
+  }

 
 

+  // We need to add the ascent, not the whole height, since X draws
+  // at the point above the descender.
+  if (use16)
+    XDrawString16((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, 
+          (XChar2b *)(char*) (const char*) text, slen);
+  else
+    XDrawString((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, XLOG2DEV (x), YLOG2DEV (y) + ascent, 
+        text, slen);
+
+  if (m_window && m_window->GetBackingPixmap()) {
+    if (use16)
+      XDrawString16((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+            XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent,
+            (XChar2b *)(char*) (const char*) text, slen);
+    else
+      XDrawString((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(), (GC) m_gcBacking,
+          XLOG2DEV_2 (x), YLOG2DEV_2 (y) + ascent, (char*) (const char*) text, slen);
+  }
+
+  long w, h;
+  GetTextExtent (text, &w, &h);
+  CalcBoundingBox (x + w, y + h);
+  CalcBoundingBox (x, y);
+};

 
 bool wxWindowDC::CanGetTextExtent(void) const
 {
 
 bool wxWindowDC::CanGetTextExtent(void) const
 {


@@ -405,29 +1203,117 @@ bool wxWindowDC::CanGetTextExtent(void) const
 };
 
 void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height,
 };
 
 void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height,

-                     long *WXUNUSED(descent), long *WXUNUSED(externalLeading),
-                     wxFont *WXUNUSED(theFont), bool WXUNUSED(use16) )
+                     long *descent, long *externalLeading,
+                     wxFont *font, bool use16 )

 {
   if (!Ok()) return;
 {
   if (!Ok()) return;

+
+  wxFont* theFont = font;
+  if (!theFont)
+     theFont = & m_font;

   
   

+  if (!theFont->Ok())
+  {
+    // TODO: this should be an error log function
+    cerr << "wxWindows warning - set a valid font before calling GetTextExtent!\n";
+    *width = -1;
+    *height = -1;
+    return;
+  }
+
+  WXFontStructPtr pFontStruct = theFont->FindOrCreateFontStruct(m_userScaleY*m_logicalScaleY);
+
+  int direction, ascent, descent2;
+  XCharStruct overall;
+  int slen;
+  
+  if (use16) slen = str16len(string); else slen = strlen(string);
+
+  if (use16)
+    XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
+           &ascent, &descent2, &overall);
+  else
+     XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
+         &ascent, &descent2, &overall);
+
+  *width = XDEV2LOGREL (overall.width);
+  *height = YDEV2LOGREL (ascent + descent2);
+  if (descent)
+    *descent = descent2;
+  if (externalLeading)
+    *externalLeading = 0;

 };
 
 long wxWindowDC::GetCharWidth(void)
 {
   if (!Ok()) return 0;
 };
 
 long wxWindowDC::GetCharWidth(void)
 {
   if (!Ok()) return 0;

-  return 0;
+
+  if (!m_font.Ok())
+    return 0;
+
+  WXFontStructPtr pFontStruct = m_font.FindOrCreateFontStruct(m_userScaleY * m_logicalScaleY);
+
+  int direction, ascent, descent;
+  XCharStruct overall;
+  XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
+        &descent, &overall);
+  return XDEV2LOGREL(overall.width);

 };
 
 long wxWindowDC::GetCharHeight(void)
 {
   if (!Ok()) return 0;
 };
 
 long wxWindowDC::GetCharHeight(void)
 {
   if (!Ok()) return 0;

-  return 0;
+
+  if (!m_font.Ok())
+    return 0;
+
+  WXFontStructPtr pFontStruct = m_font.FindOrCreateFontStruct(m_userScaleY*m_logicalScaleY);
+
+  int direction, ascent, descent;
+  XCharStruct overall;
+  XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
+        &descent, &overall);
+//  return XDEV2LOGREL(overall.ascent + overall.descent);
+  return XDEV2LOGREL(ascent + descent);

 };
 
 void wxWindowDC::Clear(void)
 {
   if (!Ok()) return;
   
 };
 
 void wxWindowDC::Clear(void)
 {
   if (!Ok()) return;
   

+  int w, h;
+  if (m_window)
+    {
+      // TODO: should we get the virtual size?
+      m_window->GetSize(&w, &h);
+
+      if (m_window && m_window->GetBackingPixmap())
+      {
+        w = m_window->GetPixmapWidth();
+        h = m_window->GetPixmapHeight();
+      }
+    }
+  else
+    {
+        if (this->IsKindOf(CLASSINFO(wxMemoryDC)))
+        {
+           wxMemoryDC* memDC = (wxMemoryDC*) this;
+           w = memDC->GetBitmap().GetWidth();
+           h = memDC->GetBitmap().GetHeight();
+       }
+        else
+          return;
+    }
+
+  wxBrush saveBrush = m_brush;
+  SetBrush (m_backgroundBrush);
+
+  XFillRectangle ((Display*) m_display, (Pixmap) m_pixmap, (GC) m_gc, 0, 0, w, h);
+
+  if (m_window && m_window->GetBackingPixmap())
+    XFillRectangle ((Display*) m_display, (Pixmap) m_window->GetBackingPixmap(),(GC) m_gcBacking, 0, 0, w, h);
+
+  m_brush = saveBrush;

 };
 
 void wxWindowDC::SetFont( const wxFont &font )
 };
 
 void wxWindowDC::SetFont( const wxFont &font )


@@ -435,46 +1321,597 @@ void wxWindowDC::SetFont( const wxFont &font )
   if (!Ok()) return;
   
   m_font = font;
   if (!Ok()) return;
   
   m_font = font;

+
+  if (!m_font.Ok())
+    return;
+
+  WXFontStructPtr pFontStruct = m_font.FindOrCreateFontStruct(m_userScaleY*m_logicalScaleY);
+
+  Font fontId = ((XFontStruct*)pFontStruct)->fid;
+  XSetFont ((Display*) m_display, (GC) m_gc, fontId);
+
+  if (m_window && m_window->GetBackingPixmap())
+      XSetFont ((Display*) m_display,(GC) m_gcBacking, fontId);

 };
 
 void wxWindowDC::SetPen( const wxPen &pen )
 {
   if (!Ok()) return;
 
 };
 
 void wxWindowDC::SetPen( const wxPen &pen )
 {
   if (!Ok()) return;
 

-  if (m_pen == pen) return;
-  

   m_pen = pen;
   m_pen = pen;

-  
-  if (!m_pen.Ok()) return;
+  if (m_pen.Ok())
+    return;
+
+  wxBitmap oldStipple = m_currentStipple;
+  int oldStyle = m_currentStyle;
+  int oldFill = m_currentFill;
+  int old_pen_width = m_currentPenWidth;
+  int old_pen_join = m_currentPenJoin;
+  int old_pen_cap = m_currentPenCap;
+  int old_pen_nb_dash = m_currentPenDashCount;
+  char *old_pen_dash = m_currentPenDash;
+
+  wxColour oldPenColour = m_currentColour;
+  m_currentColour = m_pen.GetColour ();
+  m_currentStyle = m_pen.GetStyle ();
+  m_currentFill = m_pen.GetStyle (); // TODO?
+  m_currentPenWidth = m_pen.GetWidth ();
+  m_currentPenJoin = m_pen.GetJoin ();
+  m_currentPenCap = m_pen.GetCap ();
+  m_currentPenDashCount = m_pen.GetDashCount();
+  m_currentPenDash = m_pen.GetDash();
+
+  if (m_currentStyle == wxSTIPPLE)
+    m_currentStipple = m_pen.GetStipple ();
+
+  bool sameStyle = (oldStyle == m_currentStyle &&
+             oldFill == m_currentFill &&
+             old_pen_join == m_currentPenJoin &&
+             old_pen_cap == m_currentPenCap &&
+             old_pen_nb_dash == m_currentPenDashCount &&
+             old_pen_dash == m_currentPenDash &&
+             old_pen_width == m_currentPenWidth);
+
+  bool sameColour = (oldPenColour.Ok () &&
+              (oldPenColour.Red () == m_currentColour.Red ()) &&
+              (oldPenColour.Blue () == m_currentColour.Blue ()) &&
+              (oldPenColour.Green () == m_currentColour.Green ()) &&
+              (oldPenColour.GetPixel() == m_currentColour.GetPixel()));
+
+  if (!sameStyle || !GetOptimization())
+    {
+      int scaled_width = (int) XLOG2DEVREL (m_pen.GetWidth ());
+      if (scaled_width < 0)
+        scaled_width = 0;
+
+      int style;
+      int join;
+      int cap;
+      static char dotted[] =
+      {2, 5};
+      static char short_dashed[] =
+      {4, 4};
+      static char long_dashed[] =
+      {4, 8};
+      static char dotted_dashed[] =
+      {6, 6, 2, 6};
+
+      // We express dash pattern in pen width unit, so we are
+      // independent of zoom factor and so on...
+      int req_nb_dash;
+      char *req_dash;
+
+      switch (m_pen.GetStyle ())
+      {
+        case wxUSER_DASH:
+          req_nb_dash = m_currentPenDashCount;
+          req_dash = m_currentPenDash;
+          style = LineOnOffDash;
+          break;
+        case wxDOT:
+          req_nb_dash = 2;
+          req_dash = dotted;
+          style = LineOnOffDash;
+          break;
+        case wxSHORT_DASH:
+          req_nb_dash = 2;
+          req_dash = short_dashed;
+          style = LineOnOffDash;
+          break;
+        case wxLONG_DASH:
+          req_nb_dash = 2;
+          req_dash = long_dashed;
+          style = LineOnOffDash;
+          break;
+        case wxDOT_DASH:
+          req_nb_dash = 4;
+          req_dash = dotted_dashed;
+          style = LineOnOffDash;
+          break;
+        case wxSTIPPLE:
+        case wxSOLID:
+        case wxTRANSPARENT:
+        default:
+          style = LineSolid;
+          req_dash = NULL;
+          req_nb_dash = 0;
+      }
+
+      if (req_dash && req_nb_dash)
+      {
+        char *real_req_dash = new char[req_nb_dash];
+        if (real_req_dash)
+        {
+          int factor = scaled_width == 0 ? 1 : scaled_width;
+          for (int i = 0; i < req_nb_dash; i++)
+          real_req_dash[i] = req_dash[i] * factor;
+          XSetDashes ((Display*) m_display, (GC) m_gc, 0, real_req_dash, req_nb_dash);
+
+          if (m_window && m_window->GetBackingPixmap())
+          XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, real_req_dash, req_nb_dash);
+          delete[]real_req_dash;
+        }
+        else
+        {
+          // No Memory. We use non-scaled dash pattern...
+          XSetDashes ((Display*) m_display, (GC) m_gc, 0, req_dash, req_nb_dash);
+
+          if (m_window && m_window->GetBackingPixmap())
+          XSetDashes ((Display*) m_display,(GC) m_gcBacking, 0, req_dash, req_nb_dash);
+        }
+      }
+
+      switch (m_pen.GetCap ())
+      {
+        case wxCAP_PROJECTING:
+          cap = CapProjecting;
+          break;
+        case wxCAP_BUTT:
+          cap = CapButt;
+          break;
+        case wxCAP_ROUND:
+        default:
+          cap = CapRound;
+          break;
+      }
+
+      switch (m_pen.GetJoin ())
+      {
+        case wxJOIN_BEVEL:
+          join = JoinBevel;
+          break;
+        case wxJOIN_MITER:
+          join = JoinMiter;
+          break;
+        case wxJOIN_ROUND:
+        default:
+          join = JoinRound;
+          break;
+      }
+
+      XSetLineAttributes ((Display*) m_display, (GC) m_gc, scaled_width, style, cap, join);
+
+      if (m_window && m_window->GetBackingPixmap())
+        XSetLineAttributes ((Display*) m_display,(GC) m_gcBacking, scaled_width, style, cap, join);
+    }
+
+    if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
+    {
+      Pixmap myStipple;
+
+      oldStipple = NULL;    // For later reset!!
+
+      switch (m_currentFill)
+      {
+        case wxBDIAGONAL_HATCH:
+          if (bdiag == (Pixmap) 0)
+            bdiag = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         bdiag_bits, bdiag_width, bdiag_height);
+          myStipple = bdiag;
+          break;
+        case wxFDIAGONAL_HATCH:
+          if (fdiag == (Pixmap) 0)
+            fdiag = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         fdiag_bits, fdiag_width, fdiag_height);
+          myStipple = fdiag;
+          break;
+        case wxCROSS_HATCH:
+          if (cross == (Pixmap) 0)
+            cross = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         cross_bits, cross_width, cross_height);
+          myStipple = cross;
+          break;
+        case wxHORIZONTAL_HATCH:
+          if (horiz == (Pixmap) 0)
+            horiz = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         horiz_bits, horiz_width, horiz_height);
+          myStipple = horiz;
+          break;
+        case wxVERTICAL_HATCH:
+          if (verti == (Pixmap) 0)
+            verti = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         verti_bits, verti_width, verti_height);
+          myStipple = verti;
+          break;
+        case wxCROSSDIAG_HATCH:
+        default:
+          if (cdiag == (Pixmap) 0)
+            cdiag = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         cdiag_bits, cdiag_width, cdiag_height);
+          myStipple = cdiag;
+          break;
+      }
+      XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
+
+      if (m_window && m_window->GetBackingPixmap())
+        XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
+    }
+    else if (m_currentStipple.Ok()
+       && ((m_currentStipple != oldStipple) || !GetOptimization()))
+    {
+      XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());
+
+      if (m_window && m_window->GetBackingPixmap())
+        XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
+    }
+
+    if ((m_currentFill != oldFill) || !GetOptimization())
+    {
+      int fill_style;
+
+      if (m_currentFill == wxSTIPPLE)
+        fill_style = FillStippled;
+      else if (IS_HATCH (m_currentFill))
+        fill_style = FillStippled;
+      else
+        fill_style = FillSolid;
+      XSetFillStyle ((Display*) m_display, (GC) m_gc, fill_style);
+      if (m_window && m_window->GetBackingPixmap())
+        XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, fill_style);
+    }
+
+    // must test m_logicalFunction, because it involves background!
+    if (!sameColour || !GetOptimization()
+      || ((m_logicalFunction == wxXOR) || (m_autoSetting & 0x2)))
+    {
+      int pixel = -1;
+      if (m_pen.GetStyle () == wxTRANSPARENT)
+        pixel = m_backgroundPixel;
+      else if (!m_colour)
+      {
+        unsigned char red = m_pen.GetColour ().Red ();
+        unsigned char blue = m_pen.GetColour ().Blue ();
+        unsigned char green = m_pen.GetColour ().Green ();
+        if (red == (unsigned char) 255 && blue == (unsigned char) 255
+            && green == (unsigned char) 255)
+        {
+          pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
+          m_currentColour = *wxWHITE;
+          m_pen.GetColour().SetPixel(pixel);
+          m_currentColour.SetPixel(pixel);
+        }
+        else
+        {
+          pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
+          m_currentColour = *wxBLACK;
+          m_pen.GetColour().SetPixel(pixel);
+        }
+      }
+      else
+      {
+        pixel = m_pen.GetColour ().AllocColour(m_display);
+        m_currentColour.SetPixel(pixel);
+      }
+
+      // Finally, set the GC to the required colour
+      if (pixel > -1)
+      {
+        if (m_logicalFunction == wxXOR)
+        {
+          XGCValues values;
+          XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
+          XSetForeground ((Display*) m_display, (GC) m_gc, pixel ^ values.background);
+          if (m_window && m_window->GetBackingPixmap())
+            XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel ^ values.background);
+        }
+      else
+        {
+          XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
+          if (m_window && m_window->GetBackingPixmap())
+            XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+        }
+    }
+  }
+  else
+    m_pen.GetColour().SetPixel(oldPenColour.GetPixel());
+
+  m_autoSetting = 0;

 };
 
 void wxWindowDC::SetBrush( const wxBrush &brush )
 {
   if (!Ok()) return;
   
 };
 
 void wxWindowDC::SetBrush( const wxBrush &brush )
 {
   if (!Ok()) return;
   

-  if (m_brush == brush) return;
-  

   m_brush = brush;
   m_brush = brush;

-  
-  if (!m_brush.Ok()) return;
-  
+
+  if (!m_brush.Ok() || m_brush.GetStyle () == wxTRANSPARENT)
+    return;
+
+  int oldFill = m_currentFill;
+  wxBitmap oldStipple = m_currentStipple;
+
+  m_autoSetting |= 0x1;
+
+  m_currentFill = m_brush.GetStyle ();
+  if (m_currentFill == wxSTIPPLE)
+    m_currentStipple = m_brush.GetStipple ();
+
+  wxColour oldBrushColour(m_currentColour);
+  m_currentColour = m_brush.GetColour ();
+
+  bool sameColour = (oldBrushColour.Ok () &&
+              (oldBrushColour.Red () == m_currentColour.Red ()) &&
+              (oldBrushColour.Blue () == m_currentColour.Blue ()) &&
+           (oldBrushColour.Green () == m_currentColour.Green ()) &&
+              (oldBrushColour.GetPixel() == m_currentColour.GetPixel()));
+
+  if ((oldFill != m_brush.GetStyle ()) || !GetOptimization())
+  {
+      switch (brush.GetStyle ())
+      {
+        case wxTRANSPARENT:
+          break;
+        case wxBDIAGONAL_HATCH:
+        case wxCROSSDIAG_HATCH:
+        case wxFDIAGONAL_HATCH:
+        case wxCROSS_HATCH:
+        case wxHORIZONTAL_HATCH:
+        case wxVERTICAL_HATCH:
+        case wxSTIPPLE:
+          {
+            // Chris Breeze 23/07/97: use background mode to determine whether
+            // fill style should be solid or transparent
+            int style = (m_backgroundMode == wxSOLID ? FillOpaqueStippled : FillStippled);
+            XSetFillStyle ((Display*) m_display, (GC) m_gc, style);
+            if (m_window && m_window->GetBackingPixmap())
+              XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, style);
+          }
+          break;
+        case wxSOLID:
+        default:
+          XSetFillStyle ((Display*) m_display, (GC) m_gc, FillSolid);
+          if (m_window && m_window->GetBackingPixmap())
+            XSetFillStyle ((Display*) m_display,(GC) m_gcBacking, FillSolid);
+      }
+  }
+
+  if (IS_HATCH(m_currentFill) && ((m_currentFill != oldFill) || !GetOptimization()))
+    {
+      Pixmap myStipple;
+
+      switch (m_currentFill)
+      {
+        case wxBDIAGONAL_HATCH:
+          if (bdiag == (Pixmap) 0)
+            bdiag = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         bdiag_bits, bdiag_width, bdiag_height);
+          myStipple = bdiag;
+          break;
+        case wxFDIAGONAL_HATCH:
+          if (fdiag == (Pixmap) 0)
+            fdiag = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         fdiag_bits, fdiag_width, fdiag_height);
+          myStipple = fdiag;
+          break;
+        case wxCROSS_HATCH:
+          if (cross == (Pixmap) 0)
+            cross = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         cross_bits, cross_width, cross_height);
+          myStipple = cross;
+          break;
+        case wxHORIZONTAL_HATCH:
+          if (horiz == (Pixmap) 0)
+            horiz = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         horiz_bits, horiz_width, horiz_height);
+          myStipple = horiz;
+          break;
+        case wxVERTICAL_HATCH:
+          if (verti == (Pixmap) 0)
+            verti = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         verti_bits, verti_width, verti_height);
+          myStipple = verti;
+          break;
+        case wxCROSSDIAG_HATCH:
+        default:
+          if (cdiag == (Pixmap) 0)
+            cdiag = XCreateBitmapFromData ((Display*) m_display,
+                      RootWindow ((Display*) m_display, DefaultScreen ((Display*) m_display)),
+                         cdiag_bits, cdiag_width, cdiag_height);
+          myStipple = cdiag;
+          break;
+      }
+      XSetStipple ((Display*) m_display, (GC) m_gc, myStipple);
+
+      if (m_window && m_window->GetBackingPixmap())
+        XSetStipple ((Display*) m_display,(GC) m_gcBacking, myStipple);
+    }
+    // X can forget the stipple value when resizing a window (apparently)
+    // so always set the stipple.
+    else if (m_currentStipple.Ok()) // && m_currentStipple != oldStipple)
+    {
+      XSetStipple ((Display*) m_display, (GC) m_gc, (Pixmap) m_currentStipple.GetPixmap());
+      if (m_window && m_window->GetBackingPixmap())
+        XSetStipple ((Display*) m_display,(GC) m_gcBacking, (Pixmap) m_currentStipple.GetPixmap());
+    }
+
+    // must test m_logicalFunction, because it involves background!
+    if (!sameColour || !GetOptimization() || m_logicalFunction == wxXOR)
+    {
+      int pixel = -1;
+      if (!m_colour)
+      {
+          // Policy - on a monochrome screen, all brushes are white,
+          // except when they're REALLY black!!!
+          unsigned char red = m_brush.GetColour ().Red ();
+          unsigned char blue = m_brush.GetColour ().Blue ();
+          unsigned char green = m_brush.GetColour ().Green ();
+
+          if (red == (unsigned char) 0 && blue == (unsigned char) 0
+              && green == (unsigned char) 0)
+            {
+              pixel = (int) BlackPixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
+              m_currentColour = *wxBLACK;
+              m_brush.GetColour().SetPixel(pixel);
+              m_currentColour.SetPixel(pixel);
+            }
+          else
+            {
+              pixel = (int) WhitePixel ((Display*) m_display, DefaultScreen ((Display*) m_display));
+              m_currentColour = *wxWHITE;
+              m_brush.GetColour().SetPixel(pixel);
+              m_currentColour.SetPixel(pixel);
+            }
+
+          // N.B. comment out the above line and uncomment the following lines
+          // if you want non-white colours to be black on a monochrome display.
+          /*
+             if (red == (unsigned char )255 && blue == (unsigned char)255
+             && green == (unsigned char)255)
+             pixel = (int)WhitePixel((Display*) m_display, DefaultScreen((Display*) m_display));
+             else
+             pixel = (int)BlackPixel((Display*) m_display, DefaultScreen((Display*) m_display));
+           */
+      }
+      else if (m_brush.GetStyle () != wxTRANSPARENT)
+      {
+        pixel = m_brush.GetColour().AllocColour(m_display);
+        m_currentColour.SetPixel(pixel);
+      }
+      if (pixel > -1)
+      {
+        // Finally, set the GC to the required colour
+        if (m_logicalFunction == wxXOR)
+        {
+          XGCValues values;
+          XGetGCValues ((Display*) m_display, (GC) m_gc, GCBackground, &values);
+          XSetForeground ((Display*) m_display, (GC) m_gc, pixel ^ values.background);
+          if (m_window && m_window->GetBackingPixmap())
+            XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel ^ values.background);
+        }
+        else
+        {
+          XSetForeground ((Display*) m_display, (GC) m_gc, pixel);
+          if (m_window && m_window->GetBackingPixmap())
+            XSetForeground ((Display*) m_display,(GC) m_gcBacking, pixel);
+        }
+      }
+    }
+  else
+    m_brush.GetColour().SetPixel(oldBrushColour.GetPixel());

 };
 
 void wxWindowDC::SetBackground( const wxBrush &brush )
 {
   if (!Ok()) return;
   
 };
 
 void wxWindowDC::SetBackground( const wxBrush &brush )
 {
   if (!Ok()) return;
   

-  if (m_backgroundBrush == brush) return;
-  

   m_backgroundBrush = brush;
   m_backgroundBrush = brush;

-  
-  if (!m_backgroundBrush.Ok()) return;
-  
+
+  if (!m_backgroundBrush.Ok())
+    return;
+
+  int pixel = m_backgroundBrush.GetColour().AllocColour(m_display);
+
+  XSetWindowBackground ((Display*) m_display, (Pixmap) m_pixmap, pixel);
+
+  // Necessary for ::DrawIcon, which use fg/bg pixel or the GC.
+  // And Blit,... (Any fct that use XCopyPlane, in fact.)
+  XSetBackground ((Display*) m_display, (GC) m_gc, pixel);
+  if (m_window && m_window->GetBackingPixmap())
+     XSetBackground ((Display*) m_display,(GC) m_gcBacking, pixel);

 };
 
 void wxWindowDC::SetLogicalFunction( int function )
 {
 };
 
 void wxWindowDC::SetLogicalFunction( int function )
 {

-  if (m_logicalFunction == function) return;
+  int x_function;
+
+  /* MATTHEW: [9] */
+  if (m_logicalFunction == function)
+    return;
+
+  switch (function)
+    {
+    case wxCLEAR:
+      x_function = GXclear;
+      break;
+    case wxXOR:
+      x_function = GXxor;
+      break;
+    case wxINVERT:
+      x_function = GXinvert;
+      break;
+    case wxOR_REVERSE:
+      x_function = GXorReverse;
+      break;
+    case wxAND_REVERSE:
+      x_function = GXandReverse;
+      break;
+    case wxAND:
+      x_function = GXand;
+      break;
+    case wxOR:
+      x_function = GXor;
+      break;
+    case wxAND_INVERT:
+      x_function = GXandInverted;
+      break;
+    case wxNO_OP:
+      x_function = GXnoop;
+      break;
+    case wxNOR:
+      x_function = GXnor;
+      break;
+    case wxEQUIV:
+      x_function = GXequiv;
+      break;
+    case wxSRC_INVERT:
+      x_function = GXcopyInverted;
+      break;
+    case wxOR_INVERT:
+      x_function = GXorInverted;
+      break;
+    case wxNAND:
+      x_function = GXnand;
+      break;
+    case wxSET:
+      x_function = GXset;
+      break;
+    case wxCOPY:
+    default:
+      x_function = GXcopy;
+      break;
+    }
+
+  XSetFunction((Display*) m_display, (GC) m_gc, x_function);
+  if (m_window && m_window->GetBackingPixmap())
+    XSetFunction((Display*) m_display, (GC) m_gcBacking, x_function);
+
+  if ((m_logicalFunction == wxXOR) != (function == wxXOR))
+    /* MATTHEW: [9] Need to redo pen simply */
+    m_autoSetting |= 0x2;
+
+  m_logicalFunction = function;
+

 };
 
 void wxWindowDC::SetTextForeground( const wxColour &col )
 };
 
 void wxWindowDC::SetTextForeground( const wxColour &col )


@@ -484,7 +1921,7 @@ void wxWindowDC::SetTextForeground( const wxColour &col )
   if (m_textForegroundColour == col) return;
   
   m_textForegroundColour = col;
   if (m_textForegroundColour == col) return;
   
   m_textForegroundColour = col;

-  if (!m_textForegroundColour.Ok()) return;
+

 };
 
 void wxWindowDC::SetTextBackground( const wxColour &col )
 };
 
 void wxWindowDC::SetTextBackground( const wxColour &col )


@@ -501,25 +1938,102 @@ void wxWindowDC::SetBackgroundMode( int mode )
 {
   m_backgroundMode = mode;
 
 {
   m_backgroundMode = mode;
 

-  if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT)
+};
+
+void wxWindowDC::SetPalette( const wxPalette& palette )
+{
+  if (m_window)

   {
   {

+    if (palette.Ok())
+      /* Use GetXColormap */
+      XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
+              (Colormap) palette.GetXColormap());
+    else
+      /* Use wxGetMainColormap */
+      XSetWindowColormap ((Display*) m_display, (Window) m_window->GetXWindow(),
+              (Colormap) wxTheApp->GetMainColormap(m_display));

   }
 };
 
   }
 };
 

-void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) )
+// Helper function
+void wxWindowDC:: SetDCClipping ()

 {
 {

-};
+  // m_userRegion is the region set by calling SetClippingRegion
+
+  if (m_currentRegion)
+    XDestroyRegion ((Region) m_currentRegion);
+
+  // We need to take into account
+  // clipping imposed on a window by a repaint.
+  // We'll combine it with the user region. But for now,
+  // just use the currently-defined user clipping region.
+  if (m_userRegion || (m_window && m_window->GetPaintRegion()) )
+    m_currentRegion = (WXRegion) XCreateRegion ();
+  else
+    m_currentRegion = (WXRegion) NULL;
+
+  if ((m_window && m_window->GetPaintRegion()) && m_userRegion)
+    XIntersectRegion ((Region) m_window->GetPaintRegion(), (Region) m_userRegion, (Region) m_currentRegion);
+  else if (m_userRegion)
+    XIntersectRegion ((Region) m_userRegion, (Region) m_userRegion, (Region) m_currentRegion);
+  else if (m_window && m_window->GetPaintRegion())
+    XIntersectRegion ((Region) m_window->GetPaintRegion(), (Region) m_window->GetPaintRegion(), 
+(Region) m_currentRegion);
+
+  if (m_currentRegion)
+    {
+      XSetRegion ((Display*) m_display, (GC) m_gc, (Region) m_currentRegion);
+    }
+  else
+    {
+      XSetClipMask ((Display*) m_display, (GC) m_gc, None);
+    }
+
+}

 
 void wxWindowDC::SetClippingRegion( long x, long y, long width, long height )
 {
   wxDC::SetClippingRegion( x, y, width, height );
 
 void wxWindowDC::SetClippingRegion( long x, long y, long width, long height )
 {
   wxDC::SetClippingRegion( x, y, width, height );

-  
+
+  if (m_userRegion)
+    XDestroyRegion ((Region) m_userRegion);
+  m_userRegion = (WXRegion) XCreateRegion ();
+  XRectangle r;
+  r.x = XLOG2DEV (x);
+  r.y = YLOG2DEV (y);
+  r.width = XLOG2DEVREL(width);
+  r.height = YLOG2DEVREL(height);
+  XUnionRectWithRegion (&r, (Region) m_userRegion, (Region) m_userRegion);
+
+  SetDCClipping ();
+
+  // Needs to work differently for Pixmap: without this,
+  // there's a nasty (Display*) m_display bug. 8/12/94
+  if (m_window && m_window->GetBackingPixmap())
+  {
+    XRectangle rects[1];
+    rects[0].x = XLOG2DEV_2(x); 
+    rects[0].y = YLOG2DEV_2(y);
+    rects[0].width = XLOG2DEVREL(width);
+    rects[0].height = YLOG2DEVREL(height);
+    XSetClipRectangles((Display*) m_display, (GC) m_gcBacking, 0, 0, rects, 1, Unsorted);
+  }

 };
 
 void wxWindowDC::DestroyClippingRegion(void)
 {
   wxDC::DestroyClippingRegion();
   
 };
 
 void wxWindowDC::DestroyClippingRegion(void)
 {
   wxDC::DestroyClippingRegion();
   

+  if (m_userRegion)
+    XDestroyRegion ((Region) m_userRegion);
+  m_userRegion = NULL;
+
+  SetDCClipping ();
+
+  XGCValues gc_val;
+  gc_val.clip_mask = None;
+  if (m_window && m_window->GetBackingPixmap())
+    XChangeGC((Display*) m_display, (GC) m_gcBacking, GCClipMask, &gc_val);

 };
 
 // ----------------------------------- spline code ----------------------------------------
 };
 
 // ----------------------------------- spline code ----------------------------------------


@@ -536,8 +2050,8 @@ static void wx_spline_draw_point_array(wxDC *dc);
 
 wxList wx_spline_point_list;
 
 
 wxList wx_spline_point_list;
 

-#define                half(z1, z2)    ((z1+z2)/2.0)
-#define                THRESHOLD       5
+#define        half(z1, z2)    ((z1+z2)/2.0)
+#define        THRESHOLD    5

 
 /* iterative version */
 
 
 /* iterative version */
 


@@ -553,16 +2067,16 @@ void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3,
     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
         xmid = (double)half(x2, x3);
         ymid = (double)half(y2, y3);
     while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
         xmid = (double)half(x2, x3);
         ymid = (double)half(y2, y3);

-       if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
-           fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
+    if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
+        fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {

             wx_spline_add_point( x1, y1 );
             wx_spline_add_point( xmid, ymid );
             wx_spline_add_point( x1, y1 );
             wx_spline_add_point( xmid, ymid );

-       } else {
+    } else {

             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
                  (double)half(x3, x4), (double)half(y3, y4), x4, y4);
             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
                  (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
             wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
                  (double)half(x3, x4), (double)half(y3, y4), x4, y4);
             wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
                  (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);

-       }
+    }

     }
 }
 
     }
 }
 


@@ -601,7 +2115,7 @@ int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
                   double *x3, double *y3, double *x4, double *y4)
 {
     if (wx_stack_count == 0)
                   double *x3, double *y3, double *x4, double *y4)
 {
     if (wx_stack_count == 0)

-       return (0);
+    return (0);

     wx_stack_top--;
     wx_stack_count--;
     *x1 = wx_stack_top->x1;
     wx_stack_top--;
     wx_stack_count--;
     *x1 = wx_stack_top->x1;


@@ -664,10 +2178,10 @@ void wxWindowDC::DrawOpenSpline( wxList *points )
     while ((node = node->Next()) != NULL)
     {
         p = (wxPoint *)node->Data();
     while ((node = node->Next()) != NULL)
     {
         p = (wxPoint *)node->Data();

-       x1 = x2;
-       y1 = y2;
-       x2 = p->x;
-       y2 = p->y;
+    x1 = x2;
+    y1 = y2;
+    x2 = p->x;
+    y2 = p->y;

         cx4 = (double)(x1 + x2) / 2;
         cy4 = (double)(y1 + y2) / 2;
         cx3 = (double)(x1 + cx4) / 2;
         cx4 = (double)(x1 + x2) / 2;
         cy4 = (double)(y1 + y2) / 2;
         cx3 = (double)(x1 + cx4) / 2;


@@ -675,8 +2189,8 @@ void wxWindowDC::DrawOpenSpline( wxList *points )
 
         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
 
 
         wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
 

-       cx1 = cx4;
-       cy1 = cy4;
+    cx1 = cx4;
+    cy1 = cy4;

         cx2 = (double)(cx1 + x2) / 2;
         cy2 = (double)(cy1 + y2) / 2;
     }
         cx2 = (double)(cx1 + x2) / 2;
         cy2 = (double)(cy1 + y2) / 2;
     }

diff --git a/src/motif/dcmemory.cpp b/src/motif/dcmemory.cpp
index 9a80e5f5495c552ef9f7a15bb759c9b436d074c1..6c58af617fc70d16256edaed02dc0285288bdaa3 100644 (file)
--- a/src/motif/dcmemory.cpp
+++ b/src/motif/dcmemory.cpp
@@ -19,7 +19,7 @@
 // wxMemoryDC
 //-----------------------------------------------------------------------------
 
 // wxMemoryDC
 //-----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC,wxPaintDC)
+IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxWindowDC)

 
 wxMemoryDC::wxMemoryDC(void)
 {
 
 wxMemoryDC::wxMemoryDC(void)
 {


@@ -37,9 +37,10 @@ wxMemoryDC::~wxMemoryDC(void)
 
 void wxMemoryDC::SelectObject( const wxBitmap& bitmap )
 {
 
 void wxMemoryDC::SelectObject( const wxBitmap& bitmap )
 {

-  m_selected = bitmap;
-  if (m_selected.Ok())
+  m_bitmap = bitmap;
+  if (m_bitmap.Ok())

   {
   {

+    m_pixmap = m_bitmap.GetPixmap();

   }
   else
   {
   }
   else
   {


@@ -49,10 +50,10 @@ void wxMemoryDC::SelectObject( const wxBitmap& bitmap )
 
 void wxMemoryDC::GetSize( int *width, int *height ) const
 {
 
 void wxMemoryDC::GetSize( int *width, int *height ) const
 {

-  if (m_selected.Ok())
+  if (m_bitmap.Ok())

   {
   {

-    if (width) (*width) = m_selected.GetWidth();
-    if (height) (*height) = m_selected.GetHeight();
+    if (width) (*width) = m_bitmap.GetWidth();
+    if (height) (*height) = m_bitmap.GetHeight();

   }
   else
   {
   }
   else
   {

diff --git a/src/motif/fdiag.xbm b/src/motif/fdiag.xbm
new file mode 100644 (file)
index 0000000..67d3b47
--- /dev/null
+++ b/src/motif/fdiag.xbm
@@ -0,0 +1,6 @@
+#define fdiag_width 16
+#define fdiag_height 16
+static char fdiag_bits[] = {
+   0x01, 0x01, 0x02, 0x02, 0x04, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20,
+   0x40, 0x40, 0x80, 0x80, 0x01, 0x01, 0x02, 0x02, 0x04, 0x04, 0x08, 0x08,
+   0x10, 0x10, 0x20, 0x20, 0x40, 0x40, 0x80, 0x80};

diff --git a/src/motif/horiz.xbm b/src/motif/horiz.xbm
new file mode 100644 (file)
index 0000000..ff3309b
--- /dev/null
+++ b/src/motif/horiz.xbm
@@ -0,0 +1,6 @@
+#define horiz_width 15
+#define horiz_height 15
+static char horiz_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0xff, 0x7f, 0x00, 0x00, 0x00, 0x00};

diff --git a/src/motif/palette.cpp b/src/motif/palette.cpp
index 69e9780221d98beec7b225ad2be60cbeccddd6ba..e5ec7326731715b17f2f745b1b13bb8ec1954341 100644 (file)
--- a/src/motif/palette.cpp
+++ b/src/motif/palette.cpp
@@ -26,7 +26,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
 
 wxPaletteRefData::wxPaletteRefData()
 {
 
 wxPaletteRefData::wxPaletteRefData()
 {

-    // TODO
+    m_colormap = (WXColormap) 0;

 }
 
 wxPaletteRefData::~wxPaletteRefData()
 }
 
 wxPaletteRefData::~wxPaletteRefData()

diff --git a/src/motif/settings.cpp b/src/motif/settings.cpp
index 17f57f98d17b0a8efadbdfddd349c09f8dcce828..357fe42c8fba3c6554997d120359a5a5e7aae829 100644 (file)
--- a/src/motif/settings.cpp
+++ b/src/motif/settings.cpp
@@ -9,6 +9,10 @@
 // Licence:    wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:    wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

+// TODO: these settings should probably be configurable from some central or
+// per-user file, which can be edited using a Windows-control-panel clone.
+// Also they should be documented better. Some are very MS Windows-ish.
+

 #ifdef __GNUG__
 #pragma implementation "settings.h"
 #endif
 #ifdef __GNUG__
 #pragma implementation "settings.h"
 #endif


@@ -18,12 +22,37 @@
 wxColour wxSystemSettings::GetSystemColour(int index)
 {
     // TODO
 wxColour wxSystemSettings::GetSystemColour(int index)
 {
     // TODO

-       return wxColour();
+    return wxColour();

 }
 
 wxFont wxSystemSettings::GetSystemFont(int index)
 {
     // TODO
 }
 
 wxFont wxSystemSettings::GetSystemFont(int index)
 {
     // TODO

+    switch (index)
+    {
+        case wxSYS_DEVICE_DEFAULT_FONT:
+        {
+            break;
+        }
+        case wxSYS_DEFAULT_PALETTE:
+        {
+            break;
+        }
+        case wxSYS_SYSTEM_FIXED_FONT:
+        {
+            break;
+        }
+        case wxSYS_SYSTEM_FONT:
+        {
+            break;
+        }
+        default:
+        case wxSYS_DEFAULT_GUI_FONT:
+        {
+            break;
+        }
+    }
+

     return wxFont();
 }
 
     return wxFont();
 }
 

diff --git a/src/motif/verti.xbm b/src/motif/verti.xbm
new file mode 100644 (file)
index 0000000..2dd9dc4
--- /dev/null
+++ b/src/motif/verti.xbm
@@ -0,0 +1,6 @@
+#define verti_width 15
+#define verti_height 15
+static char verti_bits[] = {
+   0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10,
+   0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10,
+   0x84, 0x10, 0x84, 0x10, 0x84, 0x10};

diff --git a/src/motif/window.cpp b/src/motif/window.cpp
index 5e8e991befc1b5c5849607f92f459539eea6b979..dffcfcc268fef8df60a791430ef77d271e18e380 100644 (file)
--- a/src/motif/window.cpp
+++ b/src/motif/window.cpp
@@ -132,6 +132,7 @@ wxWindow::wxWindow()
     m_lastTS = 0;
     m_lastButton = 0;
     m_canAddEventHandler = FALSE;
     m_lastTS = 0;
     m_lastButton = 0;
     m_canAddEventHandler = FALSE;

+    m_paintRegion = (WXRegion) 0;

 }
 
 // Destructor
 }
 
 // Destructor


@@ -139,6 +140,10 @@ wxWindow::~wxWindow()
 {
   //// Motif-specific
 
 {
   //// Motif-specific
 

+  if (m_paintRegion)
+    XDestroyRegion ((Region) m_paintRegion);
+  m_paintRegion = (WXRegion) 0;
+

   if (GetMainWidget())
     DetachWidget(GetMainWidget()); // Removes event handlers
 
   if (GetMainWidget())
     DetachWidget(GetMainWidget()); // Removes event handlers
 


@@ -299,6 +304,7 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
     m_pixmapHeight = 0;
     m_pixmapOffsetX = 0;
     m_pixmapOffsetY = 0;
     m_pixmapHeight = 0;
     m_pixmapOffsetX = 0;
     m_pixmapOffsetY = 0;

+    m_paintRegion = (WXRegion) 0;

 
     if (!parent)
         return FALSE;
 
     if (!parent)
         return FALSE;

diff --git a/src/motif/wxwin.xbm b/src/motif/wxwin.xbm
new file mode 100644 (file)
index 0000000..9c70498
--- /dev/null
+++ b/src/motif/wxwin.xbm
@@ -0,0 +1,46 @@
+#define wxwin.xbm_width 64
+#define wxwin.xbm_height 64
+static char wxwin.xbm_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff,
+   0xff, 0xff, 0x1f, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
+   0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x40, 0x80, 0xc7, 0x19,
+   0x8e, 0x01, 0x50, 0x00, 0x40, 0x00, 0xc7, 0x39, 0xcf, 0x01, 0x70, 0x00,
+   0x40, 0x00, 0xc7, 0x31, 0x3c, 0x00, 0x50, 0x00, 0x40, 0x00, 0xc7, 0x21,
+   0x1c, 0x00, 0x70, 0x00, 0x40, 0x80, 0xe3, 0x20, 0x38, 0x00, 0x50, 0x00,
+   0x40, 0x80, 0xe3, 0x30, 0x3c, 0x00, 0x70, 0x00, 0x40, 0x80, 0xe3, 0x78,
+   0x76, 0x01, 0x50, 0x00, 0x40, 0x00, 0xdf, 0xff, 0xf3, 0x20, 0x70, 0x00,
+   0x40, 0x00, 0x8e, 0xff, 0x61, 0x70, 0x50, 0x00, 0x40, 0x00, 0x00, 0xfc,
+   0x01, 0xf8, 0x70, 0x00, 0x40, 0x00, 0x00, 0xfc, 0x01, 0xfc, 0x51, 0x00,
+   0x40, 0x00, 0x00, 0xfe, 0x03, 0xfc, 0x73, 0x00, 0x40, 0x00, 0x00, 0xff,
+   0x03, 0xf8, 0x51, 0x00, 0x40, 0x00, 0x00, 0xff, 0x07, 0xf0, 0x70, 0x00,
+   0x40, 0x00, 0x80, 0xff, 0x07, 0x60, 0x50, 0x00, 0x40, 0x00, 0x80, 0xff,
+   0x0f, 0xfc, 0x70, 0x00, 0x40, 0x00, 0xc0, 0xff, 0x1f, 0xfc, 0x50, 0x00,
+   0x40, 0x00, 0xe0, 0xff, 0x1f, 0xfc, 0x70, 0x00, 0x40, 0x00, 0xf0, 0x0f,
+   0x00, 0xfc, 0x50, 0x00, 0x40, 0x00, 0xf0, 0x07, 0x00, 0xfc, 0x70, 0x00,
+   0x40, 0x00, 0xf8, 0x07, 0x00, 0xfc, 0x50, 0x00, 0x40, 0x00, 0xfc, 0x03,
+   0x00, 0xfc, 0x70, 0x00, 0x40, 0x00, 0xfc, 0x01, 0x00, 0xfc, 0x50, 0x00,
+   0x40, 0x00, 0xfe, 0x00, 0x00, 0xfc, 0x70, 0x00, 0x40, 0x00, 0xfe, 0x00,
+   0x00, 0xfc, 0x50, 0x00, 0x40, 0x00, 0x7f, 0x00, 0x00, 0xfc, 0x70, 0x00,
+   0x40, 0x80, 0x7f, 0x00, 0x00, 0xfc, 0x50, 0x00, 0x40, 0x80, 0x3f, 0x00,
+   0x00, 0xfc, 0x70, 0x00, 0x40, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00,
+   0x40, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x40, 0xe0, 0xff, 0xff,
+   0xff, 0xff, 0x50, 0x00, 0x40, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00,
+   0x40, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x40, 0xf0, 0xff, 0xff,
+   0xff, 0xff, 0x70, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00,
+   0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x40, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x50, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00,
+   0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5f, 0x00, 0x80, 0xaa, 0xaa, 0xaa,
+   0xaa, 0xaa, 0x6a, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

diff --git a/src/stubs/settings.cpp b/src/stubs/settings.cpp
index d831092aa42ddb7d0774c5efd7b5d3a59c38a64e..2beda5c2a6896dee8513827fa63bc8eabb8af5e7 100644 (file)
--- a/src/stubs/settings.cpp
+++ b/src/stubs/settings.cpp
@@ -24,6 +24,31 @@ wxColour wxSystemSettings::GetSystemColour(int index)
 wxFont wxSystemSettings::GetSystemFont(int index)
 {
     // TODO
 wxFont wxSystemSettings::GetSystemFont(int index)
 {
     // TODO

+    switch (index)
+    {
+        case wxSYS_DEVICE_DEFAULT_FONT:
+        {
+            break;
+        }
+        case wxSYS_DEFAULT_PALETTE:
+        {
+            break;
+        }
+        case wxSYS_SYSTEM_FIXED_FONT:
+        {
+            break;
+        }
+        case wxSYS_SYSTEM_FONT:
+        {
+            break;
+        }
+        default:
+        case wxSYS_DEFAULT_GUI_FONT:
+        {
+            break;
+        }
+    }
+

     return wxFont();
 }
 
     return wxFont();
 }