wxX11:

     Lots of wxBitmap et al work.
     Adapted wxIcon, wxCursor to this.
     Split wxApp init things up so that the
       X11 display is available sooner.
     Changed initial display code accordingly.
     Corrected wxDC::DrawBitmap.

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

diff --git a/include/wx/x11/app.h b/include/wx/x11/app.h
index 39a94cbe3079b1ee212db2c749190f9c28ba0bac..402a8dbf092b1d5e7037a84e1b171ee57f9e08ae 100644 (file)
--- a/include/wx/x11/app.h
+++ b/include/wx/x11/app.h
@@ -91,12 +91,15 @@ public:
     
     WXWindow       GetTopLevelWidget() const { return m_topLevelWidget; }
     WXColormap     GetMainColormap(WXDisplay* display);
     
     WXWindow       GetTopLevelWidget() const { return m_topLevelWidget; }
     WXColormap     GetMainColormap(WXDisplay* display);

-    WXDisplay*     GetInitialDisplay() const { return m_initialDisplay; }

     long           GetMaxRequestSize() const { return m_maxRequestSize; }
     
     // This handler is called when a property change event occurs
     virtual void   HandlePropertyChange(WXEvent *event);
     
     long           GetMaxRequestSize() const { return m_maxRequestSize; }
     
     // This handler is called when a property change event occurs
     virtual void   HandlePropertyChange(WXEvent *event);
     

+    // We need this before create the app
+    static   WXDisplay* GetDisplay() { return ms_display; }
+    static   WXDisplay* ms_display;
+    

 public:
     static long    sm_lastMessageTime;
     int            m_nCmdShow;
 public:
     static long    sm_lastMessageTime;
     int            m_nCmdShow;


@@ -106,7 +109,6 @@ protected:
     
     WXWindow              m_topLevelWidget;
     WXColormap            m_mainColormap;
     
     WXWindow              m_topLevelWidget;
     WXColormap            m_mainColormap;

-    WXDisplay*            m_initialDisplay;

     long                  m_maxRequestSize;
     wxEventLoop*          m_mainLoop;
     
     long                  m_maxRequestSize;
     wxEventLoop*          m_mainLoop;
     

diff --git a/include/wx/x11/bitmap.h b/include/wx/x11/bitmap.h
index be3ae6febf7dac08f2aecbeb42a4fd9e7244c790..4fa848590a9979c73267b9508dcfb5732053c479 100644 (file)
--- a/include/wx/x11/bitmap.h
+++ b/include/wx/x11/bitmap.h
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        bitmap.h
 // Purpose:     wxBitmap class
 /////////////////////////////////////////////////////////////////////////////
 // Name:        bitmap.h
 // Purpose:     wxBitmap class

-// Author:      Julian Smart
+// Author:      Julian Smart, Robert Roebling

 // Modified by:
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     17/09/98
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart
+// Copyright:   (c) Julian Smart, Robert Roebling

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


@@ -16,203 +16,117 @@
 #pragma interface "bitmap.h"
 #endif
 
 #pragma interface "bitmap.h"
 #endif
 

-#include "wx/gdiobj.h"
-#include "wx/gdicmn.h"
+#include "wx/defs.h"
+#include "wx/object.h"
+#include "wx/string.h"

 #include "wx/palette.h"
 #include "wx/palette.h"

+#include "wx/gdiobj.h"
+
+//-----------------------------------------------------------------------------
+// classes
+//-----------------------------------------------------------------------------
+
+class wxMask;
+class wxBitmap;
+class wxImage;

 
 

-// Bitmap
-class WXDLLEXPORT wxDC;
-class WXDLLEXPORT wxControl;
-class WXDLLEXPORT wxBitmap;
-class WXDLLEXPORT wxBitmapHandler;
-class WXDLLEXPORT wxIcon;
-class WXDLLEXPORT wxCursor;
-class WXDLLEXPORT wxImage;
-
-// A mask is a mono bitmap used for drawing bitmaps
-// transparently.
-class WXDLLEXPORT wxMask: public wxObject
+//-----------------------------------------------------------------------------
+// wxMask
+//-----------------------------------------------------------------------------
+
+class wxMask: public wxObject

 {
 {

-    DECLARE_DYNAMIC_CLASS(wxMask)
-        

 public:
     wxMask();
 public:
     wxMask();

-    
-    // Construct a mask from a bitmap and a colour indicating
-    // the transparent area
-    wxMask(const wxBitmap& bitmap, const wxColour& colour);
-    
-    // Construct a mask from a bitmap and a palette index indicating
-    // the transparent area
-    wxMask(const wxBitmap& bitmap, int paletteIndex);
-    
-    // Construct a mask from a mono bitmap (copies the bitmap).
-    wxMask(const wxBitmap& bitmap);
-    
+    wxMask( const wxBitmap& bitmap, const wxColour& colour );
+    wxMask( const wxBitmap& bitmap, int paletteIndex );
+    wxMask( const wxBitmap& bitmap );

     ~wxMask();
     ~wxMask();

-    
-    bool Create(const wxBitmap& bitmap, const wxColour& colour);
-    bool Create(const wxBitmap& bitmap, int paletteIndex);
-    bool Create(const wxBitmap& bitmap);
-    
-    WXPixmap GetPixmap() const { return m_pixmap; }
-    void SetPixmap(WXPixmap pixmap) { m_pixmap = pixmap; }
-    
-protected:
-    WXPixmap      m_pixmap;
-};
+  
+    bool Create( const wxBitmap& bitmap, const wxColour& colour );
+    bool Create( const wxBitmap& bitmap, int paletteIndex );
+    bool Create( const wxBitmap& bitmap );

 
 

-class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData
-{
-    friend class WXDLLEXPORT wxBitmap;
-    friend class WXDLLEXPORT wxIcon;
-    friend class WXDLLEXPORT wxCursor;
-public:
-    wxBitmapRefData();
-    ~wxBitmapRefData();
-    
-public:
-    int               m_width;
-    int               m_height;
-    int               m_depth;
-    bool              m_ok;
-    int               m_numColors;
-    wxPalette         m_bitmapPalette;
-    int               m_quality;
-    
-    wxMask *          m_bitmapMask; // Optional mask
-    
-    // Motif implementation
-public:
-    WXPixmap          m_pixmap;
-    WXDisplay*        m_display;
-    bool              m_freePixmap;
-    unsigned long*    m_freeColors;
-    long              m_freeColorsCount;
+    // implementation
+    WXPixmap GetBitmap() const              { return m_bitmap; }
+    void SetBitmap( WXPixmap bitmap )       { m_bitmap = bitmap; }
+    
+    WXDisplay *GetDisplay() const           { return m_display; }
+    void SetDisplay( WXDisplay *display )   { m_display = display; }
+    
+private:
+    WXPixmap    m_bitmap;
+    WXDisplay  *m_display;
+  
+private:
+    DECLARE_DYNAMIC_CLASS(wxMask)

 };
 
 };
 

-#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
+//-----------------------------------------------------------------------------
+// wxBitmap
+//-----------------------------------------------------------------------------

 
 

-class WXDLLEXPORT wxBitmapHandler: public wxObject
+class wxBitmap: public wxGDIObject

 {
 {

-    DECLARE_DYNAMIC_CLASS(wxBitmapHandler)

 public:
 public:

-    wxBitmapHandler() { m_name = ""; m_extension = ""; m_type = 0; };
+    wxBitmap();
+    wxBitmap( int width, int height, int depth = -1 );
+    wxBitmap( const char bits[], int width, int height, int depth = 1 );
+    wxBitmap( const char **bits ) { (void)CreateFromXpm(bits); }
+    wxBitmap( char **bits ) { (void)CreateFromXpm((const char **)bits); }
+    wxBitmap( const wxBitmap& bmp );
+    wxBitmap( const wxString &filename, int type = wxBITMAP_TYPE_XPM );
+    wxBitmap( const wxImage& image, int depth = -1 ) { (void)CreateFromImage(image, depth); }
+    ~wxBitmap();
+    wxBitmap& operator = ( const wxBitmap& bmp );
+    bool operator == ( const wxBitmap& bmp ) const;
+    bool operator != ( const wxBitmap& bmp ) const;
+    bool Ok() const;
+
+    bool Create(int width, int height, int depth = -1);

     
     

-    virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
-    virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-        int desiredWidth, int desiredHeight);
-    virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
+    int GetHeight() const;
+    int GetWidth() const;
+    int GetDepth() const;

     
     

-    void SetName(const wxString& name) { m_name = name; }
-    void SetExtension(const wxString& ext) { m_extension = ext; }
-    void SetType(long type) { m_type = type; }
-    wxString GetName() const { return m_name; }
-    wxString GetExtension() const { return m_extension; }
-    long GetType() const { return m_type; }
-protected:
-    wxString  m_name;
-    wxString  m_extension;
-    long      m_type;
-};
+    wxImage ConvertToImage() const;

 
 

-#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
+    // copies the contents and mask of the given (colour) icon to the bitmap
+    virtual bool CopyFromIcon(const wxIcon& icon);

 
 

-class WXDLLEXPORT wxBitmap: public wxGDIObject
-{
-    DECLARE_DYNAMIC_CLASS(wxBitmap)
-        
-        friend class WXDLLEXPORT wxBitmapHandler;
-    
-public:
-    wxBitmap(); // Platform-specific
-    
-    // Copy constructors
-    wxBitmap(const wxBitmap& bitmap)
-    { Ref(bitmap); }
-    
-    // Initialize with raw XBM data
-    wxBitmap(const char bits[], int width, int height, int depth = 1);
-    
-    // from XPM
-    wxBitmap(const char **data) { (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); }
-    wxBitmap(char **data) { (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); }
-    
-    // Load a file or resource
-    wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_XPM);
-    
-    // Constructor for generalised creation from data
-    wxBitmap(void *data, long type, int width, int height, int depth = 1);
-    
-    // If depth is omitted, will create a bitmap compatible with the display
-    wxBitmap(int width, int height, int depth = -1);
-    
-    // Convert from wxImage:  
-    wxBitmap(const wxImage& image, int depth = -1) { (void)CreateFromImage(image, depth); }
-    
-    ~wxBitmap();
-    
-    virtual bool Create(int width, int height, int depth = -1);
-    virtual bool Create(void *data, long type, int width, int height, int depth = 1);
+    wxMask *GetMask() const;
+    void SetMask( wxMask *mask );

     
     wxBitmap GetSubBitmap( const wxRect& rect ) const;
     
     wxBitmap GetSubBitmap( const wxRect& rect ) const;

-    
-    virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_XPM);
-    virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
-    
-    wxImage ConvertToImage() const;

 
 

-    bool CopyFromIcon(const wxIcon& icon);
-    
-    bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
-    int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
-    int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
-    int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
-    int GetQuality() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); }
-    void SetWidth(int w);
-    void SetHeight(int h);
-    void SetDepth(int d);
-    void SetQuality(int q);
-    void SetOk(bool isOk);
-    
-    wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : (wxPalette*) NULL); }
-    void SetPalette(const wxPalette& palette);
-    
-    wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) NULL); }
-    void SetMask(wxMask *mask) ;
-    
-    wxBitmap& operator = (const wxBitmap& bitmap) { if (*this == bitmap) return (*this); Ref(bitmap); return *this; }
-    bool operator == (const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; }
-    bool operator != (const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; }
-    
-    // Format handling
-    static wxList& GetHandlers() { return sm_handlers; }
-    static void AddHandler(wxBitmapHandler *handler);
-    static void InsertHandler(wxBitmapHandler *handler);
-    static bool RemoveHandler(const wxString& name);
-    static wxBitmapHandler *FindHandler(const wxString& name);
-    static wxBitmapHandler *FindHandler(const wxString& extension, long bitmapType);
-    static wxBitmapHandler *FindHandler(long bitmapType);
-    
-    static void InitStandardHandlers();
-    static void CleanUpHandlers();
-    
-    // Motif implementation
-public:
-    WXDisplay* GetDisplay() const { return M_BITMAPDATA->m_display; }
-    WXPixmap GetPixmap() const { return (WXPixmap) M_BITMAPDATA->m_pixmap; }
-    void SetPixmapNull() { M_BITMAPDATA->m_pixmap = 0; }
+    bool SaveFile( const wxString &name, int type, wxPalette *palette = (wxPalette *) NULL );
+    bool LoadFile( const wxString &name, int type = wxBITMAP_TYPE_XPM );
+
+    wxPalette *GetPalette() const;
+    wxPalette *GetColourMap() const
+        { return GetPalette(); };
+
+    // implementation
+    // --------------
+
+    void SetHeight( int height );
+    void SetWidth( int width );
+    void SetDepth( int depth );
+    void SetPixmap( WXPixmap pixmap );
+    void SetBitmap( WXPixmap bitmap );
+
+    WXPixmap GetPixmap() const;
+    WXPixmap GetBitmap() const;

     
     

-protected:
-    static wxList sm_handlers;
+    WXDisplay *GetDisplay() const;

     
 protected:
     
 protected:

-    bool CreateFromImage(const wxImage& image, int depth);    
-};
+    bool CreateFromXpm(const char **bits);
+    bool CreateFromImage(const wxImage& image, int depth);

 
 

-// Creates a bitmap with transparent areas drawn in
-// the given colour.
-wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour);
+private:
+    DECLARE_DYNAMIC_CLASS(wxBitmap)
+};

 
 #endif
 // _WX_BITMAP_H_
 
 #endif
 // _WX_BITMAP_H_

diff --git a/include/wx/x11/cursor.h b/include/wx/x11/cursor.h
index c1d3bce5c3702fc65e92279aa5e3749306c3639d..65fe7721a766d9f42f515b6e66e23a6a94c63f7c 100644 (file)
--- a/include/wx/x11/cursor.h
+++ b/include/wx/x11/cursor.h
@@ -18,67 +18,41 @@
 
 #include "wx/bitmap.h"
 
 
 #include "wx/bitmap.h"
 

-/* Cursor for one display, so we can choose the correct one for
-* the current display.
-*/
-class wxXCursor : public wxObject
-{
-    DECLARE_DYNAMIC_CLASS(wxXCursor)
-        
-public:
-    WXDisplay*  m_display;
-    WXCursor    m_cursor;
-};
-
-class WXDLLEXPORT wxCursorRefData: public wxBitmapRefData
-{
-    friend class WXDLLEXPORT wxBitmap;
-    friend class WXDLLEXPORT wxCursor;
-public:
-    wxCursorRefData();
-    ~wxCursorRefData();
-    
-    wxList        m_cursors;  // wxXCursor objects, one per display
-    wxStockCursor m_cursorId; // wxWindows standard cursor id
-};
+#if wxUSE_IMAGE
+#include "wx/image.h"
+#endif

 
 

-#define M_CURSORDATA ((wxCursorRefData *)m_refData)
-#define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData)
+//-----------------------------------------------------------------------------
+// wxCursor
+//-----------------------------------------------------------------------------

 
 

-// Cursor
-class WXDLLEXPORT wxCursor: public wxBitmap
+class wxCursor: public wxObject

 {
 {

-    DECLARE_DYNAMIC_CLASS(wxCursor)
-        

 public:
 public:

+

     wxCursor();
     wxCursor();

-    
-    // Copy constructors
-    wxCursor(const wxCursor& cursor) { Ref(cursor); }
-    
-    wxCursor(const char bits[], int width, int height, int hotSpotX = -1, int hotSpotY = -1,
-        const char maskBits[] = NULL);
-    
-    wxCursor(const wxString& name, long flags = wxBITMAP_TYPE_XBM,
-        int hotSpotX = 0, int hotSpotY = 0);
-    
-    wxCursor(wxStockCursor id);
+    wxCursor( int cursorId );
+    wxCursor( const wxCursor &cursor );
+#if wxUSE_IMAGE
+    wxCursor( const wxImage & image );
+#endif
+    wxCursor( const char bits[], int width, int  height,
+              int hotSpotX=-1, int hotSpotY=-1,
+              const char maskBits[]=0, wxColour *fg=0, wxColour *bg=0 );

     ~wxCursor();
     ~wxCursor();

-    
-    virtual bool Ok() const { return ((m_refData != NULL) && M_CURSORDATA->m_ok); }
-    
-    wxCursor& operator = (const wxCursor& cursor) { if (*this == cursor) return (*this); Ref(cursor); return *this; }
-    bool operator == (const wxCursor& cursor) const { return m_refData == cursor.m_refData; }
-    bool operator != (const wxCursor& cursor) const { return m_refData != cursor.m_refData; }
-    
-    // Motif-specific.
-    // Create/get a cursor for the current display
-    WXCursor GetXCursor(WXDisplay* display) ;
-    // Make a cursor from standard id
-    WXCursor MakeCursor(WXDisplay* display, wxStockCursor id);
+    wxCursor& operator = ( const wxCursor& cursor );
+    bool operator == ( const wxCursor& cursor ) const;
+    bool operator != ( const wxCursor& cursor ) const;
+    bool Ok() const;
+
+    // implementation
+
+    WXCursor GetCursor() const;
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxCursor)

 };
 
 };
 

-extern WXDLLEXPORT void wxSetCursor(const wxCursor& cursor);

 
 #endif
 // _WX_CURSOR_H_
 
 #endif
 // _WX_CURSOR_H_

diff --git a/include/wx/x11/icon.h b/include/wx/x11/icon.h
index b72e6c96f49f0a669899d4679ea3746f6ebab02e..ee6e47fe75896b3483ab4b0acf374de19d5f2cf4 100644 (file)
--- a/include/wx/x11/icon.h
+++ b/include/wx/x11/icon.h
@@ -18,42 +18,39 @@
 
 #include "wx/bitmap.h"
 
 
 #include "wx/bitmap.h"
 

-#define M_ICONDATA ((wxBitmapRefData *)m_refData)
-#define M_ICONHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
+//-----------------------------------------------------------------------------
+// wxIcon
+//-----------------------------------------------------------------------------

 
 

-// Icon
-class WXDLLEXPORT wxIcon: public wxBitmap
+class wxIcon: public wxBitmap

 {
 {

-    DECLARE_DYNAMIC_CLASS(wxIcon)
-        

 public:
     wxIcon();
 public:
     wxIcon();

-    
-    // Copy constructors
-    inline wxIcon(const wxIcon& icon) { Ref(icon); }
-    
-    // Initialize with XBM data
-    wxIcon(const char bits[], int width, int height);
-    
-    // Initialize with XPM data
-    wxIcon(const char **data);
-    wxIcon(char **data);
-    
-    wxIcon(const wxString& name, long flags = wxBITMAP_TYPE_XPM,
-        int desiredWidth = -1, int desiredHeight = -1);
-    ~wxIcon();
-    
-    bool LoadFile(const wxString& name, long flags = wxBITMAP_TYPE_XPM,
-        int desiredWidth = -1, int desiredHeight = -1);
-    
-    inline wxIcon& operator = (const wxIcon& icon) { if (*this == icon) return (*this); Ref(icon); return *this; }
-    inline bool operator == (const wxIcon& icon) const { return m_refData == icon.m_refData; }
-    inline bool operator != (const wxIcon& icon) const { return m_refData != icon.m_refData; }
-    
-    virtual bool Ok() const { return ((m_refData != NULL) && (M_ICONDATA->m_ok)); }
-
-    bool CopyFromBitmap(const wxBitmap& bitmap);
+    wxIcon( const wxIcon& icon);
+    wxIcon( const char **bits, int width=-1, int height=-1 );
+
+    // For compatibility with wxMSW where desired size is sometimes required to
+    // distinguish between multiple icons in a resource.
+    wxIcon( const wxString& filename, int type = wxBITMAP_TYPE_XPM, 
+            int WXUNUSED(desiredWidth)=-1, int WXUNUSED(desiredHeight)=-1 ) :
+        wxBitmap(filename, type)
+    {
+    }
+    wxIcon( char **bits, int width=-1, int height=-1 );
+
+    wxIcon& operator = (const wxIcon& icon);
+    inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; }
+    inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; }
+
+    // create from bitmap (which should have a mask unless it's monochrome):
+    // there shouldn't be any implicit bitmap -> icon conversion (i.e. no
+    // ctors, assignment operators...), but it's ok to have such function
+    void CopyFromBitmap(const wxBitmap& bmp);
+  
+private:
+    DECLARE_DYNAMIC_CLASS(wxIcon)

 };
 
 };
 

+

 #endif
 // _WX_ICON_H_
 #endif
 // _WX_ICON_H_

diff --git a/samples/drawing/drawing.cpp b/samples/drawing/drawing.cpp
index a019bf45cd21f2a31e4ed63a3c85a1eb900257db..e08e04250d80e83474eb31184860f0767000fcfe 100644 (file)
--- a/samples/drawing/drawing.cpp
+++ b/samples/drawing/drawing.cpp
@@ -43,7 +43,7 @@
 // ----------------------------------------------------------------------------
 
 // the application icon
 // ----------------------------------------------------------------------------
 
 // the application icon

-#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__) || defined(__WXMGL__)
+#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__) || defined(__WXMGL__) || defined(__WXX11__)

     #include "mondrian.xpm"
 #endif
 
     #include "mondrian.xpm"
 #endif
 

diff --git a/src/gtk/app.cpp b/src/gtk/app.cpp
index eb7f991c51d0fa57593a7e3c9b595ffe21a796be..6b0b5276dfd766eae63fba54db2805b872a8ee6a 100644 (file)
--- a/src/gtk/app.cpp
+++ b/src/gtk/app.cpp
@@ -602,9 +602,7 @@ void wxApp::CleanUp()
     wxCleanUpResourceSystem();
 #endif
 
     wxCleanUpResourceSystem();
 #endif
 

-    if (wxTheColourDatabase)
-        delete wxTheColourDatabase;
-
+    delete wxTheColourDatabase;

     wxTheColourDatabase = (wxColourDatabase*) NULL;
 
     wxDeleteStockObjects();
     wxTheColourDatabase = (wxColourDatabase*) NULL;
 
     wxDeleteStockObjects();


@@ -614,17 +612,16 @@ void wxApp::CleanUp()
     delete wxTheApp;
     wxTheApp = (wxApp*) NULL;
 
     delete wxTheApp;
     wxTheApp = (wxApp*) NULL;
 

-    // GL: I'm annoyed ... I don't know where to put this and I don't want to
-    // create a module for that as it's part of the core.
+    delete[] wxBuffer;
+    wxBuffer = NULL;
+
+    wxClassInfo::CleanUpClasses();
+

 #if wxUSE_THREADS
     delete wxPendingEvents;
     delete wxPendingEventsLocker;
 #endif
 
 #if wxUSE_THREADS
     delete wxPendingEvents;
     delete wxPendingEventsLocker;
 #endif
 

-    delete[] wxBuffer;
-
-    wxClassInfo::CleanUpClasses();
-

     // check for memory leaks
 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
     // check for memory leaks
 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)

diff --git a/src/gtk/bitmap.cpp b/src/gtk/bitmap.cpp
index 4f5ad6a77057bf7b0f46941dd0731a09777488ce..94a89e1d5c66141d6162241be077893d78dfd99c 100644 (file)
--- a/src/gtk/bitmap.cpp
+++ b/src/gtk/bitmap.cpp
@@ -300,6 +300,8 @@ bool wxBitmap::Create( int width, int height, int depth )
 
 bool wxBitmap::CreateFromXpm( const char **bits )
 {
 
 bool wxBitmap::CreateFromXpm( const char **bits )
 {

+    UnRef();
+

     wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
 
     GdkVisual *visual = wxTheApp->GetGdkVisual();
     wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
 
     GdkVisual *visual = wxTheApp->GetGdkVisual();


@@ -327,6 +329,8 @@ bool wxBitmap::CreateFromXpm( const char **bits )
 
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 {
 
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 {

+    UnRef();
+

     wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
     wxCHECK_MSG( depth == -1 || depth == 1, FALSE, wxT("invalid bitmap depth") )
 
     wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
     wxCHECK_MSG( depth == -1 || depth == 1, FALSE, wxT("invalid bitmap depth") )
 


@@ -510,7 +514,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         if (bpp > 8)
         {
             if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask))      b_o = RGB;
         if (bpp > 8)
         {
             if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask))      b_o = RGB;

-            else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask))  b_o = RGB;
+            else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask))  b_o = RBG;

             else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask))   b_o = BRG;
             else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
             else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask))   b_o = GRB;
             else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask))   b_o = BRG;
             else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
             else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask))   b_o = GRB;

diff --git a/src/gtk1/app.cpp b/src/gtk1/app.cpp
index eb7f991c51d0fa57593a7e3c9b595ffe21a796be..6b0b5276dfd766eae63fba54db2805b872a8ee6a 100644 (file)
--- a/src/gtk1/app.cpp
+++ b/src/gtk1/app.cpp
@@ -602,9 +602,7 @@ void wxApp::CleanUp()
     wxCleanUpResourceSystem();
 #endif
 
     wxCleanUpResourceSystem();
 #endif
 

-    if (wxTheColourDatabase)
-        delete wxTheColourDatabase;
-
+    delete wxTheColourDatabase;

     wxTheColourDatabase = (wxColourDatabase*) NULL;
 
     wxDeleteStockObjects();
     wxTheColourDatabase = (wxColourDatabase*) NULL;
 
     wxDeleteStockObjects();


@@ -614,17 +612,16 @@ void wxApp::CleanUp()
     delete wxTheApp;
     wxTheApp = (wxApp*) NULL;
 
     delete wxTheApp;
     wxTheApp = (wxApp*) NULL;
 

-    // GL: I'm annoyed ... I don't know where to put this and I don't want to
-    // create a module for that as it's part of the core.
+    delete[] wxBuffer;
+    wxBuffer = NULL;
+
+    wxClassInfo::CleanUpClasses();
+

 #if wxUSE_THREADS
     delete wxPendingEvents;
     delete wxPendingEventsLocker;
 #endif
 
 #if wxUSE_THREADS
     delete wxPendingEvents;
     delete wxPendingEventsLocker;
 #endif
 

-    delete[] wxBuffer;
-
-    wxClassInfo::CleanUpClasses();
-

     // check for memory leaks
 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
     // check for memory leaks
 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)

diff --git a/src/gtk1/bitmap.cpp b/src/gtk1/bitmap.cpp
index 4f5ad6a77057bf7b0f46941dd0731a09777488ce..94a89e1d5c66141d6162241be077893d78dfd99c 100644 (file)
--- a/src/gtk1/bitmap.cpp
+++ b/src/gtk1/bitmap.cpp
@@ -300,6 +300,8 @@ bool wxBitmap::Create( int width, int height, int depth )
 
 bool wxBitmap::CreateFromXpm( const char **bits )
 {
 
 bool wxBitmap::CreateFromXpm( const char **bits )
 {

+    UnRef();
+

     wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
 
     GdkVisual *visual = wxTheApp->GetGdkVisual();
     wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
 
     GdkVisual *visual = wxTheApp->GetGdkVisual();


@@ -327,6 +329,8 @@ bool wxBitmap::CreateFromXpm( const char **bits )
 
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 {
 
 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
 {

+    UnRef();
+

     wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
     wxCHECK_MSG( depth == -1 || depth == 1, FALSE, wxT("invalid bitmap depth") )
 
     wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
     wxCHECK_MSG( depth == -1 || depth == 1, FALSE, wxT("invalid bitmap depth") )
 


@@ -510,7 +514,7 @@ bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
         if (bpp > 8)
         {
             if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask))      b_o = RGB;
         if (bpp > 8)
         {
             if ((visual->red_mask > visual->green_mask) && (visual->green_mask > visual->blue_mask))      b_o = RGB;

-            else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask))  b_o = RGB;
+            else if ((visual->red_mask > visual->blue_mask) && (visual->blue_mask > visual->green_mask))  b_o = RBG;

             else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask))   b_o = BRG;
             else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
             else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask))   b_o = GRB;
             else if ((visual->blue_mask > visual->red_mask) && (visual->red_mask > visual->green_mask))   b_o = BRG;
             else if ((visual->blue_mask > visual->green_mask) && (visual->green_mask > visual->red_mask)) b_o = BGR;
             else if ((visual->green_mask > visual->red_mask) && (visual->red_mask > visual->blue_mask))   b_o = GRB;

diff --git a/src/x11/app.cpp b/src/x11/app.cpp
index 31ad42aae9721b3cac58d226e02115234d0836bd..6b85093ad0bd4c724b2903f8143e571e65149b65 100644 (file)
--- a/src/x11/app.cpp
+++ b/src/x11/app.cpp
@@ -79,6 +79,7 @@ static int wxXErrorHandler(Display *dpy, XErrorEvent *xevent)
 #endif // __WXDEBUG__
 
 long wxApp::sm_lastMessageTime = 0;
 #endif // __WXDEBUG__
 
 long wxApp::sm_lastMessageTime = 0;

+WXDisplay *wxApp::ms_display = NULL;

 
 bool wxApp::Initialize()
 {
 
 bool wxApp::Initialize()
 {


@@ -102,8 +103,6 @@ bool wxApp::Initialize()
     wxInitializeResourceSystem();
 #endif
 
     wxInitializeResourceSystem();
 #endif
 

-    wxBitmap::InitStandardHandlers();
-

     wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
 
     wxModule::RegisterModules();
     wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
 
     wxModule::RegisterModules();


@@ -123,27 +122,21 @@ void wxApp::CleanUp()
     wxCleanUpResourceSystem();
 #endif
 
     wxCleanUpResourceSystem();
 #endif
 

-    wxDeleteStockObjects() ;
-
-    // Destroy all GDI lists, etc.
-
-    wxDeleteStockLists();
-

     delete wxTheColourDatabase;
     wxTheColourDatabase = NULL;
 
     delete wxTheColourDatabase;
     wxTheColourDatabase = NULL;
 

-    wxBitmap::CleanUpHandlers();
+    wxDeleteStockObjects();
+    
+    wxDeleteStockLists();
+
+    delete wxTheApp;
+    wxTheApp = NULL;

 
     delete[] wxBuffer;
     wxBuffer = NULL;
 
     wxClassInfo::CleanUpClasses();
 
 
     delete[] wxBuffer;
     wxBuffer = NULL;
 
     wxClassInfo::CleanUpClasses();
 

-    delete wxTheApp;
-    wxTheApp = NULL;
-
-    // GL: I'm annoyed ... I don't know where to put this and I don't want to
-    // create a module for that as it's part of the core.

 #if wxUSE_THREADS
     delete wxPendingEvents;
     delete wxPendingEventsLocker;
 #if wxUSE_THREADS
     delete wxPendingEvents;
     delete wxPendingEventsLocker;


@@ -168,6 +161,46 @@ void wxApp::CleanUp()
     delete wxLog::SetActiveTarget(NULL);
 }
 
     delete wxLog::SetActiveTarget(NULL);
 }
 

+// NB: argc and argv may be changed here, pass by reference!
+int wxEntryStart( int& argc, char *argv[] )
+{
+#ifdef __WXDEBUG__
+    // install the X error handler
+    gs_pfnXErrorHandler = XSetErrorHandler( wxXErrorHandler );
+#endif // __WXDEBUG__
+
+    Display* xdisplay = XOpenDisplay(NULL);
+
+    if (!xdisplay)
+    {
+        wxLogError( _("wxWindows could not open display. Exiting.") );
+        return -1;
+    }
+    
+    wxApp::ms_display = (WXDisplay*) xdisplay;
+    
+    XSelectInput( xdisplay, XDefaultRootWindow(xdisplay), PropertyChangeMask);
+        
+//    wxSetDetectableAutoRepeat( TRUE );
+
+    if (!wxApp::Initialize())
+        return -1;
+
+    return 0;
+}
+
+
+int wxEntryInitGui()
+{
+    int retValue = 0;
+
+    if ( !wxTheApp->OnInitGui() )
+        retValue = -1;
+
+    return retValue;
+}
+
+

 int wxEntry( int argc, char *argv[] )
 {
 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 int wxEntry( int argc, char *argv[] )
 {
 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT


@@ -179,9 +212,9 @@ int wxEntry( int argc, char *argv[] )
     // checked, but this is a reasonable compromise.
     wxDebugContext::SetCheckpoint();
 #endif
     // checked, but this is a reasonable compromise.
     wxDebugContext::SetCheckpoint();
 #endif

-
-    if (!wxApp::Initialize())
-        return FALSE;
+    int err = wxEntryStart(argc, argv);
+    if (err)
+        return err;

 
     if (!wxTheApp)
     {
 
     if (!wxTheApp)
     {


@@ -206,14 +239,18 @@ int wxEntry( int argc, char *argv[] )
     wxTheApp->argc = argc;
     wxTheApp->argv = argv;
 
     wxTheApp->argc = argc;
     wxTheApp->argv = argv;
 

-    // GUI-specific initialization, such as creating an app context.
-    wxTheApp->OnInitGui();
+    int retValue;
+    retValue = wxEntryInitGui();

 
     // Here frames insert themselves automatically into wxTopLevelWindows by
     // getting created in OnInit().
 
     // Here frames insert themselves automatically into wxTopLevelWindows by
     // getting created in OnInit().

+    if ( retValue == 0 )
+    {
+        if ( !wxTheApp->OnInit() )
+            retValue = -1;
+    }

 
 

-    int retValue = 0;
-    if (wxTheApp->OnInit())
+    if ( retValue == 0 )

     {
         if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
     }
     {
         if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
     }


@@ -257,7 +294,6 @@ wxApp::wxApp()
     m_mainColormap = (WXColormap) NULL;
     m_topLevelWidget = (WXWindow) NULL;
     m_maxRequestSize = 0;
     m_mainColormap = (WXColormap) NULL;
     m_topLevelWidget = (WXWindow) NULL;
     m_maxRequestSize = 0;

-    m_initialDisplay = (WXDisplay*) 0;

     m_mainLoop = NULL;
 }
 
     m_mainLoop = NULL;
 }
 


@@ -621,30 +657,13 @@ bool wxApp::OnInitGui()
     // now we don't want to try popping up a dialog
     // for error messages.
     delete wxLog::SetActiveTarget(new wxLogStderr);
     // now we don't want to try popping up a dialog
     // for error messages.
     delete wxLog::SetActiveTarget(new wxLogStderr);

+    

     if (!wxAppBase::OnInitGui())
        return FALSE;
     
     if (!wxAppBase::OnInitGui())
        return FALSE;
     

-    // TODO: parse argv and get display to pass to XOpenDisplay
-    Display* dpy = XOpenDisplay(NULL);
-    m_initialDisplay = (WXDisplay*) dpy;
-
-    if (!dpy) {
-        wxString className(wxTheApp->GetClassName());
-        wxLogError(_("wxWindows could not open display for '%s': exiting."),
-            (const char*) className);
-        exit(-1);
-    }
-    XSelectInput((Display*) m_initialDisplay,
-        XDefaultRootWindow((Display*) m_initialDisplay),
-        PropertyChangeMask);
-
-#ifdef __WXDEBUG__
-    // install the X error handler
-    gs_pfnXErrorHandler = XSetErrorHandler(wxXErrorHandler);
-#endif // __WXDEBUG__

 
 

-    GetMainColormap(dpy);
-    m_maxRequestSize = XMaxRequestSize((Display*) dpy);
+    GetMainColormap( wxApp::GetDisplay() );
+    m_maxRequestSize = XMaxRequestSize( (Display*) wxApp::GetDisplay() );

 
     return TRUE;
 }
 
     return TRUE;
 }

diff --git a/src/x11/bitmap.cpp b/src/x11/bitmap.cpp
index 9a4f71feb1d12d09b3effc572a60a49a9f14d161..6d4c558c3ee03d875698ff8511ac934068aaa8a1 100644 (file)
--- a/src/x11/bitmap.cpp
+++ b/src/x11/bitmap.cpp
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        bitmap.cpp
 // Purpose:     wxBitmap
 /////////////////////////////////////////////////////////////////////////////
 // Name:        bitmap.cpp
 // Purpose:     wxBitmap

-// Author:      Julian Smart
+// Author:      Julian Smart, Robert Roebling

 // Modified by:
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     17/09/98
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart
+// Copyright:   (c) Julian Smart, Robert Roebling

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


@@ -13,24 +13,12 @@
 #pragma implementation "bitmap.h"
 #endif
 
 #pragma implementation "bitmap.h"
 #endif
 

-#include "wx/setup.h"
-#include "wx/utils.h"
-#include "wx/palette.h"

 #include "wx/bitmap.h"
 #include "wx/icon.h"
 #include "wx/log.h"
 #include "wx/bitmap.h"
 #include "wx/icon.h"
 #include "wx/log.h"

-#include "wx/control.h"
-#include "wx/dcmemory.h"

 #include "wx/image.h"
 #include "wx/app.h"
 
 #include "wx/image.h"
 #include "wx/app.h"
 

-#ifdef __VMS__
-#pragma message disable nosimpint
-#endif
-#ifdef __VMS__
-#pragma message enable nosimpint
-#endif
-

 #include "wx/x11/private.h"
 
 #if wxHAVE_LIB_XPM
 #include "wx/x11/private.h"
 
 #if wxHAVE_LIB_XPM


@@ -38,1017 +26,1065 @@
 #endif
 #include <math.h>
 
 #endif
 #include <math.h>
 

+//-----------------------------------------------------------------------------
+// wxMask
+//-----------------------------------------------------------------------------

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
-IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
-
-wxBitmapRefData::wxBitmapRefData()
-{
-    m_ok = FALSE;
-    m_width = 0;
-    m_height = 0;
-    m_depth = 0;
-    m_quality = 0;
-    m_numColors = 0;
-    m_bitmapMask = NULL;
-
-    m_pixmap = (WXPixmap) 0;
-    m_display = (WXDisplay*) 0;
-
-    m_freePixmap = TRUE; //TODO: necessary?
-    m_freeColors = (unsigned long*) 0;
-    m_freeColorsCount = 0;
-}
-
-wxBitmapRefData::~wxBitmapRefData()
-{
-    if (m_pixmap && m_freePixmap)
-        XFreePixmap ((Display*) m_display, (Pixmap) m_pixmap);
-
-    if (m_freeColors)
-    {
-        int screen = DefaultScreen((Display*) m_display);
-        Colormap cmp = DefaultColormap((Display*) m_display,screen);
-        long llp;
-        for(llp = 0;llp < m_freeColorsCount;llp++)
-            XFreeColors((Display*) m_display, cmp, &m_freeColors[llp], 1, 0L);
-        delete m_freeColors;
-    };
-
-    if (m_bitmapMask)
-        delete m_bitmapMask;
-    m_bitmapMask = NULL;
-}
-
-wxList wxBitmap::sm_handlers;
-
-#define M_BMPDATA ((wxBitmapRefData *)m_refData)
+IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)

 
 

-wxBitmap::wxBitmap()
-{
-    m_refData = NULL;
-}
-
-wxBitmap::~wxBitmap()
+wxMask::wxMask()

 {
 {

+    m_bitmap = NULL;
+    m_display = NULL;

 }
 
 }
 

-wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
+wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )

 {
 {

-    m_refData = new wxBitmapRefData;
-
-    (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
+    m_bitmap = NULL;
+    Create( bitmap, colour );

 }
 
 }
 

-wxBitmap::wxBitmap(int w, int h, int d)
+wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex )

 {
 {

-    (void)Create(w, h, d);
+    m_bitmap = NULL;
+    Create( bitmap, paletteIndex );

 }
 
 }
 

-wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
+wxMask::wxMask( const wxBitmap& bitmap )

 {
 {

-    (void) Create(data, type, width, height, depth);
+    m_bitmap = NULL;
+    Create( bitmap );

 }
 
 }
 

-wxBitmap::wxBitmap(const wxString& filename, long type)
+wxMask::~wxMask()

 {
 {

-    LoadFile(filename, (int)type);
+    if (m_bitmap)
+        XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );

 }
 
 }
 

-bool wxBitmap::Create(int w, int h, int d)
+bool wxMask::Create( const wxBitmap& bitmap,
+                     const wxColour& colour )

 {
 {

-    UnRef();
+    if (m_bitmap)
+    {
+        XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
+        m_bitmap = NULL;
+    }

 
 

-    m_refData = new wxBitmapRefData;
+    m_display = bitmap.GetDisplay();

 
 

-    if (d < 1)
-        d = wxDisplayDepth();
+    wxImage image( bitmap );
+    if (!image.Ok()) return FALSE;
+    
+    m_display = bitmap.GetDisplay();
+    
+    Display *xdisplay = (Display*) m_display;

 
 

-    M_BITMAPDATA->m_width = w;
-    M_BITMAPDATA->m_height = h;
-    M_BITMAPDATA->m_depth = d;
-    M_BITMAPDATA->m_freePixmap = TRUE;
+    int xscreen = DefaultScreen( xdisplay );
+    Window xroot = RootWindow( xdisplay, xscreen );
+    Visual* xvisual = DefaultVisual( xdisplay, xscreen );
+    int bpp = DefaultDepth( xdisplay, xscreen );
+    
+    m_bitmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, image.GetWidth(), image.GetHeight(), 1 );
+    GC gc = XCreateGC( xdisplay, (Pixmap) m_bitmap, 0, NULL );

 
 

-    Display *dpy = (Display*) wxGetDisplay();
+    XSetForeground( xdisplay, gc, WhitePixel(xdisplay,xscreen) );
+    XSetFillStyle( xdisplay, gc, FillSolid );
+    XFillRectangle( xdisplay, (Pixmap) m_bitmap, gc, 0, 0, image.GetWidth(), image.GetHeight() );

 
 

-    M_BITMAPDATA->m_display = dpy; /* MATTHEW: [4] Remember the display */
+    unsigned char *data = image.GetData();
+    int index = 0;

 
 

-    M_BITMAPDATA->m_pixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
-        w, h, d);
+    unsigned char red = colour.Red();
+    unsigned char green = colour.Green();
+    unsigned char blue = colour.Blue();

 
 

-    M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_pixmap != (WXPixmap) 0) ;
-    return M_BITMAPDATA->m_ok;
-}
+    XVisualInfo vinfo_template;
+    XVisualInfo *vi;

 
 

-bool wxBitmap::LoadFile(const wxString& filename, long type)
-{
-    UnRef();
+    vinfo_template.visual = xvisual;
+    vinfo_template.visualid = XVisualIDFromVisual( xvisual );
+    vinfo_template.depth = bpp;
+    int nitem = 0;

 
 

-    m_refData = new wxBitmapRefData;
+    vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
+    wxASSERT_MSG( vi, wxT("No visual info") );
+    
+    if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
+    if (bpp == 15)
+    {
+        red = red & 0xf8;
+        green = green & 0xf8;
+        blue = blue & 0xf8;
+    } else
+    if (bpp == 16)
+    {
+        red = red & 0xf8;
+        green = green & 0xfc;
+        blue = blue & 0xf8;
+    } else
+    if (bpp == 12)
+    {
+        red = red & 0xf0;
+        green = green & 0xf0;
+        blue = blue & 0xf0;
+    }

 
 

-    wxBitmapHandler *handler = FindHandler(type);
+    XSetForeground( xdisplay, gc, BlackPixel(xdisplay,xscreen) );

 
 

-    if ( handler == NULL ) {
-        wxImage image;
-        if (!image.LoadFile( filename, type )) return FALSE;
-        if (image.Ok()) 
+    for (int j = 0; j < image.GetHeight(); j++)
+    {
+        int start_x = -1;
+        int i;
+        for (i = 0; i < image.GetWidth(); i++)

         {
         {

-            *this = image.ConvertToBitmap();
-            return TRUE;
+            if ((data[index] == red) &&
+                (data[index+1] == green) &&
+                (data[index+2] == blue))
+            {
+                if (start_x == -1)
+                start_x = i;
+            }
+            else
+            {
+                if (start_x != -1)
+                {
+                    XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i-1, j );
+                    start_x = -1;
+                }
+            }
+            index += 3;

         }
         }

-        else return FALSE;
+        if (start_x != -1)
+            XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i, j );

     }
     }

+    
+    XFreeGC( xdisplay, gc );

 
 

-    return handler->LoadFile(this, filename, type, -1, -1);
+    return TRUE;

 }
 
 }
 

-bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
+bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )

 {
 {

-    UnRef();
-
-    m_refData = new wxBitmapRefData;
+    unsigned char r,g,b;
+    wxPalette *pal = bitmap.GetPalette();

 
 

-    wxBitmapHandler *handler = FindHandler(type);
+    wxCHECK_MSG( pal, FALSE, wxT("Cannot create mask from bitmap without palette") );

 
 

-    if ( handler == NULL ) {
-        wxLogWarning("no data bitmap handler for type %d defined.", type);
-
-        return FALSE;
-    }
+    pal->GetRGB(paletteIndex, &r, &g, &b);

 
 

-    return handler->Create(this, data, type, width, height, depth);
+    return Create(bitmap, wxColour(r, g, b));

 }
 
 }
 

-bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
+bool wxMask::Create( const wxBitmap& bitmap )

 {
 {

-    wxBitmapHandler *handler = FindHandler(type);
-
-    if ( handler == NULL ) { // try wxImage
-        wxImage image( *this );
-        if (image.Ok()) return image.SaveFile( filename, type );
-        else return FALSE;
+    if (m_bitmap)
+    {
+        XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
+        m_bitmap = NULL;

     }
 
     }
 

-    return handler->SaveFile(this, filename, type, palette);
-}
-
-void wxBitmap::SetWidth(int w)
-{
-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
+    if (!bitmap.Ok()) return FALSE;

 
 

-    M_BITMAPDATA->m_width = w;
-}
+    wxCHECK_MSG( bitmap.GetBitmap(), FALSE, wxT("Cannot create mask from colour bitmap") );
+    
+    m_display = bitmap.GetDisplay();

 
 

-void wxBitmap::SetHeight(int h)
-{
-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
+    int xscreen = DefaultScreen( (Display*) m_display );
+    Window xroot = RootWindow( (Display*) m_display, xscreen );
+    
+    m_bitmap = (WXPixmap) XCreatePixmap( (Display*) m_display, xroot, bitmap.GetWidth(), bitmap.GetHeight(), 1 );

 
 

-    M_BITMAPDATA->m_height = h;
-}
+    if (!m_bitmap) return FALSE;
+    
+    GC gc = XCreateGC( (Display*) m_display, (Pixmap) m_bitmap, 0, NULL );

 
 

-void wxBitmap::SetDepth(int d)
-{
-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
+    XCopyPlane( (Display*) m_display, (Pixmap) bitmap.GetBitmap(), (Pixmap) m_bitmap,
+       gc, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), 0, 0, 1 );
+       
+    XFreeGC( (Display*) m_display, gc );

 
 

-    M_BITMAPDATA->m_depth = d;
+    return TRUE;

 }
 
 }
 

-void wxBitmap::SetQuality(int q)
-{
-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
-
-    M_BITMAPDATA->m_quality = q;
-}
+//-----------------------------------------------------------------------------
+// wxBitmap
+//-----------------------------------------------------------------------------

 
 

-void wxBitmap::SetOk(bool isOk)
+class wxBitmapRefData: public wxObjectRefData

 {
 {

-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
-
-    M_BITMAPDATA->m_ok = isOk;
-}
+public:
+    wxBitmapRefData();
+    ~wxBitmapRefData();
+
+    WXPixmap        m_pixmap;
+    WXPixmap        m_bitmap;
+    WXDisplay      *m_display;
+    wxMask         *m_mask;
+    int             m_width;
+    int             m_height;
+    int             m_bpp;
+    wxPalette      *m_palette;
+};

 
 

-void wxBitmap::SetPalette(const wxPalette& palette)
+wxBitmapRefData::wxBitmapRefData()

 {
 {

-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
-
-    M_BITMAPDATA->m_bitmapPalette = palette ;
+    m_pixmap = NULL;
+    m_bitmap = NULL;
+    m_display = NULL;
+    m_mask = (wxMask *) NULL;
+    m_width = 0;
+    m_height = 0;
+    m_bpp = 0;
+    m_palette = (wxPalette *) NULL;

 }
 
 }
 

-void wxBitmap::SetMask(wxMask *mask)
+wxBitmapRefData::~wxBitmapRefData()

 {
 {

-    if (!M_BITMAPDATA)
-        m_refData = new wxBitmapRefData;
-
-    M_BITMAPDATA->m_bitmapMask = mask ;
+    if (m_pixmap) XFreePixmap( (Display*) m_display, (Pixmap) m_pixmap );
+    if (m_bitmap) XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
+    if (m_mask) delete m_mask;
+    if (m_palette) delete m_palette;

 }
 
 }
 

-wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
-{
-    wxCHECK_MSG( Ok() &&
-                 (rect.x >= 0) && (rect.y >= 0) &&
-                 (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height),
-                 wxNullBitmap, wxT("invalid bitmap or bitmap region") );
+//-----------------------------------------------------------------------------

 
 

-    wxBitmap ret( rect.width, rect.height, 0 );
-    wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
+#define M_BMPDATA ((wxBitmapRefData *)m_refData)

 
 

-   // The remaining still TODO
-   return ret;
-}
+IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)

 
 

-void wxBitmap::AddHandler(wxBitmapHandler *handler)
+wxBitmap::wxBitmap()

 {
 {

-    sm_handlers.Append(handler);

 }
 
 }
 

-void wxBitmap::InsertHandler(wxBitmapHandler *handler)
+wxBitmap::wxBitmap( int width, int height, int depth )

 {
 {

-    sm_handlers.Insert(handler);
+    Create( width, height, depth );

 }
 
 }
 

-bool wxBitmap::RemoveHandler(const wxString& name)
+bool wxBitmap::Create( int width, int height, int depth )

 {
 {

-    wxBitmapHandler *handler = FindHandler(name);
-    if ( handler )
+    UnRef();
+
+    wxCHECK_MSG( (width > 0) && (height > 0), FALSE, wxT("invalid bitmap size") )
+
+    m_refData = new wxBitmapRefData();
+    
+    M_BMPDATA->m_display = wxGlobalDisplay();
+    
+    wxASSERT_MSG( M_BMPDATA->m_display, wxT("No display") );
+    
+    int xscreen = DefaultScreen( (Display*) M_BMPDATA->m_display );
+    Window xroot = RootWindow( (Display*) M_BMPDATA->m_display, xscreen );
+    
+    int bpp = DefaultDepth( (Display*) M_BMPDATA->m_display, xscreen );
+    if (depth == -1) depth = bpp;
+
+    wxCHECK_MSG( (depth == bpp) ||
+                 (depth == 1), FALSE, wxT("invalid bitmap depth") )
+
+    M_BMPDATA->m_mask = (wxMask *) NULL;
+    M_BMPDATA->m_width = width;
+    M_BMPDATA->m_height = height;
+    if (depth == 1)

     {
     {

-        sm_handlers.DeleteObject(handler);
-        return TRUE;
+        M_BMPDATA->m_bitmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, 1 );
+        
+        wxASSERT_MSG( M_BMPDATA->m_bitmap, wxT("Bitmap creation failed") );
+        
+        M_BMPDATA->m_bpp = 1;

     }
     else
     }
     else

-        return FALSE;
-}
-
-wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
-{
-    wxNode *node = sm_handlers.First();
-    while ( node )

     {
     {

-        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
-        if ( handler->GetName() == name )
-            return handler;
-        node = node->Next();
+        M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, depth );
+        
+        wxASSERT_MSG( M_BMPDATA->m_pixmap, wxT("Pixmap creation failed") );
+        
+        M_BMPDATA->m_bpp = depth;

     }
     }

-    return NULL;
-}

 
 

-wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
-{
-    wxNode *node = sm_handlers.First();
-    while ( node )
-    {
-        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
-        if ( handler->GetExtension() == extension &&
-            (bitmapType == -1 || handler->GetType() == bitmapType) )
-            return handler;
-        node = node->Next();
-    }
-    return NULL;
+    return Ok();

 }
 
 }
 

-wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
+bool wxBitmap::CreateFromXpm( const char **bits )

 {
 {

-    wxNode *node = sm_handlers.First();
-    while ( node )
+    UnRef();
+
+    wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
+
+    m_refData = new wxBitmapRefData();
+
+    M_BMPDATA->m_display = wxGlobalDisplay();
+    
+    Display *xdisplay = (Display*) M_BMPDATA->m_display;
+    
+    int xscreen = DefaultScreen( xdisplay );
+    Window xroot = RootWindow( xdisplay, xscreen );
+    
+    int bpp = DefaultDepth( xdisplay, xscreen );
+
+    XpmAttributes xpmAttr;
+    xpmAttr.valuemask = XpmReturnInfos;    // nothing yet, but get infos back
+
+    Pixmap pixmap;
+    Pixmap mask = 0;
+    
+    int ErrorStatus = XpmCreatePixmapFromData( xdisplay, xroot, (char**) bits, &pixmap, &mask, &xpmAttr );
+    
+    if (ErrorStatus == XpmSuccess)

     {
     {

-        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
-        if (handler->GetType() == bitmapType)
-            return handler;
-        node = node->Next();
-    }
-    return NULL;
-}
+        M_BMPDATA->m_width = xpmAttr.width;
+        M_BMPDATA->m_height = xpmAttr.height;

 
 

-/*
-* wxMask
-*/
+        M_BMPDATA->m_bpp = bpp;  // mono as well?

 
 

-wxMask::wxMask()
-{
-    m_pixmap = (WXPixmap) 0;
-}
+#if __WXDEBUG__
+        unsigned int depthRet;
+        int xRet, yRet;
+        unsigned int widthRet, heightRet, borderWidthRet;
+        XGetGeometry( xdisplay, pixmap, &xroot, &xRet, &yRet,
+            &widthRet, &heightRet, &borderWidthRet, &depthRet);

 
 

-// Construct a mask from a bitmap and a colour indicating
-// the transparent area
-wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
-{
-    m_pixmap = (WXPixmap) 0;
+        wxASSERT_MSG( bpp == (int)depthRet, wxT("colour depth mismatch") )
+#endif
+
+        XpmFreeAttributes(&xpmAttr);
+        
+        M_BMPDATA->m_pixmap = (WXPixmap) pixmap;
+        
+        if (mask)
+        {
+            M_BMPDATA->m_mask = new wxMask;
+            M_BMPDATA->m_mask->SetBitmap( (WXPixmap) mask );
+            M_BMPDATA->m_mask->SetDisplay( xdisplay );
+        }
+    }
+    else
+    {
+        UnRef();
+        
+        return FALSE;
+    }

 
 

-    Create(bitmap, colour);
+    return TRUE;

 }
 
 }
 

-// Construct a mask from a bitmap and a palette index indicating
-// the transparent area
-wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
+bool wxBitmap::CreateFromImage( const wxImage& image, int depth )

 {
 {

-    m_pixmap = (WXPixmap) 0;
+    UnRef();

 
 

-    Create(bitmap, paletteIndex);
-}
+    wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
+    wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") )

 
 

-// Construct a mask from a mono bitmap (copies the bitmap).
-wxMask::wxMask(const wxBitmap& bitmap)
-{
-    m_pixmap = (WXPixmap) 0;
+    m_refData = new wxBitmapRefData();

 
 

-    Create(bitmap);
-}
+    M_BMPDATA->m_display = wxGlobalDisplay();
+    
+    Display *xdisplay = (Display*) M_BMPDATA->m_display;
+    
+    int xscreen = DefaultScreen( xdisplay );
+    Window xroot = RootWindow( xdisplay, xscreen );
+    Visual* xvisual = DefaultVisual( xdisplay, xscreen );
+    
+    int bpp = DefaultDepth( xdisplay, xscreen );
+    
+    int width = image.GetWidth();
+    int height = image.GetHeight();
+    M_BMPDATA->m_width = width;
+    M_BMPDATA->m_height = height;

 
 

-wxMask::~wxMask()
-{
-    // TODO: this may be the wrong display
-    if ( m_pixmap )
-        XFreePixmap ((Display*) wxGetDisplay(), (Pixmap) m_pixmap);
-}
+    if (depth != 1) depth = bpp;
+    M_BMPDATA->m_bpp = depth;
+    
+    if (depth == 1)
+    {
+        wxFAIL_MSG( "mono images later" );
+    }
+    else
+    {
+        // Create image
+    
+        XImage *data_image = XCreateImage( xdisplay, xvisual, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
+        data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
+    
+        if (data_image->data == NULL)
+        {
+            wxLogError( wxT("Out of memory.") );  // TODO clean
+            return FALSE;
+        }

 
 

-// Create a mask from a mono bitmap (copies the bitmap).
-bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap))
-{
-    // TODO
-    return FALSE;
-}
+        M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, depth );

 
 

-// Create a mask from a bitmap and a palette index indicating
-// the transparent area
-bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex))
-{
-    // TODO
-    return FALSE;
-}
+        // Create mask

 
 

-// Create a mask from a bitmap and a colour indicating
-// the transparent area
-bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour))
-{
-    // TODO
-    return FALSE;
-}
+        XImage *mask_image = (XImage*) NULL;
+        if (image.HasMask())
+        { 
+            mask_image = XCreateImage( xdisplay, xvisual, 1, ZPixmap, 0, 0, width, height, 32, 0 );
+            mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
+        
+            if (mask_image->data == NULL)
+            {
+                wxLogError( wxT("Out of memory.") ); // TODO clean
+                return FALSE;
+            }
+            
+            wxMask *mask = new wxMask();
+            mask->SetDisplay( xdisplay );
+            mask->SetBitmap( (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, 1 ) );

 
 

-/*
-* wxBitmapHandler
-*/
+            SetMask( mask );
+        }

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
+        // Retrieve info

 
 

-bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(type),
-                             int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
-{
-    return FALSE;
-}
+        XVisualInfo vinfo_template;
+        XVisualInfo *vi;

 
 

-bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), long WXUNUSED(type),
-                               int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
-{
-    return FALSE;
-}
+        vinfo_template.visual = xvisual;
+        vinfo_template.visualid = XVisualIDFromVisual( xvisual );
+        vinfo_template.depth = bpp;
+        int nitem = 0;

 
 

-bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), int WXUNUSED(type),
-                               const wxPalette *WXUNUSED(palette))
-{
-    return FALSE;
-}
+        vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
+        wxASSERT_MSG( vi, wxT("No visual info") );

 
 

-/*
-* Standard handlers
-*/
+        if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
+        if (bpp < 8) bpp = 8;

 
 

-class WXDLLEXPORT wxXBMFileHandler: public wxBitmapHandler
-{
-    DECLARE_DYNAMIC_CLASS(wxXBMFileHandler)
-public:
-    inline wxXBMFileHandler()
-    {
-        m_name = "XBM file";
-        m_extension = "xbm";
-        m_type = wxBITMAP_TYPE_XBM;
-    };
+        // Render

 
 

-    virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
-        int desiredWidth, int desiredHeight);
-};
-IMPLEMENT_DYNAMIC_CLASS(wxXBMFileHandler, wxBitmapHandler)
+        enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
+        byte_order b_o = RGB;

 
 

-bool wxXBMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long WXUNUSED(flags),
-                                int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
-{
-    M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
+        if (bpp > 8)
+        {
+            if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask))      b_o = RGB;
+            else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask))  b_o = RBG;
+            else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask))   b_o = BRG;
+            else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
+            else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask))   b_o = GRB;
+            else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask))  b_o = GBR;
+        }

 
 

-    int hotX, hotY;
-    unsigned int w, h;
-    Pixmap pixmap;
+        XFree( vi );

 
 

-    Display *dpy = (Display*) wxGetDisplay();
-    M_BITMAPDATA->m_display = (WXDisplay*) dpy;
+        int r_mask = image.GetMaskRed();
+        int g_mask = image.GetMaskGreen();
+        int b_mask = image.GetMaskBlue();

 
 

-    int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)),
-        (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY);
-    M_BITMAPHANDLERDATA->m_width = w;
-    M_BITMAPHANDLERDATA->m_height = h;
-    M_BITMAPHANDLERDATA->m_depth = 1;
-    M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
+        unsigned char* data = image.GetData();
+        wxASSERT_MSG( data, "No image data" );

 
 

-    if ((value == BitmapFileInvalid) ||
-        (value == BitmapOpenFailed) ||
-        (value == BitmapNoMemory))
-    {
-        M_BITMAPHANDLERDATA->m_ok = FALSE;
-        M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) 0;
-    }
-    else
-        M_BITMAPHANDLERDATA->m_ok = TRUE;
+        bool hasMask = image.HasMask();

 
 

-    return M_BITMAPHANDLERDATA->m_ok ;
-}
+        int index = 0;
+        for (int y = 0; y < height; y++)
+        {
+            for (int x = 0; x < width; x++)
+            {
+                int r = data[index];
+                index++;
+                int g = data[index];
+                index++;
+                int b = data[index];
+                index++;
+
+                if (hasMask)
+                {
+                    if ((r == r_mask) && (b == b_mask) && (g == g_mask))
+                        XPutPixel( mask_image, x, y, 0 );
+                    else
+                        XPutPixel( mask_image, x, y, 1 );
+                }

 
 

-class WXDLLEXPORT wxXBMDataHandler: public wxBitmapHandler
-{
-    DECLARE_DYNAMIC_CLASS(wxXBMDataHandler)
-public:
-    inline wxXBMDataHandler()
-    {
-        m_name = "XBM data";
-        m_extension = "xbm";
-        m_type = wxBITMAP_TYPE_XBM_DATA;
-    };
+                switch (bpp)
+                {
+                    case 8:
+                    {
+                        int pixel = 0;
+#if 0                        
+                        if (wxTheApp->m_colorCube)
+                        {
+                            pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
+                        }
+                        else
+                        {
+                            GdkColormap *cmap = gtk_widget_get_default_colormap();
+                            GdkColor *colors = cmap->colors;
+                            int max = 3 * (65536);
+    
+                            for (int i = 0; i < cmap->size; i++)
+                            {
+                                int rdiff = (r << 8) - colors[i].red;
+                                int gdiff = (g << 8) - colors[i].green;
+                                int bdiff = (b << 8) - colors[i].blue;
+                                int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
+                                if (sum < max) { pixel = i; max = sum; }
+                            }
+                        }
+#endif    
+                        XPutPixel( data_image, x, y, pixel );
+                        break;
+                    }
+                    case 12:  // SGI only
+                    {
+                        int pixel = 0;
+                        switch (b_o)
+                        {
+                            case RGB: pixel = ((r & 0xf0) << 4) | (g & 0xf0) | ((b & 0xf0) >> 4); break;
+                            case RBG: pixel = ((r & 0xf0) << 4) | (b & 0xf0) | ((g & 0xf0) >> 4); break;
+                            case GRB: pixel = ((g & 0xf0) << 4) | (r & 0xf0) | ((b & 0xf0) >> 4); break;
+                            case GBR: pixel = ((g & 0xf0) << 4) | (b & 0xf0) | ((r & 0xf0) >> 4); break;
+                            case BRG: pixel = ((b & 0xf0) << 4) | (r & 0xf0) | ((g & 0xf0) >> 4); break;
+                            case BGR: pixel = ((b & 0xf0) << 4) | (g & 0xf0) | ((r & 0xf0) >> 4); break;
+                        }
+                        XPutPixel( data_image, x, y, pixel );
+                        break;
+                    }
+                    case 15:
+                    {
+                        int pixel = 0;
+                        switch (b_o)
+                        {
+                            case RGB: pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); break;
+                            case RBG: pixel = ((r & 0xf8) << 7) | ((b & 0xf8) << 2) | ((g & 0xf8) >> 3); break;
+                            case GRB: pixel = ((g & 0xf8) << 7) | ((r & 0xf8) << 2) | ((b & 0xf8) >> 3); break;
+                            case GBR: pixel = ((g & 0xf8) << 7) | ((b & 0xf8) << 2) | ((r & 0xf8) >> 3); break;
+                            case BRG: pixel = ((b & 0xf8) << 7) | ((r & 0xf8) << 2) | ((g & 0xf8) >> 3); break;
+                            case BGR: pixel = ((b & 0xf8) << 7) | ((g & 0xf8) << 2) | ((r & 0xf8) >> 3); break;
+                        }
+                        XPutPixel( data_image, x, y, pixel );
+                        break;
+                    }
+                    case 16:
+                    {
+                        // I actually don't know if for 16-bit displays, it is alway the green
+                        // component or the second component which has 6 bits.
+                        int pixel = 0;
+                        switch (b_o)
+                        {
+                            case RGB: pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); break;
+                            case RBG: pixel = ((r & 0xf8) << 8) | ((b & 0xfc) << 3) | ((g & 0xf8) >> 3); break;
+                            case GRB: pixel = ((g & 0xf8) << 8) | ((r & 0xfc) << 3) | ((b & 0xf8) >> 3); break;
+                            case GBR: pixel = ((g & 0xf8) << 8) | ((b & 0xfc) << 3) | ((r & 0xf8) >> 3); break;
+                            case BRG: pixel = ((b & 0xf8) << 8) | ((r & 0xfc) << 3) | ((g & 0xf8) >> 3); break;
+                            case BGR: pixel = ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | ((r & 0xf8) >> 3); break;
+                        }
+                        XPutPixel( data_image, x, y, pixel );
+                        break;
+                    }
+                    case 32:
+                    case 24:
+                    {
+                        int pixel = 0;
+                        switch (b_o)
+                        {
+                            case RGB: pixel = (r << 16) | (g << 8) | b; break;
+                            case RBG: pixel = (r << 16) | (b << 8) | g; break;
+                            case BRG: pixel = (b << 16) | (r << 8) | g; break;
+                            case BGR: pixel = (b << 16) | (g << 8) | r; break;
+                            case GRB: pixel = (g << 16) | (r << 8) | b; break;
+                            case GBR: pixel = (g << 16) | (b << 8) | r; break;
+                        }
+                        XPutPixel( data_image, x, y, pixel );
+                    }
+                    default: break;
+                }
+            } // for
+        }  // for

 
 

-    virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
-};
-IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
+        // Blit picture

 
 

-bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags),
-                              int width, int height, int WXUNUSED(depth))
-{
-    M_BITMAPHANDLERDATA->m_width = width;
-    M_BITMAPHANDLERDATA->m_height = height;
-    M_BITMAPHANDLERDATA->m_depth = 1;
-    M_BITMAPHANDLERDATA->m_freePixmap = TRUE;
+        GC gc = XCreateGC( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, 0, NULL );
+        XPutImage( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, gc, data_image, 0, 0, 0, 0, width, height );

 
 

-    Display *dpy = (Display*) wxGetDisplay();
-    M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy;
+        XDestroyImage( data_image );
+        XFreeGC( xdisplay, gc );

 
 

-    M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) XCreateBitmapFromData (dpy, RootWindow (dpy, DefaultScreen (dpy)), (char*) data, width, height);
-    M_BITMAPHANDLERDATA->m_ok = (M_BITMAPHANDLERDATA->m_pixmap != (WXPixmap) 0) ;
+        // Blit mask
+        
+        if (image.HasMask())
+        {
+            GC gc = XCreateGC( xdisplay, (Pixmap) GetMask()->GetBitmap(), 0, NULL );
+            XPutImage( xdisplay, (Pixmap) GetMask()->GetBitmap(), gc, data_image, 0, 0, 0, 0, width, height );
+
+            XDestroyImage( mask_image );
+            XFreeGC( xdisplay, gc );
+        }
+    }

 
     return TRUE;
 }
 
 
     return TRUE;
 }
 

-void wxBitmap::CleanUpHandlers()
+static void wxCalcPrecAndShift( unsigned long mask, int *shift, int *prec )

 {
 {

-    wxNode *node = sm_handlers.First();
-    while ( node )
+  *shift = 0;
+  *prec = 0;
+
+  while (!(mask & 0x1))

     {
     {

-        wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
-        wxNode *next = node->Next();
-        delete handler;
-        delete node;
-        node = next;
+      (*shift)++;
+      mask >>= 1;

     }
     }

-}
-
-void wxBitmap::InitStandardHandlers()
-{
-    // Initialize all standard bitmap or derived class handlers here.
-    AddHandler(new wxXBMFileHandler);
-    AddHandler(new wxXBMDataHandler);

 
 

-    // XPM will be handled by wxImage
+  while (mask & 0x1)
+    {
+      (*prec)++;
+      mask >>= 1;
+    }

 }
 
 }
 

-// Creates a bitmap with transparent areas drawn in
-// the given colour.
-wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour)
+wxImage wxBitmap::ConvertToImage() const

 {
 {

-    wxBitmap newBitmap(bitmap.GetWidth(),
-        bitmap.GetHeight(),
-        bitmap.GetDepth());
-    wxMemoryDC destDC;
-    wxMemoryDC srcDC;
-    srcDC.SelectObject(bitmap);
-    destDC.SelectObject(newBitmap);
-
-#if 0
-    wxBrush brush(colour, wxSOLID);
-    destDC.SetOptimization(FALSE);
-    destDC.SetBackground(brush);
-    destDC.Clear();
-    destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), & srcDC, 0, 0, wxCOPY, TRUE);
-#endif
-
-    return newBitmap;
-}
-
-//-----------------------------------------------------------------------------
-// wxImage conversion routines
-//-----------------------------------------------------------------------------
+    wxImage image;

 
 

-/*
+    wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );

 
 

-Date: Wed, 05 Jan 2000 11:45:40 +0100
-From: Frits Boel <boel@niob.knaw.nl>
-To: julian.smart@ukonline.co.uk
-Subject: Patch for Motif ConvertToBitmap
+    Display *xdisplay = (Display*) M_BMPDATA->m_display;
+    wxASSERT_MSG( xdisplay, wxT("No display") );
+    
+    int xscreen = DefaultScreen( xdisplay );
+    Visual* xvisual = DefaultVisual( xdisplay, xscreen );
+    
+    int bpp = DefaultDepth( xdisplay, xscreen );
+    
+    XImage *x_image = NULL;
+    if (GetPixmap())
+    {
+        x_image = XGetImage( xdisplay, (Pixmap) GetPixmap(),
+            0, 0,
+            GetWidth(), GetHeight(),
+            AllPlanes, ZPixmap );
+    } else
+    if (GetBitmap())
+    {
+        x_image = XGetImage( xdisplay, (Pixmap) GetBitmap(),
+            0, 0,
+            GetWidth(), GetHeight(),
+            AllPlanes, ZPixmap );
+    } else
+    {
+        wxFAIL_MSG( wxT("Ill-formed bitmap") );
+    }

 
 

-Hi Julian,
+    wxCHECK_MSG( x_image, wxNullImage, wxT("couldn't create image") );

 
 

-I've been working on a wxWin application for image processing. From the
-beginning, I was surprised by the (lack of) speed of ConvertToBitmap,
-till I looked in the source code of image.cpp. I saw that converting a
-wxImage to a bitmap with 8-bit pixels is done with comparing every pixel
-to the 256 colors of the palet. A very time-consuming piece of code!
+    image.Create( GetWidth(), GetHeight() );
+    char unsigned *data = image.GetData();

 
 

-Because I wanted a faster application, I've made a 'patch' for this. In
-short: every pixel of the image is compared to a sorted list with
-colors. If the color is found in the list, the palette entry is
-returned; if the color is not found, the color palette is searched and
-then the palette entry is returned and the color added to the sorted
-list.
+    if (!data)
+    {
+        XDestroyImage( x_image );
+        wxFAIL_MSG( wxT("couldn't create image") );
+        return wxNullImage;
+    }

 
 

-Maybe there is another method for this, namely changing the palette
-itself (if the colors are known, as is the case with tiffs with a
-colormap). I did not look at this, maybe someone else did?
+    XImage *x_image_mask = NULL;
+    if (GetMask())
+    {
+        x_image_mask = XGetImage( xdisplay, (Pixmap) GetMask()->GetBitmap(),
+            0, 0,
+            GetWidth(), GetHeight(), 
+            AllPlanes, ZPixmap );

 
 

-The code of the patch is attached, have a look on it, and maybe you will
-ship it with the next release of wxMotif?
+        image.SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
+    }

 
 

-Regards,
+    int red_shift_right = 0;
+    int green_shift_right = 0;
+    int blue_shift_right = 0;
+    int red_shift_left = 0;
+    int green_shift_left = 0;
+    int blue_shift_left = 0;
+    bool use_shift = FALSE;

 
 

-Frits Boel
-Software engineer at Hubrecht Laboratory, The Netherlands.
+    if (GetPixmap())
+    {
+        // Retrieve info
+
+        XVisualInfo vinfo_template;
+        XVisualInfo *vi;
+
+        vinfo_template.visual = xvisual;
+        vinfo_template.visualid = XVisualIDFromVisual( xvisual );
+        vinfo_template.depth = bpp;
+        int nitem = 0;
+
+        vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
+        wxASSERT_MSG( vi, wxT("No visual info") );
+        
+        int red_prec,green_prec,blue_prec;
+        int red_shift,green_shift,blue_shift;
+        wxCalcPrecAndShift( vi->red_mask, &red_shift, &red_prec );
+        wxCalcPrecAndShift( vi->green_mask, &green_shift, &green_prec );
+        wxCalcPrecAndShift( vi->blue_mask, &blue_shift, &blue_prec );
+        if (bpp == 16) bpp = red_prec + green_prec + blue_prec;
+        
+        red_shift_right = red_shift;
+        red_shift_left = 8-red_prec;
+        green_shift_right = green_shift;
+        green_shift_left = 8-green_prec;
+        blue_shift_right = blue_shift;
+        blue_shift_left = 8-blue_prec;
+        
+#if 0
+        use_shift = (vi->visual->c_class == TrueColor) || (vi->visual->c_class == DirectColor);
+#else
+        use_shift = TRUE;
+#endif
+        
+        XFree( vi );
+    }
+    if (GetBitmap())
+    {
+        bpp = 1;
+    }

 
 

-*/

 
 

-class wxSearchColor
-{
-public:
-  wxSearchColor( void );
-  wxSearchColor( int size, XColor *colors );
-  ~wxSearchColor( void );
+//    GdkColormap *cmap = gtk_widget_get_default_colormap();

 
 

-  int SearchColor( int r, int g, int b );
-private:
-  int AddColor( unsigned int value, int pos );
+    long pos = 0;
+    for (int j = 0; j < GetHeight(); j++)
+    {
+        for (int i = 0; i < GetWidth(); i++)
+        {
+            unsigned long pixel = XGetPixel( x_image, i, j );
+            if (bpp == 1)
+            {
+                if (pixel == 0)
+                {
+                    data[pos]   = 0;
+                    data[pos+1] = 0;
+                    data[pos+2] = 0;
+                }
+                else
+                {
+                    data[pos]   = 255;
+                    data[pos+1] = 255;
+                    data[pos+2] = 255;
+                }
+            }
+            else if (use_shift)
+            {
+                data[pos] =   (pixel >> red_shift_right)   << red_shift_left;
+                data[pos+1] = (pixel >> green_shift_right) << green_shift_left;
+                data[pos+2] = (pixel >> blue_shift_right)  << blue_shift_left;
+            }
+#if 0
+            else if (cmap->colors)
+            {
+                data[pos] =   cmap->colors[pixel].red   >> 8;
+                data[pos+1] = cmap->colors[pixel].green >> 8;
+                data[pos+2] = cmap->colors[pixel].blue  >> 8;
+            }
+#endif
+            else
+            {
+                wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
+            }

 
 

-  int          size;
-  XColor       *colors;
-  unsigned int *color;
-  int          *entry;
+            if (x_image_mask)
+            {
+                int mask_pixel = XGetPixel( x_image_mask, i, j );
+                if (mask_pixel == 0)
+                {
+                    data[pos] = 16;
+                    data[pos+1] = 16;
+                    data[pos+2] = 16;
+                }
+            }

 
 

-  int bottom;
-  int top;
-};
+            pos += 3;
+        }
+    }

 
 

-wxSearchColor::wxSearchColor( void )
-{
-  size   = 0;
-  colors = (XColor*) NULL;
-  color  = (unsigned int *) NULL;
-  entry  = (int*) NULL;
+    XDestroyImage( x_image );
+    if (x_image_mask) XDestroyImage( x_image_mask );

 
 

-  bottom = 0;
-  top    = 0;
+    return image;

 }
 
 }
 

-wxSearchColor::wxSearchColor( int size_, XColor *colors_ )
+wxBitmap::wxBitmap( const wxBitmap& bmp )

 {
 {

-    int i;
-    size   = size_;
-    colors = colors_;
-    color  = new unsigned int[size];
-    entry  = new int         [size];
-
-    for (i = 0; i < size; i++ ) {
-        entry[i] = -1;
-    }
-
-    bottom = top = ( size >> 1 );
+    Ref( bmp );

 }
 
 }
 

-wxSearchColor::~wxSearchColor( void )
+wxBitmap::wxBitmap( const wxString &filename, int type )

 {
 {

-  if ( color ) delete color;
-  if ( entry ) delete entry;
+    LoadFile( filename, type );

 }
 
 }
 

-int wxSearchColor::SearchColor( int r, int g, int b )
+wxBitmap::wxBitmap( const char bits[], int width, int height, int WXUNUSED(depth) )

 {
 {

-  unsigned int value = ( ( ( r * 256 ) + g ) * 256 ) + b;
-  int          begin = bottom;
-  int          end   = top;
-  int          middle = 0;
-
-  while ( begin <= end ) {
-
-    middle = ( begin + end ) >> 1;
+    m_refData = new wxBitmapRefData();

 
 

-    if ( value == color[middle] ) {
-      return( entry[middle] );
-    } else if ( value < color[middle] ) {
-      end = middle - 1;
-    } else {
-      begin = middle + 1;
-    }
+    M_BMPDATA->m_display = wxGlobalDisplay();

 
 

-  }
+    Display *xdisplay = (Display*) M_BMPDATA->m_display;
+    
+    int xscreen = DefaultScreen( xdisplay );
+    Window xroot = RootWindow( xdisplay, xscreen );
+    
+    M_BMPDATA->m_mask = (wxMask *) NULL;
+    M_BMPDATA->m_bitmap = (WXPixmap) XCreateBitmapFromData( xdisplay, xroot, (char *) bits, width, height );
+    M_BMPDATA->m_width = width;
+    M_BMPDATA->m_height = height;
+    M_BMPDATA->m_bpp = 1;

 
 

-  return AddColor( value, middle );
+    wxCHECK_RET( M_BMPDATA->m_bitmap, wxT("couldn't create bitmap") );

 }
 
 }
 

-int wxSearchColor::AddColor( unsigned int value, int pos )
+wxBitmap::~wxBitmap()

 {
 {

-  int i;
-  int pixel = -1;
-  int max = 3 * (65536);
-  for ( i = 0; i < 256; i++ ) {
-    int rdiff = ((value >> 8) & 0xFF00 ) - colors[i].red;
-    int gdiff = ((value     ) & 0xFF00 ) - colors[i].green;
-    int bdiff = ((value << 8) & 0xFF00 ) - colors[i].blue;
-    int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
-    if (sum < max) { pixel = i; max = sum; }
-  }
-
-  if ( entry[pos] < 0 ) {
-    color[pos] = value;
-    entry[pos] = pixel;
-  } else if ( value < color[pos] ) {
-
-    if ( bottom > 0 ) {
-      for ( i = bottom; i < pos; i++ ) {
-        color[i-1] = color[i];
-        entry[i-1] = entry[i];
-      }
-      bottom--;
-      color[pos-1] = value;
-      entry[pos-1] = pixel;
-    } else if ( top < size-1 ) {
-      for ( i = top; i >= pos; i-- ) {
-        color[i+1] = color[i];
-        entry[i+1] = entry[i];
-      }
-      top++;
-      color[pos] = value;
-      entry[pos] = pixel;
-    }
-
-  } else {
-
-    if ( top < size-1 ) {
-      for ( i = top; i > pos; i-- ) {
-        color[i+1] = color[i];
-        entry[i+1] = entry[i];
-      }
-      top++;
-      color[pos+1] = value;
-      entry[pos+1] = pixel;
-    } else if ( bottom > 0 ) {
-      for ( i = bottom; i < pos; i++ ) {
-        color[i-1] = color[i];
-        entry[i-1] = entry[i];
-      }
-      bottom--;
-      color[pos] = value;
-      entry[pos] = pixel;
-    }
-
-  }
-
-  return( pixel );

 }
 
 }
 

-
-bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
+wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )

 {
 {

-    wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
-    wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") )
+    if ( m_refData != bmp.m_refData )
+        Ref( bmp );

 
 

-    m_refData = new wxBitmapRefData();
+    return *this;
+}

 
 

-    int width = image.GetWidth();
-    int height = image.GetHeight();
+bool wxBitmap::operator == ( const wxBitmap& bmp ) const
+{
+    return m_refData == bmp.m_refData;
+}

 
 

-    SetHeight( height );
-    SetWidth( width );
+bool wxBitmap::operator != ( const wxBitmap& bmp ) const
+{
+    return m_refData != bmp.m_refData;
+}

 
 

-    Display *dpy = (Display*) wxGetDisplay();
-    Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
-    int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
+bool wxBitmap::Ok() const
+{
+    return (m_refData != NULL);
+}

 
 

-    // Create image
+int wxBitmap::GetHeight() const
+{
+    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );

 
 

-    XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
-    data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
+    return M_BMPDATA->m_height;
+}

 
 

-    Create( width, height, bpp );
+int wxBitmap::GetWidth() const
+{
+    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );

 
 

-    // Create mask
+    return M_BMPDATA->m_width;
+}

 
 

-    XImage *mask_image = (XImage*) NULL;
-    if (image.HasMask())
-    {
-        mask_image = XCreateImage( dpy, vis, 1, ZPixmap, 0, 0, width, height, 32, 0 );
-        mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
-    }
+int wxBitmap::GetDepth() const
+{
+    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );

 
 

-    // Retrieve depth info
+    return M_BMPDATA->m_bpp;
+}

 
 

-    XVisualInfo vinfo_template;
-    XVisualInfo *vi;
+wxMask *wxBitmap::GetMask() const
+{
+    wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );

 
 

-    vinfo_template.visual = vis;
-    vinfo_template.visualid = XVisualIDFromVisual( vis );
-    vinfo_template.depth = bpp;
-    int nitem = 0;
+    return M_BMPDATA->m_mask;
+}

 
 

-    vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
+void wxBitmap::SetMask( wxMask *mask )
+{
+    wxCHECK_RET( Ok(), wxT("invalid bitmap") );

 
 

-    wxCHECK_MSG( vi, FALSE, wxT("no visual") );
+    if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;

 
 

-    XFree( vi );
+    M_BMPDATA->m_mask = mask;
+}

 
 

-    if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
-    if (bpp < 8) bpp = 8;
+bool wxBitmap::CopyFromIcon(const wxIcon& icon)
+{
+    *this = icon;
+    return TRUE;
+}

 
 

-    // Render
+wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
+{
+    wxCHECK_MSG( Ok() &&
+                 (rect.x >= 0) && (rect.y >= 0) &&
+                 (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height),
+                 wxNullBitmap, wxT("invalid bitmap or bitmap region") );

 
 

-    enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
-    byte_order b_o = RGB;
+    wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp );
+    wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );

 
 

-    if (bpp >= 24)
+    
+    wxFAIL_MSG( "wxBitmap::GetSubBitmap not yet implemented" );
+    
+#if 0
+    if (ret.GetPixmap())

     {
     {

-        if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask))      b_o = RGB;
-        else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask))  b_o = RGB;
-        else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask))   b_o = BRG;
-        else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
-        else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask))   b_o = GRB;
-        else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask))  b_o = GBR;
+        GdkGC *gc = gdk_gc_new( ret.GetPixmap() );
+        gdk_draw_pixmap( ret.GetPixmap(), gc, GetPixmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
+        gdk_gc_destroy( gc );
+    }
+    else
+    {
+        GdkGC *gc = gdk_gc_new( ret.GetBitmap() );
+        gdk_wx_draw_bitmap( ret.GetBitmap(), gc, GetBitmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
+        gdk_gc_destroy( gc );

     }
 
     }
 

-    int r_mask = image.GetMaskRed();
-    int g_mask = image.GetMaskGreen();
-    int b_mask = image.GetMaskBlue();
-
-    XColor colors[256];
-    if (bpp == 8)
+    if (GetMask())

     {
     {

-        Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
+        wxMask *mask = new wxMask;
+        mask->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, rect.width, rect.height, 1 );
+
+        GdkGC *gc = gdk_gc_new( mask->m_bitmap );
+        gdk_wx_draw_bitmap( mask->m_bitmap, gc, M_BMPDATA->m_mask->m_bitmap, 0, 0, rect.x, rect.y, rect.width, rect.height );
+        gdk_gc_destroy( gc );

 
 

-        for (int i = 0; i < 256; i++) colors[i].pixel = i;
-        XQueryColors( dpy, cmap, colors, 256 );
+        ret.SetMask( mask );

     }
     }

+#endif

 
 

-    wxSearchColor scolor( 256, colors );
-    unsigned char* data = image.GetData();
+    return ret;
+}

 
 

-    bool hasMask = image.HasMask();
+bool wxBitmap::SaveFile( const wxString &name, int type, wxPalette *WXUNUSED(palette) )
+{
+    wxCHECK_MSG( Ok(), FALSE, wxT("invalid bitmap") );

 
 

-    int index = 0;
-    for (int y = 0; y < height; y++)
+    // Try to save the bitmap via wxImage handlers:

     {
     {

-        for (int x = 0; x < width; x++)
-        {
-            int r = data[index];
-            index++;
-            int g = data[index];
-            index++;
-            int b = data[index];
-            index++;
-
-            if (hasMask)
-            {
-              if ((r == r_mask) && (b == b_mask) && (g == g_mask))
-                XPutPixel( mask_image, x, y, 0 );
-              else
-                XPutPixel( mask_image, x, y, 1 );
-            }
-
-            switch (bpp)
-            {
-            case 8:
-                {
-#if 0 // Old, slower code
-                    int pixel = -1;
-                    /*
-                    if (wxTheApp->m_colorCube)
-                    {
-                    pixel = wxTheApp->m_colorCube
-                    [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
-                    }
-                    else
-                    {
-                    */
-                    int max = 3 * (65536);
-                    for (int i = 0; i < 256; i++)
-                    {
-                        int rdiff = (r << 8) - colors[i].red;
-                        int gdiff = (g << 8) - colors[i].green;
-                        int bdiff = (b << 8) - colors[i].blue;
-                        int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
-                        if (sum < max) { pixel = i; max = sum; }
-                    }
-                    /*
-                    }
-                    */
-#endif
+        wxImage image( *this );
+        if (image.Ok()) return image.SaveFile( name, type );
+    }

 
 

-                    // And this is all to get the 'right' color...
-                    int pixel = scolor.SearchColor( r, g, b );
-                    XPutPixel( data_image, x, y, pixel );
-                    break;
-                }
-            case 15:
-                {
-                    int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
-                    XPutPixel( data_image, x, y, pixel );
-                    break;
-                }
-            case 16:
-                {
-                    int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
-                    XPutPixel( data_image, x, y, pixel );
-                    break;
-                }
-            case 32:
-            case 24:
-                {
-                    int pixel = 0;
-                    switch (b_o)
-                    {
-                    case RGB: pixel = (r << 16) | (g << 8) | b; break;
-                    case RBG: pixel = (r << 16) | (b << 8) | g; break;
-                    case BRG: pixel = (b << 16) | (r << 8) | g; break;
-                    case BGR: pixel = (b << 16) | (g << 8) | r; break;
-                    case GRB: pixel = (g << 16) | (r << 8) | b; break;
-                    case GBR: pixel = (g << 16) | (b << 8) | r; break;
-                    }
-                    XPutPixel( data_image, x, y, pixel );
-                }
-            default: break;
-            }
-        } // for
-    }  // for
+    return FALSE;
+}

 
 

-    // Blit picture
+bool wxBitmap::LoadFile( const wxString &name, int type )
+{
+    UnRef();

 
 

-    XGCValues gcvalues;
-    gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) );
-    GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues );
-    XPutImage( dpy, (Drawable)GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height );
+    if (!wxFileExists(name)) return FALSE;

 
 

-    XDestroyImage( data_image );
-    XFreeGC( dpy, gc );

 
 

-    // Blit mask
-    if (image.HasMask())
+    if (type == wxBITMAP_TYPE_XPM)

     {
     {

-        wxBitmap maskBitmap(width, height, 1);
+        m_refData = new wxBitmapRefData();

 
 

-        GC gcMask = XCreateGC( dpy, (Pixmap) maskBitmap.GetPixmap(), 0, (XGCValues*)NULL );
-        XPutImage( dpy, (Drawable)maskBitmap.GetPixmap(), gcMask, mask_image, 0, 0, 0, 0, width, height );
+        M_BMPDATA->m_display = wxGlobalDisplay();
+    
+        Display *xdisplay = (Display*) M_BMPDATA->m_display;
+    
+        int xscreen = DefaultScreen( xdisplay );
+        Window xroot = RootWindow( xdisplay, xscreen );
+    
+        int bpp = DefaultDepth( xdisplay, xscreen );

 
 

-        XDestroyImage( mask_image );
-        XFreeGC( dpy, gcMask );
+        XpmAttributes xpmAttr;
+        xpmAttr.valuemask = XpmReturnInfos;    // nothing yet, but get infos back

 
 

-        wxMask* mask = new wxMask;
-        mask->SetPixmap(maskBitmap.GetPixmap());
+        Pixmap pixmap;
+        Pixmap mask = 0;
+    
+        int ErrorStatus = XpmReadFileToPixmap( xdisplay, xroot, (char*) name.c_str(), &pixmap, &mask, &xpmAttr);
+    
+        if (ErrorStatus == XpmSuccess)
+        {
+            M_BMPDATA->m_width = xpmAttr.width;
+            M_BMPDATA->m_height = xpmAttr.height;

 
 

-        SetMask(mask);
+            M_BMPDATA->m_bpp = bpp;  // mono as well?

 
 

-        maskBitmap.SetPixmapNull();
+            XpmFreeAttributes(&xpmAttr);
+        
+            M_BMPDATA->m_bitmap = (WXPixmap) pixmap;
+        
+            if (mask)
+            {
+                M_BMPDATA->m_mask = new wxMask;
+                M_BMPDATA->m_mask->SetBitmap( (WXPixmap) mask );
+                M_BMPDATA->m_mask->SetDisplay( xdisplay );
+            }
+        }
+        else
+        {
+            UnRef();
+            
+            return FALSE;
+        }
+    }
+    else // try if wxImage can load it
+    {
+        wxImage image;
+        if (!image.LoadFile( name, type )) return FALSE;
+        if (image.Ok()) *this = image.ConvertToBitmap();
+        else return FALSE;

     }
     }

-

 
     return TRUE;
 }
 
 
     return TRUE;
 }
 

-wxImage wxBitmap::ConvertToImage() const
+wxPalette *wxBitmap::GetPalette() const

 {
 {

-    wxImage image;
-    
-    wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
-
-    Display *dpy = (Display*) wxGetDisplay();
-    Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
-    int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
-
-    XImage *ximage = XGetImage( dpy,
-        (Drawable)GetPixmap(),
-        0, 0,
-        GetWidth(), GetHeight(),
-        AllPlanes, ZPixmap );
-
-    wxCHECK_MSG( ximage, wxNullImage, wxT("couldn't create image") );
-
-    image.Create( GetWidth(), GetHeight() );
-    char unsigned *data = image.GetData();
-
-    if (!data)
-    {
-        XDestroyImage( ximage );
-        wxFAIL_MSG( wxT("couldn't create image") );
-        return wxNullImage;
-    }
+    if (!Ok()) return (wxPalette *) NULL;

 
 

-    /*
-    GdkImage *gdk_image_mask = (GdkImage*) NULL;
-    if (GetMask())
-    {
-    gdk_image_mask = gdk_image_get( GetMask()->GetBitmap(),
-    0, 0,
-    GetWidth(), GetHeight() );
-
-      image.SetMaskColour( 16, 16, 16 );  // anything unlikely and dividable
-      }
-    */
+    return M_BMPDATA->m_palette;
+}

 
 

-    // Retrieve depth info
+void wxBitmap::SetHeight( int height )
+{
+    if (!m_refData) m_refData = new wxBitmapRefData();

 
 

-    XVisualInfo vinfo_template;
-    XVisualInfo *vi;
+    M_BMPDATA->m_height = height;
+}

 
 

-    vinfo_template.visual = vis;
-    vinfo_template.visualid = XVisualIDFromVisual( vis );
-    vinfo_template.depth = bpp;
-    int nitem = 0;
+void wxBitmap::SetWidth( int width )
+{
+    if (!m_refData) m_refData = new wxBitmapRefData();

 
 

-    vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
+    M_BMPDATA->m_width = width;
+}

 
 

-    wxCHECK_MSG( vi, wxNullImage, wxT("no visual") );
+void wxBitmap::SetDepth( int depth )
+{
+    if (!m_refData) m_refData = new wxBitmapRefData();

 
 

-    if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
+    M_BMPDATA->m_bpp = depth;
+}

 
 

-    XFree( vi );
+void wxBitmap::SetPixmap( WXPixmap pixmap )
+{
+    if (!m_refData) m_refData = new wxBitmapRefData();

 
 

-    XColor colors[256];
-    if (bpp == 8)
-    {
-        Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
+    M_BMPDATA->m_pixmap = pixmap;
+}

 
 

-        for (int i = 0; i < 256; i++) colors[i].pixel = i;
-        XQueryColors( dpy, cmap, colors, 256 );
-    }
+void wxBitmap::SetBitmap( WXPixmap bitmap )
+{
+    if (!m_refData) m_refData = new wxBitmapRefData();

 
 

-    long pos = 0;
-    for (int j = 0; j < GetHeight(); j++)
-    {
-        for (int i = 0; i < GetWidth(); i++)
-        {
-            int pixel = XGetPixel( ximage, i, j );
-            if (bpp <= 8)
-            {
-                data[pos] = colors[pixel].red >> 8;
-                data[pos+1] = colors[pixel].green >> 8;
-                data[pos+2] = colors[pixel].blue >> 8;
-            } else if (bpp == 15)
-            {
-                data[pos] = (pixel >> 7) & 0xf8;
-                data[pos+1] = (pixel >> 2) & 0xf8;
-                data[pos+2] = (pixel << 3) & 0xf8;
-            } else if (bpp == 16)
-            {
-                data[pos] = (pixel >> 8) & 0xf8;
-                data[pos+1] = (pixel >> 3) & 0xfc;
-                data[pos+2] = (pixel << 3) & 0xf8;
-            } else
-            {
-                data[pos] = (pixel >> 16) & 0xff;
-                data[pos+1] = (pixel >> 8) & 0xff;
-                data[pos+2] = pixel & 0xff;
-            }
+    M_BMPDATA->m_bitmap = bitmap;
+}

 
 

-            /*
-            if (gdk_image_mask)
-            {
-            int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
-            if (mask_pixel == 0)
-            {
-            data[pos] = 16;
-            data[pos+1] = 16;
-            data[pos+2] = 16;
-            }
-            }
-            */
+WXPixmap wxBitmap::GetPixmap() const
+{
+    wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );

 
 

-            pos += 3;
-        }
-    }
+    return M_BMPDATA->m_pixmap;
+}

 
 

-    XDestroyImage( ximage );
-    /*
-    if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
-    */
+WXPixmap wxBitmap::GetBitmap() const
+{
+    wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );

 
 

-    return image;
+    return M_BMPDATA->m_bitmap;

 }
 
 }
 

-bool wxBitmap::CopyFromIcon(const wxIcon& icon)
+WXDisplay *wxBitmap::GetDisplay() const

 {
 {

-    wxBitmap* bitmap = (wxBitmap*) & icon;
+    wxCHECK_MSG( Ok(), (WXDisplay*) NULL, wxT("invalid bitmap") );

 
 

-    *this = *bitmap;
-
-    return TRUE;
+    return M_BMPDATA->m_display;

 }
 }

+

diff --git a/src/x11/cursor.cpp b/src/x11/cursor.cpp
index 10f452ceb64e2ac164c4cfc8a902edd003caa7d4..55847bb23e3feba14d77a604c1a398216581a579 100644 (file)
--- a/src/x11/cursor.cpp
+++ b/src/x11/cursor.cpp
@@ -19,422 +19,204 @@
 #include "wx/app.h"
 #include "wx/utils.h"
 
 #include "wx/app.h"
 #include "wx/utils.h"
 

-#ifdef __VMS__
-#pragma message disable nosimpint
-#endif
-#ifdef __VMS__
-#pragma message enable nosimpint
-#endif
-

 #include "wx/x11/private.h"
 #include <X11/cursorfont.h>
 #include "wx/x11/private.h"
 #include <X11/cursorfont.h>

-#include <X11/Xutil.h>

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
-IMPLEMENT_DYNAMIC_CLASS(wxXCursor, wxObject)
+//-----------------------------------------------------------------------------
+// wxCursor
+//-----------------------------------------------------------------------------
+
+class wxCursorRefData: public wxObjectRefData
+{
+public:
+
+    wxCursorRefData();
+    ~wxCursorRefData();
+
+    WXCursor     m_cursor;
+    WXDisplay   *m_display;
+};

 
 wxCursorRefData::wxCursorRefData()
 {
 
 wxCursorRefData::wxCursorRefData()
 {

-    m_width = 32; m_height = 32;
-    m_cursorId = wxCURSOR_NONE;
+    m_cursor = NULL;
+    m_display = NULL;

 }
 
 wxCursorRefData::~wxCursorRefData()
 {
 }
 
 wxCursorRefData::~wxCursorRefData()
 {

-    wxNode* node = m_cursors.First();
-    while (node)
-    {
-        wxXCursor* c = (wxXCursor*) node->Data();
-        // TODO: how to delete cursor?
-        // XDestroyCursor((Display*) c->m_display, (Cursor) c->m_cursor); // ??
-        delete c;
-        node = node->Next();
-    }
+    if (m_cursor)
+        XFreeCursor( (Display*) m_display, (Cursor) m_cursor );

 }
 
 }
 

+//-----------------------------------------------------------------------------
+
+#define M_CURSORDATA ((wxCursorRefData *)m_refData)
+
+IMPLEMENT_DYNAMIC_CLASS(wxCursor,wxObject)
+

 wxCursor::wxCursor()
 {
 wxCursor::wxCursor()
 {

+

 }
 
 }
 

-wxCursor::wxCursor(const char bits[], int width, int height,
-    int hotSpotX, int hotSpotY, const char maskBits[])
+wxCursor::wxCursor( int cursorId )

 {
 {

-    m_refData = new wxCursorRefData;
-
-    Display *dpy = (Display*) wxGetDisplay();
-    int screen_num =  DefaultScreen (dpy);
+    m_refData = new wxCursorRefData();

 
 

-    Pixmap pixmap = XCreatePixmapFromBitmapData (dpy,
-                                          RootWindow (dpy, DefaultScreen(dpy)),
-                                          (char*) bits, width, height,
-                                          1 , 0 , 1);
-
-    Pixmap mask_pixmap = None;
-    if (maskBits != NULL)
+    M_CURSORDATA->m_display = wxGlobalDisplay();
+    wxASSERT_MSG( M_CURSORDATA->m_display, wxT("No display") );
+    
+    int x_cur = XC_left_ptr;
+    switch (cursorId)

     {
     {

-        mask_pixmap = XCreatePixmapFromBitmapData (dpy,
-                                          RootWindow (dpy, DefaultScreen(dpy)),
-                                          (char*) maskBits, width, height,
-                                          1 , 0 , 1);
+        case wxCURSOR_DEFAULT:          x_cur = XC_left_ptr; break;
+        case wxCURSOR_HAND:             x_cur = XC_hand1; break;
+        case wxCURSOR_CROSS:            x_cur = XC_crosshair; break;
+        case wxCURSOR_SIZEWE:           x_cur = XC_sb_h_double_arrow; break;
+        case wxCURSOR_SIZENS:           x_cur = XC_sb_v_double_arrow; break;
+        case wxCURSOR_ARROWWAIT:
+        case wxCURSOR_WAIT:
+        case wxCURSOR_WATCH:            x_cur = XC_watch; break;
+        case wxCURSOR_SIZING:           x_cur = XC_sizing; break;
+        case wxCURSOR_SPRAYCAN:         x_cur = XC_spraycan; break;
+        case wxCURSOR_IBEAM:            x_cur = XC_xterm; break;
+        case wxCURSOR_PENCIL:           x_cur = XC_pencil; break;
+        case wxCURSOR_NO_ENTRY:         x_cur = XC_pirate; break;
+        case wxCURSOR_SIZENWSE:
+        case wxCURSOR_SIZENESW:         x_cur = XC_fleur; break;
+        case wxCURSOR_QUESTION_ARROW:   x_cur = XC_question_arrow; break;
+        case wxCURSOR_PAINT_BRUSH:      x_cur = XC_spraycan; break;
+        case wxCURSOR_MAGNIFIER:        x_cur = XC_plus; break;
+        case wxCURSOR_CHAR:             x_cur = XC_xterm; break;
+        case wxCURSOR_LEFT_BUTTON:      x_cur = XC_leftbutton; break;
+        case wxCURSOR_MIDDLE_BUTTON:    x_cur = XC_middlebutton; break;
+        case wxCURSOR_RIGHT_BUTTON:     x_cur = XC_rightbutton; break;
+        case wxCURSOR_BULLSEYE:         x_cur = XC_target; break;
+
+        case wxCURSOR_POINT_LEFT:       x_cur = XC_sb_left_arrow; break;
+        case wxCURSOR_POINT_RIGHT:      x_cur = XC_sb_right_arrow; break;
+/*
+        case wxCURSOR_DOUBLE_ARROW:     x_cur = XC_double_arrow; break;
+        case wxCURSOR_CROSS_REVERSE:    x_cur = XC_cross_reverse; break;
+        case wxCURSOR_BASED_ARROW_UP:   x_cur = XC_based_arrow_up; break;
+        case wxCURSOR_BASED_ARROW_DOWN: x_cur = XC_based_arrow_down; break;
+*/
+        default:
+            wxFAIL_MSG(wxT("unsupported cursor type"));
+            // will use the standard one

     }
 
     }
 

-    XColor foreground_color;
-    XColor background_color;
-    foreground_color.pixel = BlackPixel(dpy, screen_num);
-    background_color.pixel = WhitePixel(dpy, screen_num);
-    Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
-    XQueryColor(dpy, cmap, &foreground_color);
-    XQueryColor(dpy, cmap, &background_color);
-
-    Cursor cursor = XCreatePixmapCursor (dpy,
-                                  pixmap,
-                                  mask_pixmap,
-                                  &foreground_color,
-                                  &background_color,
-                                  hotSpotX , 
-                                  hotSpotY);
-
-    XFreePixmap( dpy, pixmap );
-    if (mask_pixmap != None)
-    {
-        XFreePixmap( dpy, mask_pixmap );
-    }
+    M_CURSORDATA->m_cursor = (WXCursor) XCreateFontCursor( (Display*) M_CURSORDATA->m_display, x_cur );
+}

 
 

-    if (cursor)
-    {
-        wxXCursor *c = new wxXCursor;
+wxCursor::wxCursor(const char bits[], int width, int  height,
+                   int hotSpotX, int hotSpotY,
+                   const char maskBits[], wxColour *fg, wxColour *bg)
+{
+   wxFAIL_MSG( "wxCursor creation from bits not yet implemented" );
+}

 
 

-        c->m_cursor = (WXCursor) cursor;
-        c->m_display = (WXDisplay*) dpy;
-        M_CURSORDATA->m_cursors.Append(c);
-        M_CURSORDATA->m_ok = TRUE;
-    }
-    else
-    {
-        M_CURSORDATA->m_ok = TRUE;
-    }
+
+wxCursor::wxCursor( const wxCursor &cursor )
+{
+    Ref( cursor );

 }
 
 }
 

-wxCursor::wxCursor(const wxString& name, long flags, int hotSpotX, int hotSpotY)
+#if wxUSE_IMAGE
+wxCursor::wxCursor( const wxImage & image )

 {
 {

-    // Must be an XBM file
-    if (flags != wxBITMAP_TYPE_XBM)
-        return;
+   wxFAIL_MSG( "wxCursor creation from wxImage not yet implemented" );
+}
+#endif

 
 

-    m_refData = new wxCursorRefData;
+wxCursor::~wxCursor()
+{
+}

 
 

-    int hotX = -1, hotY = -1;
-    unsigned int w, h;
-    Pixmap pixmap;
+wxCursor& wxCursor::operator = ( const wxCursor& cursor )
+{
+    if (*this == cursor)
+        return (*this);

 
 

-    Display *dpy = (Display*) wxGetDisplay();
-    int screen_num =  DefaultScreen (dpy);
+    Ref( cursor );

 
 

-    int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)),
-                        (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY);
+    return *this;
+}

 
 

-    M_BITMAPDATA->m_width = w;
-    M_BITMAPDATA->m_height = h;
-    M_BITMAPDATA->m_depth = 1;
+bool wxCursor::operator == ( const wxCursor& cursor ) const
+{
+    return m_refData == cursor.m_refData;
+}

 
 

-    if ((value == BitmapFileInvalid) ||
-        (value == BitmapOpenFailed) ||
-        (value == BitmapNoMemory))
-    {
-    }
-    else
-    {
-        XColor foreground_color;
-        XColor background_color;
-        foreground_color.pixel = BlackPixel(dpy, screen_num);
-        background_color.pixel = WhitePixel(dpy, screen_num);
-        Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
-        XQueryColor(dpy, cmap, &foreground_color);
-        XQueryColor(dpy, cmap, &background_color);
-
-        // TODO: how do we determine whether hotX, hotY were read correctly?
-        if (hotX < 0 || hotY < 0)
-        {
-            hotX = hotSpotX;
-            hotY = hotSpotY;
-        }
-        if (hotX < 0 || hotY < 0)
-        {
-            hotX = 0;
-            hotY = 0;
-        }
-
-        Pixmap mask_pixmap = None;
-        Cursor cursor = XCreatePixmapCursor (dpy,
-                                      pixmap,
-                                      mask_pixmap,
-                                      &foreground_color,
-                                      &background_color,
-                                      hotX,
-                                      hotY);
-
-        XFreePixmap( dpy, pixmap );
-        if (cursor)
-        {
-            wxXCursor *c = new wxXCursor;
-
-            c->m_cursor = (WXCursor) cursor;
-            c->m_display = (WXDisplay*) dpy;
-            M_CURSORDATA->m_cursors.Append(c);
-            M_CURSORDATA->m_ok = TRUE;
-        }
-    }
+bool wxCursor::operator != ( const wxCursor& cursor ) const
+{
+    return m_refData != cursor.m_refData;
+}

 
 

+bool wxCursor::Ok() const
+{
+    return (m_refData != NULL);

 }
 
 }
 

-// Cursors by stock number
-wxCursor::wxCursor(wxStockCursor id)
+WXCursor wxCursor::GetCursor() const

 {
 {

-    m_refData = new wxCursorRefData;
-    M_CURSORDATA->m_cursorId = id;
-    M_CURSORDATA->m_ok = TRUE;
+    return M_CURSORDATA->m_cursor;
+}

 
 

-    WXDisplay* display = wxGetDisplay();
-    if (!display)
-      return;
+//-----------------------------------------------------------------------------
+// busy cursor routines
+//-----------------------------------------------------------------------------

 
 

-    WXCursor cursor = GetXCursor(display);
-    if (cursor)
-    {
-        wxXCursor* c = new wxXCursor;
-        c->m_cursor = cursor;
-        c->m_display = wxGetDisplay();
-        M_CURSORDATA->m_cursors.Append(c);
-        M_CURSORDATA->m_ok = TRUE;
-    }
-}
+/* extern */ wxCursor g_globalCursor;

 
 

-wxCursor::~wxCursor()
+static wxCursor  gs_savedCursor;
+static int       gs_busyCount = 0;
+
+const wxCursor &wxBusyCursor::GetStoredCursor()

 {
 {

+    return gs_savedCursor;

 }
 
 }
 

-// Motif-specific: create/get a cursor for the current display
-WXCursor wxCursor::GetXCursor(WXDisplay* display)
+const wxCursor wxBusyCursor::GetBusyCursor()

 {
 {

-    if (!M_CURSORDATA)
-        return (WXCursor) 0;
-    wxNode* node = M_CURSORDATA->m_cursors.First();
-    while (node)
-    {
-        wxXCursor* c = (wxXCursor*) node->Data();
-        if (c->m_display == display)
-            return c->m_cursor;
-        node = node->Next();
-    }
+    return wxCursor(wxCURSOR_WATCH);
+}

 
 

-    // No cursor for this display, so let's see if we're an id-type cursor.
+void wxEndBusyCursor()
+{
+    if (--gs_busyCount > 0)
+        return;

 
 

-    if (M_CURSORDATA->m_cursorId != wxCURSOR_NONE)
-    {
-        WXCursor cursor = MakeCursor(display, M_CURSORDATA->m_cursorId);
-        if (cursor)
-        {
-            wxXCursor* c = new wxXCursor;
-            c->m_cursor = cursor;
-            c->m_display = display;
-            M_CURSORDATA->m_cursors.Append(c);
-            return cursor;
-        }
-        else
-            return (WXCursor) 0;
-    }
+    wxSetCursor( gs_savedCursor );
+    gs_savedCursor = wxNullCursor;

 
 

-    // Not an id-type cursor, so we don't know how to create it.
-    return (WXCursor) 0;
+    if (wxTheApp)
+        wxTheApp->SendIdleEvents();

 }
 
 }
 

-// Make a cursor from standard id
-WXCursor wxCursor::MakeCursor(WXDisplay* display, wxStockCursor id)
+void wxBeginBusyCursor( wxCursor *WXUNUSED(cursor) )

 {
 {

-    Display* dpy = (Display*) display;
-    Cursor cursor = (Cursor) 0;
+    if (gs_busyCount++ > 0)
+        return;

 
 

-    switch (id)
-    {
-        case wxCURSOR_WAIT:
-        {
-            cursor = XCreateFontCursor (dpy, XC_watch);
-            break;
-        }
-        case wxCURSOR_CROSS:
-        {
-            cursor = XCreateFontCursor (dpy, XC_crosshair);
-            break;
-        }
-        case wxCURSOR_CHAR:
-        {
-            // Nothing
-            break;
-        }
-        case wxCURSOR_HAND:
-        {
-            cursor = XCreateFontCursor (dpy, XC_hand1);
-            break;
-        }
-        case wxCURSOR_BULLSEYE:
-        {
-            cursor = XCreateFontCursor (dpy, XC_target);
-            break;
-        }
-        case wxCURSOR_PENCIL:
-       {
-            cursor = XCreateFontCursor (dpy, XC_pencil);
-            break;
-        }
-        case wxCURSOR_MAGNIFIER:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sizing);
-            break;
-        }
-        case wxCURSOR_IBEAM:
-        {
-            cursor = XCreateFontCursor (dpy, XC_xterm);
-            break;
-        }
-        case wxCURSOR_NO_ENTRY:
-        {
-            cursor = XCreateFontCursor (dpy, XC_pirate);
-            break;
-        }
-        case wxCURSOR_LEFT_BUTTON:
-        {
-            cursor = XCreateFontCursor (dpy, XC_leftbutton);
-            break;
-        }
-        case wxCURSOR_RIGHT_BUTTON:
-        {
-            cursor = XCreateFontCursor (dpy, XC_rightbutton);
-            break;
-        }
-        case wxCURSOR_MIDDLE_BUTTON:
-        {
-            cursor = XCreateFontCursor (dpy, XC_middlebutton);
-            break;
-        }
-        case wxCURSOR_QUESTION_ARROW:
-        {
-            cursor = XCreateFontCursor (dpy, XC_question_arrow);
-            break;
-        }
-        case wxCURSOR_SIZING:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sizing);
-            break;
-        }
-        case wxCURSOR_WATCH:
-        {
-            cursor = XCreateFontCursor (dpy, XC_watch);
-            break;
-        }
-        case wxCURSOR_SPRAYCAN:
-        {
-            cursor = XCreateFontCursor (dpy, XC_spraycan);
-            break;
-        }
-        case wxCURSOR_PAINT_BRUSH:
-        {
-            cursor = XCreateFontCursor (dpy, XC_spraycan);
-            break;
-        }
-        case wxCURSOR_SIZENWSE:
-        case wxCURSOR_SIZENESW:
-        {
-            // Not available in X
-            cursor = XCreateFontCursor (dpy, XC_crosshair);
-            break;
-        }
-        case wxCURSOR_SIZEWE:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
-            break;
-        }
-        case wxCURSOR_SIZENS:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sb_v_double_arrow);
-            break;
-        }
-        case wxCURSOR_POINT_LEFT:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sb_left_arrow);
-            break;
-        }
-        case wxCURSOR_POINT_RIGHT:
-        {
-            cursor = XCreateFontCursor (dpy, XC_sb_right_arrow);
-            break;
-        }
-        // (JD Huggins) added more stock cursors for X
-        // X-only cursors BEGIN
-        case wxCURSOR_CROSS_REVERSE:
-        {
-            cursor = XCreateFontCursor(dpy, XC_cross_reverse);
-            break;
-        }
-        case wxCURSOR_DOUBLE_ARROW:
-        {
-            cursor = XCreateFontCursor(dpy, XC_double_arrow);
-            break;
-        }
-        case wxCURSOR_BASED_ARROW_UP:
-        {
-            cursor = XCreateFontCursor(dpy, XC_based_arrow_up);
-            break;
-        }
-        case wxCURSOR_BASED_ARROW_DOWN:
-        {
-            cursor = XCreateFontCursor(dpy, XC_based_arrow_down);
-            break;
-        }
-        default:
-        case wxCURSOR_ARROW:
-        {
-            cursor = XCreateFontCursor (dpy, XC_top_left_arrow);
-            break;
-        }
-        case wxCURSOR_BLANK:
-        {
-            GC gc;
-            XGCValues gcv;
-            Pixmap empty_pixmap;
-            XColor blank_color;
-
-            empty_pixmap = XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
-                              16, 16, 1);
-            gcv.function = GXxor;
-            gc = XCreateGC (dpy,
-                    empty_pixmap,
-                    GCFunction,
-                    &gcv);
-            XCopyArea (dpy,
-                   empty_pixmap,
-                   empty_pixmap,
-                   gc,
-                   0, 0,
-                   16, 16,
-                   0, 0);
-            XFreeGC (dpy, gc);
-            cursor = XCreatePixmapCursor (dpy,
-                            empty_pixmap,
-                            empty_pixmap,
-                            &blank_color,
-                            &blank_color,
-                            8, 8);
-
-            break;
-        }
-    }
-    return (WXCursor) cursor;
+    wxASSERT_MSG( !gs_savedCursor.Ok(),
+                  wxT("forgot to call wxEndBusyCursor, will leak memory") );
+
+    gs_savedCursor = g_globalCursor;
+
+    wxSetCursor( wxCursor(wxCURSOR_WATCH) );
+
+    if (wxTheApp)
+        wxTheApp->SendIdleEvents();

 }
 
 }
 

-// Global cursor setting
-void wxSetCursor(const wxCursor& WXUNUSED(cursor))
+bool wxIsBusy()

 {
 {

-  // Nothing to do for Motif (no global cursor)
+    return gs_busyCount > 0;

 }
 
 }
 

-
+void wxSetCursor( const wxCursor& cursor )
+{
+    g_globalCursor = cursor;
+}

diff --git a/src/x11/dcclient.cpp b/src/x11/dcclient.cpp
index 509325d62891c84b5322e7113c84088945d973bb..c00bb29e357c26182a34e1fbf6a9c0e8a37c69c0 100644 (file)
--- a/src/x11/dcclient.cpp
+++ b/src/x11/dcclient.cpp
@@ -848,7 +848,6 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
 
     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
     
 
     wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
     

-#if 0

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


@@ -881,9 +880,11 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
     {
         wxImage image( bitmap );
         image.Rescale( ww, hh );
     {
         wxImage image( bitmap );
         image.Rescale( ww, hh );

+#if 0

         if (is_mono)
             use_bitmap = image.ConvertToMonoBitmap(255,255,255);
         else
         if (is_mono)
             use_bitmap = image.ConvertToMonoBitmap(255,255,255);
         else

+#endif

             use_bitmap = image.ConvertToBitmap();
     }
     else
             use_bitmap = image.ConvertToBitmap();
     }
     else


@@ -892,12 +893,13 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
     }
 
     /* apply mask if any */
     }
 
     /* apply mask if any */

-    GdkBitmap *mask = (GdkBitmap *) NULL;
+    WXPixmap mask = NULL;

     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();
     if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap();

-
+    {

         if (useMask && mask)
         {
         if (useMask && mask)
         {

-            GdkBitmap *new_mask = (GdkBitmap*) NULL;
+            WXPixmap new_mask = NULL;
+#if 0

             if (!m_currentClippingRegion.IsNull())
             {
                 GdkColor col;
             if (!m_currentClippingRegion.IsNull())
             {
                 GdkColor col;


@@ -917,53 +919,56 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap,
                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
                 gdk_gc_unref( gc );
             }
                 gdk_draw_rectangle( new_mask, gc, TRUE, 0, 0, ww, hh );
                 gdk_gc_unref( gc );
             }

-
+#endif

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

-                    gdk_gc_set_clip_mask( m_textGC, new_mask );
+                    XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) new_mask );

                 else
                 else

-                    gdk_gc_set_clip_mask( m_textGC, mask );
-                gdk_gc_set_clip_origin( m_textGC, xx, yy );
+                    XSetClipMask( (Display*) m_display, (GC) m_textGC, (Pixmap) mask );
+                XSetClipOrigin( (Display*) m_display, (GC) m_textGC, xx, yy );

             }
             else
             {
                 if (new_mask)
             }
             else
             {
                 if (new_mask)

-                    gdk_gc_set_clip_mask( m_penGC, new_mask );
+                    XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) new_mask );

                 else
                 else

-                    gdk_gc_set_clip_mask( m_penGC, mask );
-                gdk_gc_set_clip_origin( m_penGC, xx, yy );
+                    XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) mask );
+                XSetClipOrigin( (Display*) m_display, (GC) m_penGC, xx, yy );

             }
             }

+            

             if (new_mask)
             if (new_mask)

-                gdk_bitmap_unref( new_mask );
+               XFreePixmap( (Display*) m_display, (Pixmap) new_mask );

         }
         }

+    }

 
     /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
        drawing a mono-bitmap (XBitmap) we use the current text GC */
     if (is_mono)
 
     /* Draw XPixmap or XBitmap, depending on what the wxBitmap contains. For
        drawing a mono-bitmap (XBitmap) we use the current text GC */
     if (is_mono)

-        gdk_wx_draw_bitmap( m_window, m_textGC, use_bitmap.GetBitmap(), 0, 0, xx, yy, -1, -1 );
+        XCopyPlane( (Display*) m_display, (Pixmap) use_bitmap.GetBitmap(), (Window) m_window,
+            (GC) m_textGC, 0, 0, w, h, xx, yy, 1 );

     else
     else

-        gdk_draw_pixmap( m_window, m_penGC, use_bitmap.GetPixmap(), 0, 0, xx, yy, -1, -1 );
+        XCopyArea( (Display*) m_display, (Pixmap) use_bitmap.GetPixmap(), (Window) m_window,
+            (GC) m_penGC, 0, 0, w, h, xx, yy );

 
     /* remove mask again if any */
     if (useMask && mask)
     {
         if (is_mono)
         {
 
     /* remove mask again if any */
     if (useMask && mask)
     {
         if (is_mono)
         {

-            gdk_gc_set_clip_mask( m_textGC, (GdkBitmap *) NULL );
-            gdk_gc_set_clip_origin( m_textGC, 0, 0 );
+            XSetClipMask( (Display*) m_display, (GC) m_textGC, None );
+            XSetClipOrigin( (Display*) m_display, (GC) m_textGC, 0, 0 );

             if (!m_currentClippingRegion.IsNull())
             if (!m_currentClippingRegion.IsNull())

-                gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() );
+                XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() );

         }
         else
         {
         }
         else
         {

-            gdk_gc_set_clip_mask( m_penGC, (GdkBitmap *) NULL );
-            gdk_gc_set_clip_origin( m_penGC, 0, 0 );
+            XSetClipMask( (Display*) m_display, (GC) m_penGC, None );
+            XSetClipOrigin( (Display*) m_display, (GC) m_penGC, 0, 0 );

             if (!m_currentClippingRegion.IsNull())
             if (!m_currentClippingRegion.IsNull())

-                gdk_gc_set_clip_region( m_penGC, m_currentClippingRegion.GetRegion() );
+                XSetRegion( (Display*) m_display, (GC) m_penGC, (Region) m_currentClippingRegion.GetX11Region() );

         }
     }
         }
     }

-#endif

 }
 
 bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
 }
 
 bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,


@@ -996,7 +1001,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he
     {
         xsrcMask = xsrc; ysrcMask = ysrc;
     }
     {
         xsrcMask = xsrc; ysrcMask = ysrc;
     }

-
+    

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


@@ -1232,13 +1237,6 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
     x = XLOG2DEV(x);
     y = YLOG2DEV(y);
 
     x = XLOG2DEV(x);
     y = YLOG2DEV(y);
 

-    XCharStruct overall_return;
-    int direction = 0;
-    int slen = text.Length();
-    int ascent = 0;
-    int descent = 0;
-    (void)XTextExtents((XFontStruct*) xfont, (char*) (const char*) text, slen, &direction,
-                               &ascent, &descent, &overall_return);

 #if 0
     wxCoord width = gdk_string_width( font, text.mbc_str() );
     wxCoord height = font->ascent + font->descent;
 #if 0
     wxCoord width = gdk_string_width( font, text.mbc_str() );
     wxCoord height = font->ascent + font->descent;


@@ -1255,8 +1253,7 @@ void wxWindowDC::DoDrawText( const wxString &text, wxCoord x, wxCoord y )
     if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
        {
         XDrawString( (Display*) m_display, (Window) m_window, 
     if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
        {
         XDrawString( (Display*) m_display, (Window) m_window, 

-            (GC) m_textGC, x, y + ascent, text.c_str(), text.Len() );
-       wxLogDebug("Drawing text %s at %d, %d", text.c_str(), x, y);
+            (GC) m_textGC, x, y + xfont->ascent, text.c_str(), text.Len() );

        }
 
 #if 0
        }
 
 #if 0


@@ -1930,6 +1927,13 @@ wxClientDC::wxClientDC( wxWindow *win )
           : wxWindowDC( win )
 {
     wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
           : wxWindowDC( win )
 {
     wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );

+    
+#ifdef __WXUNIVERSAL__
+    wxPoint ptOrigin = win->GetClientAreaOrigin();
+    SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
+    wxSize size = win->GetClientSize();
+    SetClippingRegion(wxPoint(0, 0), size);
+#endif // __WXUNIVERSAL__

 }
 
 void wxClientDC::DoGetSize(int *width, int *height) const
 }
 
 void wxClientDC::DoGetSize(int *width, int *height) const

diff --git a/src/x11/icon.cpp b/src/x11/icon.cpp
index e357f22925e7a1d2125fdb3b2ade93f6b6662f94..e563e7b5482499a6d7c89235d7545890727638e3 100644 (file)
--- a/src/x11/icon.cpp
+++ b/src/x11/icon.cpp
@@ -16,72 +16,42 @@
 #include "wx/icon.h"
 #include "wx/window.h"
 
 #include "wx/icon.h"
 #include "wx/window.h"
 

-#ifdef __VMS__
-#pragma message disable nosimpint
-#endif
-
-#ifdef __VMS__
-#pragma message enable nosimpint
-#endif
-

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

-IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
-
-/*
-* Icons
-*/
+//-----------------------------------------------------------------------------
+// wxIcon
+//-----------------------------------------------------------------------------

 
 

-wxIcon::wxIcon()
-{
-}
-
-// Create from XBM data
-wxIcon::wxIcon(const char bits[], int width, int height)
-{
-    (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, 1);
-}
+IMPLEMENT_DYNAMIC_CLASS(wxIcon,wxBitmap)

 
 

-// Create from XPM data
-wxIcon::wxIcon(char **data)
+wxIcon::wxIcon( const char **bits, int WXUNUSED(width), int WXUNUSED(height) ) :
+    wxBitmap( bits )

 {
 {

-    (void) Create((void*) data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);

 }
 
 }
 

-wxIcon::wxIcon(const char **data)
+wxIcon::wxIcon( char **bits, int WXUNUSED(width), int WXUNUSED(height) ) :
+    wxBitmap( bits )

 {
 {

-    (void) Create((void*) data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);

 }
 
 }
 

-wxIcon::wxIcon(const wxString& icon_file, long flags,
-               int desiredWidth, int desiredHeight)
-               
+wxIcon::wxIcon() :  wxBitmap()

 {
 {

-    LoadFile(icon_file, flags, desiredWidth, desiredHeight);

 }
 
 }
 

-wxIcon::~wxIcon()
+wxIcon::wxIcon( const wxIcon& icon ) : wxBitmap()

 {
 {

+    Ref(icon);

 }
 
 }
 

-bool wxIcon::LoadFile(const wxString& filename, long type,
-                      int desiredWidth, int desiredHeight)
+wxIcon& wxIcon::operator = ( const wxIcon& icon )

 {
 {

-    UnRef();
-    
-    m_refData = new wxBitmapRefData;
-    
-    wxBitmapHandler *handler = FindHandler(type);
-    
-    if ( handler )
-        return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
-    else
-        return FALSE;
+    if (*this == icon) return (*this);
+    Ref(icon);
+    return *this;

 }
 
 }
 

-bool wxIcon::CopyFromBitmap(const wxBitmap& bitmap)
+void wxIcon::CopyFromBitmap(const wxBitmap& bmp)

 {
 {

-    wxIcon* icon = (wxIcon*) (& bitmap);
+    wxIcon *icon = (wxIcon*)(&bmp);

     *this = *icon;
     *this = *icon;

-    return TRUE;

 }
 }

diff --git a/src/x11/toplevel.cpp b/src/x11/toplevel.cpp
index 648bb6ac3a0a7596f7516d8b479951ddca86ff3d..a357025c69f3968cbd0eabd8db433d69fdd34d3d 100644 (file)
--- a/src/x11/toplevel.cpp
+++ b/src/x11/toplevel.cpp
@@ -257,7 +257,7 @@ void wxTopLevelWindowX11::SetIcon(const wxIcon& icon)
         if (icon.GetMask())
         {
             wmHints->flags |= IconMaskHint;
         if (icon.GetMask())
         {
             wmHints->flags |= IconMaskHint;

-            wmHints->icon_mask = (Pixmap) icon.GetMask()->GetPixmap();
+            wmHints->icon_mask = (Pixmap) icon.GetMask()->GetBitmap();

         }
 
         XSetWMHints(wxGlobalDisplay(), (Window) GetMainWindow(), wmHints);
         }
 
         XSetWMHints(wxGlobalDisplay(), (Window) GetMainWindow(), wmHints);

diff --git a/src/x11/utils.cpp b/src/x11/utils.cpp
index eef7ceb4ec1c59cc7997e3d684c9260de4f3d7a0..b27a3f9428468eb52477b92541aa0772afcfb99b 100644 (file)
--- a/src/x11/utils.cpp
+++ b/src/x11/utils.cpp
@@ -530,85 +530,6 @@ wxSetDefaultResources (const Widget w, const char **resourceSpec, const char *na
 
 #endif // wxUSE_RESOURCES
 
 
 #endif // wxUSE_RESOURCES
 

-// ----------------------------------------------------------------------------
-// busy cursor stuff
-// ----------------------------------------------------------------------------
-
-static int wxBusyCursorCount = 0;
-
-// Helper function
-static void
-wxXSetBusyCursor (wxWindow * win, wxCursor * cursor)
-{
-    Display *display = (Display*) win->GetXDisplay();
-
-    Window xwin = (Window) win->GetXWindow();
-    if (!xwin)
-       return;
-
-    XSetWindowAttributes attrs;
-
-    if (cursor)
-    {
-        attrs.cursor = (Cursor) cursor->GetXCursor(display);
-    }
-    else
-    {
-        // Restore old cursor
-        if (win->GetCursor().Ok())
-            attrs.cursor = (Cursor) win->GetCursor().GetXCursor(display);
-        else
-            attrs.cursor = None;
-    }
-    if (xwin)
-        XChangeWindowAttributes (display, xwin, CWCursor, &attrs);
-
-    XFlush (display);
-
-    for(wxNode *node = win->GetChildren().First (); node; node = node->Next())
-    {
-        wxWindow *child = (wxWindow *) node->Data ();
-        wxXSetBusyCursor (child, cursor);
-    }
-}
-
-// Set the cursor to the busy cursor for all windows
-void wxBeginBusyCursor(wxCursor *cursor)
-{
-    wxBusyCursorCount++;
-    if (wxBusyCursorCount == 1)
-    {
-        for(wxNode *node = wxTopLevelWindows.First (); node; node = node->Next())
-        {
-            wxWindow *win = (wxWindow *) node->Data ();
-            wxXSetBusyCursor (win, cursor);
-        }
-    }
-}
-
-// Restore cursor to normal
-void wxEndBusyCursor()
-{
-    if (wxBusyCursorCount == 0)
-        return;
-
-    wxBusyCursorCount--;
-    if (wxBusyCursorCount == 0)
-    {
-        for(wxNode *node = wxTopLevelWindows.First (); node; node = node->Next())
-        {
-            wxWindow *win = (wxWindow *) node->Data ();
-            wxXSetBusyCursor (win, NULL);
-        }
-    }
-}
-
-// TRUE if we're between the above two calls
-bool wxIsBusy()
-{
-    return (wxBusyCursorCount > 0);
-}
-

 // ----------------------------------------------------------------------------
 // display info
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // display info
 // ----------------------------------------------------------------------------


@@ -682,10 +603,8 @@ WXDisplay *wxGetDisplay()
 {
     if (gs_currentDisplay)
         return gs_currentDisplay;
 {
     if (gs_currentDisplay)
         return gs_currentDisplay;

-    else if (wxTheApp)
-        return wxTheApp->GetInitialDisplay();

     else
     else

-        return (WXDisplay*) NULL;
+        return wxApp::GetDisplay();

 }
 
 bool wxSetDisplay(const wxString& display_name)
 }
 
 bool wxSetDisplay(const wxString& display_name)

diff --git a/src/x11/window.cpp b/src/x11/window.cpp
index 72833485e92756151600e69b868d5134a9fe6c25..1983d4bb41770e1c7d8d762832debed691c21b30 100644 (file)
--- a/src/x11/window.cpp
+++ b/src/x11/window.cpp
@@ -430,11 +430,10 @@ bool wxWindowX11::SetCursor(const wxCursor& cursor)
     else
         cursor2 = wxSTANDARD_CURSOR;
 
     else
         cursor2 = wxSTANDARD_CURSOR;
 

-    WXDisplay *dpy = GetXDisplay();
-    WXCursor x_cursor = cursor2->GetXCursor(dpy);
+    WXCursor x_cursor = cursor2->GetCursor();

 
     Window win = (Window) GetMainWindow();
 
     Window win = (Window) GetMainWindow();

-    XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
+    XDefineCursor((Display*) wxGlobalDisplay(), win, (Cursor) x_cursor);

 
     return TRUE;
 }
 
     return TRUE;
 }