diff --git a/include/wx/x11/app.h b/include/wx/x11/app.h index 39a94cbe30..402a8dbf09 100644 --- 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); - 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); + // 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; @@ -106,7 +109,6 @@ protected: WXWindow m_topLevelWidget; WXColormap m_mainColormap; - WXDisplay* m_initialDisplay; long m_maxRequestSize; wxEventLoop* m_mainLoop; diff --git a/include/wx/x11/bitmap.h b/include/wx/x11/bitmap.h index be3ae6febf..4fa848590a 100644 --- a/include/wx/x11/bitmap.h +++ b/include/wx/x11/bitmap.h @@ -1,11 +1,11 @@ ///////////////////////////////////////////////////////////////////////////// // Name: bitmap.h // Purpose: wxBitmap class -// Author: Julian Smart +// Author: Julian Smart, Robert Roebling // Modified by: // Created: 17/09/98 // RCS-ID: $Id$ -// Copyright: (c) Julian Smart +// Copyright: (c) Julian Smart, Robert Roebling // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -16,203 +16,117 @@ #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/gdiobj.h" -// Bitmap -class WXDLLEXPORT wxDC; -class WXDLLEXPORT wxControl; -class WXDLLEXPORT wxBitmap; -class WXDLLEXPORT wxBitmapHandler; -class WXDLLEXPORT wxIcon; -class WXDLLEXPORT wxCursor; -class WXDLLEXPORT wxImage; +//----------------------------------------------------------------------------- +// classes +//----------------------------------------------------------------------------- -// A mask is a mono bitmap used for drawing bitmaps -// transparently. -class WXDLLEXPORT wxMask: public wxObject +class wxMask; +class wxBitmap; +class wxImage; + +//----------------------------------------------------------------------------- +// wxMask +//----------------------------------------------------------------------------- + +class wxMask: public wxObject { - DECLARE_DYNAMIC_CLASS(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(); + + bool Create( const wxBitmap& bitmap, const wxColour& colour ); + bool Create( const wxBitmap& bitmap, int paletteIndex ); + bool Create( const wxBitmap& bitmap ); + + // implementation + WXPixmap GetBitmap() const { return m_bitmap; } + void SetBitmap( WXPixmap bitmap ) { m_bitmap = bitmap; } - bool Create(const wxBitmap& bitmap, const wxColour& colour); - bool Create(const wxBitmap& bitmap, int paletteIndex); - bool Create(const wxBitmap& bitmap); + WXDisplay *GetDisplay() const { return m_display; } + void SetDisplay( WXDisplay *display ) { m_display = display; } - WXPixmap GetPixmap() const { return m_pixmap; } - void SetPixmap(WXPixmap pixmap) { m_pixmap = pixmap; } - -protected: - WXPixmap m_pixmap; +private: + WXPixmap m_bitmap; + WXDisplay *m_display; + +private: + DECLARE_DYNAMIC_CLASS(wxMask) }; -class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData +//----------------------------------------------------------------------------- +// wxBitmap +//----------------------------------------------------------------------------- + +class wxBitmap: public wxGDIObject { - 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; -}; - -#define M_BITMAPDATA ((wxBitmapRefData *)m_refData) - -class WXDLLEXPORT wxBitmapHandler: public wxObject -{ - DECLARE_DYNAMIC_CLASS(wxBitmapHandler) -public: - wxBitmapHandler() { m_name = ""; m_extension = ""; m_type = 0; }; - - 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); - - 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; -}; - -#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData()) - -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(); + 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(int width, int height, int depth = -1); - virtual bool Create(void *data, long type, int width, int height, int depth = 1); - - 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); + int GetHeight() const; + int GetWidth() const; + int GetDepth() const; 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; } - -protected: - static wxList sm_handlers; - -protected: - bool CreateFromImage(const wxImage& image, int depth); -}; + // copies the contents and mask of the given (colour) icon to the bitmap + virtual bool CopyFromIcon(const wxIcon& icon); -// Creates a bitmap with transparent areas drawn in -// the given colour. -wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour); + wxMask *GetMask() const; + void SetMask( wxMask *mask ); + + wxBitmap GetSubBitmap( const wxRect& rect ) const; + + 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; + + WXDisplay *GetDisplay() const; + +protected: + bool CreateFromXpm(const char **bits); + bool CreateFromImage(const wxImage& image, int depth); + +private: + DECLARE_DYNAMIC_CLASS(wxBitmap) +}; #endif // _WX_BITMAP_H_ diff --git a/include/wx/x11/cursor.h b/include/wx/x11/cursor.h index c1d3bce5c3..65fe7721a7 100644 --- a/include/wx/x11/cursor.h +++ b/include/wx/x11/cursor.h @@ -18,67 +18,41 @@ #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; -}; +#if wxUSE_IMAGE +#include "wx/image.h" +#endif -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 -}; +//----------------------------------------------------------------------------- +// wxCursor +//----------------------------------------------------------------------------- -#define M_CURSORDATA ((wxCursorRefData *)m_refData) -#define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData) - -// Cursor -class WXDLLEXPORT wxCursor: public wxBitmap +class wxCursor: public wxObject { - DECLARE_DYNAMIC_CLASS(wxCursor) - public: + 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(); - - 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_ diff --git a/include/wx/x11/icon.h b/include/wx/x11/icon.h index b72e6c96f4..ee6e47fe75 100644 --- a/include/wx/x11/icon.h +++ b/include/wx/x11/icon.h @@ -18,42 +18,39 @@ #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(); - - // 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)); } + wxIcon( const wxIcon& icon); + wxIcon( const char **bits, int width=-1, int height=-1 ); - bool CopyFromBitmap(const wxBitmap& bitmap); + // 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_ diff --git a/samples/drawing/drawing.cpp b/samples/drawing/drawing.cpp index a019bf45cd..e08e04250d 100644 --- a/samples/drawing/drawing.cpp +++ b/samples/drawing/drawing.cpp @@ -43,7 +43,7 @@ // ---------------------------------------------------------------------------- // 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 diff --git a/src/gtk/app.cpp b/src/gtk/app.cpp index eb7f991c51..6b0b5276df 100644 --- a/src/gtk/app.cpp +++ b/src/gtk/app.cpp @@ -602,9 +602,7 @@ void wxApp::CleanUp() wxCleanUpResourceSystem(); #endif - if (wxTheColourDatabase) - delete wxTheColourDatabase; - + delete wxTheColourDatabase; wxTheColourDatabase = (wxColourDatabase*) NULL; wxDeleteStockObjects(); @@ -614,17 +612,16 @@ void wxApp::CleanUp() 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 - delete[] wxBuffer; - - wxClassInfo::CleanUpClasses(); - // 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 4f5ad6a770..94a89e1d5c 100644 --- 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 ) { + UnRef(); + 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 ) { + UnRef(); + 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; - 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; diff --git a/src/gtk1/app.cpp b/src/gtk1/app.cpp index eb7f991c51..6b0b5276df 100644 --- a/src/gtk1/app.cpp +++ b/src/gtk1/app.cpp @@ -602,9 +602,7 @@ void wxApp::CleanUp() wxCleanUpResourceSystem(); #endif - if (wxTheColourDatabase) - delete wxTheColourDatabase; - + delete wxTheColourDatabase; wxTheColourDatabase = (wxColourDatabase*) NULL; wxDeleteStockObjects(); @@ -614,17 +612,16 @@ void wxApp::CleanUp() 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 - delete[] wxBuffer; - - wxClassInfo::CleanUpClasses(); - // 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 4f5ad6a770..94a89e1d5c 100644 --- 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 ) { + UnRef(); + 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 ) { + UnRef(); + 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; - 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; diff --git a/src/x11/app.cpp b/src/x11/app.cpp index 31ad42aae9..6b85093ad0 100644 --- 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; +WXDisplay *wxApp::ms_display = NULL; bool wxApp::Initialize() { @@ -102,8 +103,6 @@ bool wxApp::Initialize() wxInitializeResourceSystem(); #endif - wxBitmap::InitStandardHandlers(); - wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER); wxModule::RegisterModules(); @@ -123,27 +122,21 @@ void wxApp::CleanUp() wxCleanUpResourceSystem(); #endif - wxDeleteStockObjects() ; - - // Destroy all GDI lists, etc. - - wxDeleteStockLists(); - delete wxTheColourDatabase; wxTheColourDatabase = NULL; - wxBitmap::CleanUpHandlers(); + wxDeleteStockObjects(); + + wxDeleteStockLists(); + + delete wxTheApp; + wxTheApp = NULL; 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; @@ -168,6 +161,46 @@ void wxApp::CleanUp() 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 @@ -179,9 +212,9 @@ int wxEntry( int argc, char *argv[] ) // 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) { @@ -206,14 +239,18 @@ int wxEntry( int argc, char *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(). + if ( retValue == 0 ) + { + if ( !wxTheApp->OnInit() ) + retValue = -1; + } - int retValue = 0; - if (wxTheApp->OnInit()) + if ( retValue == 0 ) { if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun(); } @@ -257,7 +294,6 @@ wxApp::wxApp() m_mainColormap = (WXColormap) NULL; m_topLevelWidget = (WXWindow) NULL; m_maxRequestSize = 0; - m_initialDisplay = (WXDisplay*) 0; 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); + 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; } diff --git a/src/x11/bitmap.cpp b/src/x11/bitmap.cpp index 9a4f71feb1..6d4c558c3e 100644 --- a/src/x11/bitmap.cpp +++ b/src/x11/bitmap.cpp @@ -1,11 +1,11 @@ ///////////////////////////////////////////////////////////////////////////// // Name: bitmap.cpp // Purpose: wxBitmap -// Author: Julian Smart +// Author: Julian Smart, Robert Roebling // Modified by: // Created: 17/09/98 // RCS-ID: $Id$ -// Copyright: (c) Julian Smart +// Copyright: (c) Julian Smart, Robert Roebling // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -13,24 +13,12 @@ #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/control.h" -#include "wx/dcmemory.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 @@ -38,214 +26,883 @@ #endif #include +//----------------------------------------------------------------------------- +// wxMask +//----------------------------------------------------------------------------- -IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) -IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) +IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject) + +wxMask::wxMask() +{ + m_bitmap = NULL; + m_display = NULL; +} + +wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour ) +{ + m_bitmap = NULL; + Create( bitmap, colour ); +} + +wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex ) +{ + m_bitmap = NULL; + Create( bitmap, paletteIndex ); +} + +wxMask::wxMask( const wxBitmap& bitmap ) +{ + m_bitmap = NULL; + Create( bitmap ); +} + +wxMask::~wxMask() +{ + if (m_bitmap) + XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap ); +} + +bool wxMask::Create( const wxBitmap& bitmap, + const wxColour& colour ) +{ + if (m_bitmap) + { + XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap ); + m_bitmap = NULL; + } + + m_display = bitmap.GetDisplay(); + + wxImage image( bitmap ); + if (!image.Ok()) return FALSE; + + m_display = bitmap.GetDisplay(); + + Display *xdisplay = (Display*) m_display; + + 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 ); + + XSetForeground( xdisplay, gc, WhitePixel(xdisplay,xscreen) ); + XSetFillStyle( xdisplay, gc, FillSolid ); + XFillRectangle( xdisplay, (Pixmap) m_bitmap, gc, 0, 0, image.GetWidth(), image.GetHeight() ); + + unsigned char *data = image.GetData(); + int index = 0; + + unsigned char red = colour.Red(); + unsigned char green = colour.Green(); + unsigned char blue = colour.Blue(); + + 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") ); + + 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; + } + + XSetForeground( xdisplay, gc, BlackPixel(xdisplay,xscreen) ); + + for (int j = 0; j < image.GetHeight(); j++) + { + int start_x = -1; + int i; + for (i = 0; i < image.GetWidth(); i++) + { + 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; + } + if (start_x != -1) + XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i, j ); + } + + XFreeGC( xdisplay, gc ); + + return TRUE; +} + +bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex ) +{ + unsigned char r,g,b; + wxPalette *pal = bitmap.GetPalette(); + + wxCHECK_MSG( pal, FALSE, wxT("Cannot create mask from bitmap without palette") ); + + pal->GetRGB(paletteIndex, &r, &g, &b); + + return Create(bitmap, wxColour(r, g, b)); +} + +bool wxMask::Create( const wxBitmap& bitmap ) +{ + if (m_bitmap) + { + XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap ); + m_bitmap = NULL; + } + + if (!bitmap.Ok()) return FALSE; + + wxCHECK_MSG( bitmap.GetBitmap(), FALSE, wxT("Cannot create mask from colour bitmap") ); + + m_display = bitmap.GetDisplay(); + + 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 ); + + if (!m_bitmap) return FALSE; + + GC gc = XCreateGC( (Display*) m_display, (Pixmap) m_bitmap, 0, NULL ); + + 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 ); + + return TRUE; +} + +//----------------------------------------------------------------------------- +// wxBitmap +//----------------------------------------------------------------------------- + +class wxBitmapRefData: public wxObjectRefData +{ +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; +}; wxBitmapRefData::wxBitmapRefData() { - m_ok = FALSE; + m_pixmap = NULL; + m_bitmap = NULL; + m_display = NULL; + m_mask = (wxMask *) NULL; 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; + m_bpp = 0; + m_palette = (wxPalette *) NULL; } 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; + 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; } -wxList wxBitmap::sm_handlers; +//----------------------------------------------------------------------------- #define M_BMPDATA ((wxBitmapRefData *)m_refData) +IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject) + wxBitmap::wxBitmap() { - m_refData = NULL; +} + +wxBitmap::wxBitmap( int width, int height, int depth ) +{ + Create( width, height, depth ); +} + +bool wxBitmap::Create( int width, int height, int depth ) +{ + 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) + { + 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 + { + 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 Ok(); +} + +bool wxBitmap::CreateFromXpm( const char **bits ) +{ + 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) + { + M_BMPDATA->m_width = xpmAttr.width; + M_BMPDATA->m_height = xpmAttr.height; + + M_BMPDATA->m_bpp = bpp; // mono as well? + +#if __WXDEBUG__ + unsigned int depthRet; + int xRet, yRet; + unsigned int widthRet, heightRet, borderWidthRet; + XGetGeometry( xdisplay, pixmap, &xroot, &xRet, &yRet, + &widthRet, &heightRet, &borderWidthRet, &depthRet); + + 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; + } + + return TRUE; +} + +bool wxBitmap::CreateFromImage( const wxImage& image, int depth ) +{ + UnRef(); + + wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") ) + wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") ) + + 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 ); + 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; + + 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; + } + + M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, depth ); + + // Create mask + + 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 ) ); + + SetMask( mask ); + } + + // 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") ); + + if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15; + if (bpp < 8) bpp = 8; + + // Render + + enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR }; + byte_order b_o = RGB; + + 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; + } + + XFree( vi ); + + int r_mask = image.GetMaskRed(); + int g_mask = image.GetMaskGreen(); + int b_mask = image.GetMaskBlue(); + + unsigned char* data = image.GetData(); + wxASSERT_MSG( data, "No image data" ); + + bool hasMask = image.HasMask(); + + 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 ); + } + + 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 + + // Blit picture + + 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 ); + + XDestroyImage( data_image ); + XFreeGC( xdisplay, gc ); + + // 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; +} + +static void wxCalcPrecAndShift( unsigned long mask, int *shift, int *prec ) +{ + *shift = 0; + *prec = 0; + + while (!(mask & 0x1)) + { + (*shift)++; + mask >>= 1; + } + + while (mask & 0x1) + { + (*prec)++; + mask >>= 1; + } +} + +wxImage wxBitmap::ConvertToImage() const +{ + wxImage image; + + wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") ); + + 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") ); + } + + wxCHECK_MSG( x_image, wxNullImage, wxT("couldn't create image") ); + + image.Create( GetWidth(), GetHeight() ); + char unsigned *data = image.GetData(); + + if (!data) + { + XDestroyImage( x_image ); + wxFAIL_MSG( wxT("couldn't create image") ); + return wxNullImage; + } + + XImage *x_image_mask = NULL; + if (GetMask()) + { + x_image_mask = XGetImage( xdisplay, (Pixmap) GetMask()->GetBitmap(), + 0, 0, + GetWidth(), GetHeight(), + AllPlanes, ZPixmap ); + + image.SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable + } + + 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; + + 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; + } + + +// GdkColormap *cmap = gtk_widget_get_default_colormap(); + + 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.") ); + } + + 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; + } + } + + pos += 3; + } + } + + XDestroyImage( x_image ); + if (x_image_mask) XDestroyImage( x_image_mask ); + + return image; +} + +wxBitmap::wxBitmap( const wxBitmap& bmp ) +{ + Ref( bmp ); +} + +wxBitmap::wxBitmap( const wxString &filename, int type ) +{ + LoadFile( filename, type ); +} + +wxBitmap::wxBitmap( const char bits[], int width, int height, int WXUNUSED(depth) ) +{ + 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 ); + + 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; + + wxCHECK_RET( M_BMPDATA->m_bitmap, wxT("couldn't create bitmap") ); } wxBitmap::~wxBitmap() { } -wxBitmap::wxBitmap(const char bits[], int width, int height, int depth) +wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp ) { - m_refData = new wxBitmapRefData; + if ( m_refData != bmp.m_refData ) + Ref( bmp ); - (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth); + return *this; } -wxBitmap::wxBitmap(int w, int h, int d) +bool wxBitmap::operator == ( const wxBitmap& bmp ) const { - (void)Create(w, h, d); + return m_refData == bmp.m_refData; } -wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth) +bool wxBitmap::operator != ( const wxBitmap& bmp ) const { - (void) Create(data, type, width, height, depth); + return m_refData != bmp.m_refData; } -wxBitmap::wxBitmap(const wxString& filename, long type) +bool wxBitmap::Ok() const { - LoadFile(filename, (int)type); + return (m_refData != NULL); } -bool wxBitmap::Create(int w, int h, int d) +int wxBitmap::GetHeight() const { - UnRef(); + wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); - m_refData = new wxBitmapRefData; - - if (d < 1) - d = wxDisplayDepth(); - - M_BITMAPDATA->m_width = w; - M_BITMAPDATA->m_height = h; - M_BITMAPDATA->m_depth = d; - M_BITMAPDATA->m_freePixmap = TRUE; - - Display *dpy = (Display*) wxGetDisplay(); - - M_BITMAPDATA->m_display = dpy; /* MATTHEW: [4] Remember the display */ - - M_BITMAPDATA->m_pixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)), - w, h, d); - - M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_pixmap != (WXPixmap) 0) ; - return M_BITMAPDATA->m_ok; + return M_BMPDATA->m_height; } -bool wxBitmap::LoadFile(const wxString& filename, long type) +int wxBitmap::GetWidth() const { - UnRef(); + wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); - m_refData = new wxBitmapRefData; - - wxBitmapHandler *handler = FindHandler(type); - - if ( handler == NULL ) { - wxImage image; - if (!image.LoadFile( filename, type )) return FALSE; - if (image.Ok()) - { - *this = image.ConvertToBitmap(); - return TRUE; - } - else return FALSE; - } - - return handler->LoadFile(this, filename, type, -1, -1); + return M_BMPDATA->m_width; } -bool wxBitmap::Create(void *data, long type, int width, int height, int depth) +int wxBitmap::GetDepth() const { - UnRef(); + wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); - m_refData = new wxBitmapRefData; - - wxBitmapHandler *handler = FindHandler(type); - - if ( handler == NULL ) { - wxLogWarning("no data bitmap handler for type %d defined.", type); - - return FALSE; - } - - return handler->Create(this, data, type, width, height, depth); + return M_BMPDATA->m_bpp; } -bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette) +wxMask *wxBitmap::GetMask() const { - wxBitmapHandler *handler = FindHandler(type); + wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") ); - if ( handler == NULL ) { // try wxImage - wxImage image( *this ); - if (image.Ok()) return image.SaveFile( filename, type ); - else return FALSE; - } - - return handler->SaveFile(this, filename, type, palette); + return M_BMPDATA->m_mask; } -void wxBitmap::SetWidth(int w) +void wxBitmap::SetMask( wxMask *mask ) { - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; + wxCHECK_RET( Ok(), wxT("invalid bitmap") ); - M_BITMAPDATA->m_width = w; + if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask; + + M_BMPDATA->m_mask = mask; } -void wxBitmap::SetHeight(int h) +bool wxBitmap::CopyFromIcon(const wxIcon& icon) { - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_height = h; -} - -void wxBitmap::SetDepth(int d) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_depth = d; -} - -void wxBitmap::SetQuality(int q) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_quality = q; -} - -void wxBitmap::SetOk(bool isOk) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_ok = isOk; -} - -void wxBitmap::SetPalette(const wxPalette& palette) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_bitmapPalette = palette ; -} - -void wxBitmap::SetMask(wxMask *mask) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_bitmapMask = mask ; + *this = icon; + return TRUE; } wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const @@ -255,800 +912,179 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const (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 ); + wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp ); wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") ); - // The remaining still TODO - return ret; -} - -void wxBitmap::AddHandler(wxBitmapHandler *handler) -{ - sm_handlers.Append(handler); -} - -void wxBitmap::InsertHandler(wxBitmapHandler *handler) -{ - sm_handlers.Insert(handler); -} - -bool wxBitmap::RemoveHandler(const wxString& name) -{ - wxBitmapHandler *handler = FindHandler(name); - if ( handler ) - { - sm_handlers.DeleteObject(handler); - return TRUE; - } - 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(); - } - 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; -} - -wxBitmapHandler *wxBitmap::FindHandler(long bitmapType) -{ - wxNode *node = sm_handlers.First(); - while ( node ) - { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if (handler->GetType() == bitmapType) - return handler; - node = node->Next(); - } - return NULL; -} - -/* -* wxMask -*/ - -wxMask::wxMask() -{ - m_pixmap = (WXPixmap) 0; -} - -// Construct a mask from a bitmap and a colour indicating -// the transparent area -wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour) -{ - m_pixmap = (WXPixmap) 0; - - Create(bitmap, colour); -} - -// Construct a mask from a bitmap and a palette index indicating -// the transparent area -wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex) -{ - m_pixmap = (WXPixmap) 0; - - Create(bitmap, paletteIndex); -} - -// Construct a mask from a mono bitmap (copies the bitmap). -wxMask::wxMask(const wxBitmap& bitmap) -{ - m_pixmap = (WXPixmap) 0; - - Create(bitmap); -} - -wxMask::~wxMask() -{ - // TODO: this may be the wrong display - if ( m_pixmap ) - XFreePixmap ((Display*) wxGetDisplay(), (Pixmap) m_pixmap); -} - -// Create a mask from a mono bitmap (copies the bitmap). -bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap)) -{ - // TODO - return FALSE; -} - -// 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 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; -} - -/* -* wxBitmapHandler -*/ - -IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) - -bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(type), - int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth)) -{ - return FALSE; -} - -bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), long WXUNUSED(type), - int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight)) -{ - return FALSE; -} - -bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), int WXUNUSED(type), - const wxPalette *WXUNUSED(palette)) -{ - return FALSE; -} - -/* -* Standard handlers -*/ - -class WXDLLEXPORT wxXBMFileHandler: public wxBitmapHandler -{ - DECLARE_DYNAMIC_CLASS(wxXBMFileHandler) -public: - inline wxXBMFileHandler() - { - m_name = "XBM file"; - m_extension = "xbm"; - m_type = wxBITMAP_TYPE_XBM; - }; - - virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, - int desiredWidth, int desiredHeight); -}; -IMPLEMENT_DYNAMIC_CLASS(wxXBMFileHandler, wxBitmapHandler) - -bool wxXBMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long WXUNUSED(flags), - int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight)) -{ - M_BITMAPHANDLERDATA->m_freePixmap = TRUE; - - int hotX, hotY; - unsigned int w, h; - Pixmap pixmap; - - Display *dpy = (Display*) wxGetDisplay(); - M_BITMAPDATA->m_display = (WXDisplay*) dpy; - - 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; - - if ((value == BitmapFileInvalid) || - (value == BitmapOpenFailed) || - (value == BitmapNoMemory)) - { - M_BITMAPHANDLERDATA->m_ok = FALSE; - M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) 0; - } - else - M_BITMAPHANDLERDATA->m_ok = TRUE; - - return M_BITMAPHANDLERDATA->m_ok ; -} - -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; - }; - - virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1); -}; -IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler) - -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; - - Display *dpy = (Display*) wxGetDisplay(); - M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy; - - 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) ; - - return TRUE; -} - -void wxBitmap::CleanUpHandlers() -{ - wxNode *node = sm_handlers.First(); - while ( node ) - { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - wxNode *next = node->Next(); - delete handler; - delete node; - node = next; - } -} - -void wxBitmap::InitStandardHandlers() -{ - // Initialize all standard bitmap or derived class handlers here. - AddHandler(new wxXBMFileHandler); - AddHandler(new wxXBMDataHandler); - - // XPM will be handled by wxImage -} - -// Creates a bitmap with transparent areas drawn in -// the given colour. -wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour) -{ - 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 -//----------------------------------------------------------------------------- - -/* - -Date: Wed, 05 Jan 2000 11:45:40 +0100 -From: Frits Boel -To: julian.smart@ukonline.co.uk -Subject: Patch for Motif ConvertToBitmap - -Hi Julian, - -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! - -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. - -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? - -The code of the patch is attached, have a look on it, and maybe you will -ship it with the next release of wxMotif? - -Regards, - -Frits Boel -Software engineer at Hubrecht Laboratory, The Netherlands. - -*/ - -class wxSearchColor -{ -public: - wxSearchColor( void ); - wxSearchColor( int size, XColor *colors ); - ~wxSearchColor( void ); - - int SearchColor( int r, int g, int b ); -private: - int AddColor( unsigned int value, int pos ); - - int size; - XColor *colors; - unsigned int *color; - int *entry; - - int bottom; - int top; -}; - -wxSearchColor::wxSearchColor( void ) -{ - size = 0; - colors = (XColor*) NULL; - color = (unsigned int *) NULL; - entry = (int*) NULL; - - bottom = 0; - top = 0; -} - -wxSearchColor::wxSearchColor( int size_, XColor *colors_ ) -{ - 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 ); -} - -wxSearchColor::~wxSearchColor( void ) -{ - if ( color ) delete color; - if ( entry ) delete entry; -} - -int wxSearchColor::SearchColor( int r, int g, int b ) -{ - unsigned int value = ( ( ( r * 256 ) + g ) * 256 ) + b; - int begin = bottom; - int end = top; - int middle = 0; - - while ( begin <= end ) { - - middle = ( begin + end ) >> 1; - - if ( value == color[middle] ) { - return( entry[middle] ); - } else if ( value < color[middle] ) { - end = middle - 1; - } else { - begin = middle + 1; - } - - } - - return AddColor( value, middle ); -} - -int wxSearchColor::AddColor( unsigned int value, int pos ) -{ - 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 ) -{ - wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") ) - wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") ) - - m_refData = new wxBitmapRefData(); - - int width = image.GetWidth(); - int height = image.GetHeight(); - - SetHeight( height ); - SetWidth( width ); - - Display *dpy = (Display*) wxGetDisplay(); - Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) ); - int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) ); - - // Create image - - 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 ); - - Create( width, height, bpp ); - - // Create mask - - 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 ); - } - - // Retrieve depth info - - XVisualInfo vinfo_template; - XVisualInfo *vi; - - vinfo_template.visual = vis; - vinfo_template.visualid = XVisualIDFromVisual( vis ); - vinfo_template.depth = bpp; - int nitem = 0; - - vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem ); - - wxCHECK_MSG( vi, FALSE, wxT("no visual") ); - - XFree( vi ); - - if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15; - if (bpp < 8) bpp = 8; - - // Render - - enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR }; - byte_order b_o = RGB; - - if (bpp >= 24) - { - 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; - } - - int r_mask = image.GetMaskRed(); - int g_mask = image.GetMaskGreen(); - int b_mask = image.GetMaskBlue(); - - XColor colors[256]; - if (bpp == 8) - { - Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy ); - - for (int i = 0; i < 256; i++) colors[i].pixel = i; - XQueryColors( dpy, cmap, colors, 256 ); - } - - wxSearchColor scolor( 256, colors ); - unsigned char* data = image.GetData(); - - bool hasMask = image.HasMask(); - - 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 ); - } - - 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 - - // 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 - - // Blit picture - - 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 ); - - XDestroyImage( data_image ); - XFreeGC( dpy, gc ); - - // Blit mask - if (image.HasMask()) - { - wxBitmap maskBitmap(width, height, 1); - - GC gcMask = XCreateGC( dpy, (Pixmap) maskBitmap.GetPixmap(), 0, (XGCValues*)NULL ); - XPutImage( dpy, (Drawable)maskBitmap.GetPixmap(), gcMask, mask_image, 0, 0, 0, 0, width, height ); - - XDestroyImage( mask_image ); - XFreeGC( dpy, gcMask ); - - wxMask* mask = new wxMask; - mask->SetPixmap(maskBitmap.GetPixmap()); - - SetMask(mask); - - maskBitmap.SetPixmapNull(); - } - - - return TRUE; -} - -wxImage wxBitmap::ConvertToImage() 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) + wxFAIL_MSG( "wxBitmap::GetSubBitmap not yet implemented" ); + +#if 0 + if (ret.GetPixmap()) { - XDestroyImage( ximage ); - wxFAIL_MSG( wxT("couldn't create image") ); - return wxNullImage; + 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 ); } - /* - GdkImage *gdk_image_mask = (GdkImage*) NULL; if (GetMask()) { - gdk_image_mask = gdk_image_get( GetMask()->GetBitmap(), - 0, 0, - GetWidth(), GetHeight() ); + wxMask *mask = new wxMask; + mask->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, rect.width, rect.height, 1 ); - image.SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable - } - */ + 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 ); - // Retrieve depth info - - XVisualInfo vinfo_template; - XVisualInfo *vi; - - vinfo_template.visual = vis; - vinfo_template.visualid = XVisualIDFromVisual( vis ); - vinfo_template.depth = bpp; - int nitem = 0; - - vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem ); - - wxCHECK_MSG( vi, wxNullImage, wxT("no visual") ); - - if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15; - - XFree( vi ); - - XColor colors[256]; - if (bpp == 8) - { - Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy ); - - for (int i = 0; i < 256; i++) colors[i].pixel = i; - XQueryColors( dpy, cmap, colors, 256 ); + ret.SetMask( mask ); } +#endif - 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; - } - - /* - 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; - } - } - */ - - pos += 3; - } - } - - XDestroyImage( ximage ); - /* - if (gdk_image_mask) gdk_image_destroy( gdk_image_mask ); - */ - - return image; + return ret; } -bool wxBitmap::CopyFromIcon(const wxIcon& icon) +bool wxBitmap::SaveFile( const wxString &name, int type, wxPalette *WXUNUSED(palette) ) { - wxBitmap* bitmap = (wxBitmap*) & icon; + wxCHECK_MSG( Ok(), FALSE, wxT("invalid bitmap") ); - *this = *bitmap; + // Try to save the bitmap via wxImage handlers: + { + wxImage image( *this ); + if (image.Ok()) return image.SaveFile( name, type ); + } + + return FALSE; +} + +bool wxBitmap::LoadFile( const wxString &name, int type ) +{ + UnRef(); + + if (!wxFileExists(name)) return FALSE; + + + if (type == wxBITMAP_TYPE_XPM) + { + 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 = 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; + + M_BMPDATA->m_bpp = bpp; // mono as well? + + 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; } + +wxPalette *wxBitmap::GetPalette() const +{ + if (!Ok()) return (wxPalette *) NULL; + + return M_BMPDATA->m_palette; +} + +void wxBitmap::SetHeight( int height ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); + + M_BMPDATA->m_height = height; +} + +void wxBitmap::SetWidth( int width ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); + + M_BMPDATA->m_width = width; +} + +void wxBitmap::SetDepth( int depth ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); + + M_BMPDATA->m_bpp = depth; +} + +void wxBitmap::SetPixmap( WXPixmap pixmap ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); + + M_BMPDATA->m_pixmap = pixmap; +} + +void wxBitmap::SetBitmap( WXPixmap bitmap ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); + + M_BMPDATA->m_bitmap = bitmap; +} + +WXPixmap wxBitmap::GetPixmap() const +{ + wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") ); + + return M_BMPDATA->m_pixmap; +} + +WXPixmap wxBitmap::GetBitmap() const +{ + wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") ); + + return M_BMPDATA->m_bitmap; +} + +WXDisplay *wxBitmap::GetDisplay() const +{ + wxCHECK_MSG( Ok(), (WXDisplay*) NULL, wxT("invalid bitmap") ); + + return M_BMPDATA->m_display; +} + diff --git a/src/x11/cursor.cpp b/src/x11/cursor.cpp index 10f452ceb6..55847bb23e 100644 --- a/src/x11/cursor.cpp +++ b/src/x11/cursor.cpp @@ -19,422 +19,204 @@ #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 -#include -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() { - m_width = 32; m_height = 32; - m_cursorId = wxCURSOR_NONE; + m_cursor = NULL; + m_display = NULL; } 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(const char bits[], int width, int height, - int hotSpotX, int hotSpotY, const char maskBits[]) +wxCursor::wxCursor( int cursorId ) { - m_refData = new wxCursorRefData; + m_refData = new wxCursorRefData(); - Display *dpy = (Display*) wxGetDisplay(); - int screen_num = DefaultScreen (dpy); - - 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 ); - } - - 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; - } - else - { - M_CURSORDATA->m_ok = TRUE; - } + M_CURSORDATA->m_cursor = (WXCursor) XCreateFontCursor( (Display*) M_CURSORDATA->m_display, x_cur ); } -wxCursor::wxCursor(const wxString& name, long flags, int hotSpotX, int hotSpotY) +wxCursor::wxCursor(const char bits[], int width, int height, + int hotSpotX, int hotSpotY, + const char maskBits[], wxColour *fg, wxColour *bg) { - // Must be an XBM file - if (flags != wxBITMAP_TYPE_XBM) - return; - - m_refData = new wxCursorRefData; - - int hotX = -1, hotY = -1; - unsigned int w, h; - Pixmap pixmap; - - Display *dpy = (Display*) wxGetDisplay(); - int screen_num = DefaultScreen (dpy); - - int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)), - (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY); - - M_BITMAPDATA->m_width = w; - M_BITMAPDATA->m_height = h; - M_BITMAPDATA->m_depth = 1; - - 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; - } - } - + wxFAIL_MSG( "wxCursor creation from bits not yet implemented" ); } -// Cursors by stock number -wxCursor::wxCursor(wxStockCursor id) + +wxCursor::wxCursor( const wxCursor &cursor ) { - m_refData = new wxCursorRefData; - M_CURSORDATA->m_cursorId = id; - M_CURSORDATA->m_ok = TRUE; - - WXDisplay* display = wxGetDisplay(); - if (!display) - return; - - 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; - } + Ref( cursor ); } +#if wxUSE_IMAGE +wxCursor::wxCursor( const wxImage & image ) +{ + wxFAIL_MSG( "wxCursor creation from wxImage not yet implemented" ); +} +#endif + wxCursor::~wxCursor() { } -// Motif-specific: create/get a cursor for the current display -WXCursor wxCursor::GetXCursor(WXDisplay* display) +wxCursor& wxCursor::operator = ( const wxCursor& cursor ) { - 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(); - } + if (*this == cursor) + return (*this); - // No cursor for this display, so let's see if we're an id-type cursor. + Ref( cursor ); - 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; - } - - // Not an id-type cursor, so we don't know how to create it. - return (WXCursor) 0; + return *this; } -// Make a cursor from standard id -WXCursor wxCursor::MakeCursor(WXDisplay* display, wxStockCursor id) +bool wxCursor::operator == ( const wxCursor& cursor ) const { - Display* dpy = (Display*) display; - Cursor cursor = (Cursor) 0; - - 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; + return m_refData == cursor.m_refData; } -// Global cursor setting -void wxSetCursor(const wxCursor& WXUNUSED(cursor)) +bool wxCursor::operator != ( const wxCursor& cursor ) const { - // Nothing to do for Motif (no global cursor) + return m_refData != cursor.m_refData; } +bool wxCursor::Ok() const +{ + return (m_refData != NULL); +} +WXCursor wxCursor::GetCursor() const +{ + return M_CURSORDATA->m_cursor; +} + +//----------------------------------------------------------------------------- +// busy cursor routines +//----------------------------------------------------------------------------- + +/* extern */ wxCursor g_globalCursor; + +static wxCursor gs_savedCursor; +static int gs_busyCount = 0; + +const wxCursor &wxBusyCursor::GetStoredCursor() +{ + return gs_savedCursor; +} + +const wxCursor wxBusyCursor::GetBusyCursor() +{ + return wxCursor(wxCURSOR_WATCH); +} + +void wxEndBusyCursor() +{ + if (--gs_busyCount > 0) + return; + + wxSetCursor( gs_savedCursor ); + gs_savedCursor = wxNullCursor; + + if (wxTheApp) + wxTheApp->SendIdleEvents(); +} + +void wxBeginBusyCursor( wxCursor *WXUNUSED(cursor) ) +{ + if (gs_busyCount++ > 0) + return; + + 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(); +} + +bool wxIsBusy() +{ + 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 509325d628..c00bb29e35 100644 --- 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") ); -#if 0 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 ); +#if 0 if (is_mono) use_bitmap = image.ConvertToMonoBitmap(255,255,255); else +#endif use_bitmap = image.ConvertToBitmap(); } else @@ -892,12 +893,13 @@ void wxWindowDC::DoDrawBitmap( const wxBitmap &bitmap, } /* apply mask if any */ - GdkBitmap *mask = (GdkBitmap *) NULL; + WXPixmap mask = NULL; if (use_bitmap.GetMask()) mask = use_bitmap.GetMask()->GetBitmap(); - + { if (useMask && mask) { - GdkBitmap *new_mask = (GdkBitmap*) NULL; + WXPixmap new_mask = NULL; +#if 0 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 ); } - +#endif 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 - 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) - gdk_gc_set_clip_mask( m_penGC, new_mask ); + XSetClipMask( (Display*) m_display, (GC) m_penGC, (Pixmap) new_mask ); 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) - 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) - 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 - 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) { - 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()) - gdk_gc_set_clip_region( m_textGC, m_currentClippingRegion.GetRegion() ); + XSetRegion( (Display*) m_display, (GC) m_textGC, (Region) m_currentClippingRegion.GetX11Region() ); } 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()) - 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, @@ -996,7 +1001,7 @@ bool wxWindowDC::DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord he { xsrcMask = xsrc; ysrcMask = ysrc; } - + #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); - 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; @@ -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, - (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 @@ -1930,6 +1927,13 @@ wxClientDC::wxClientDC( wxWindow *win ) : 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 diff --git a/src/x11/icon.cpp b/src/x11/icon.cpp index e357f22925..e563e7b548 100644 --- a/src/x11/icon.cpp +++ b/src/x11/icon.cpp @@ -16,72 +16,42 @@ #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" -IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap) +//----------------------------------------------------------------------------- +// wxIcon +//----------------------------------------------------------------------------- -/* -* Icons -*/ +IMPLEMENT_DYNAMIC_CLASS(wxIcon,wxBitmap) -wxIcon::wxIcon() +wxIcon::wxIcon( const char **bits, int WXUNUSED(width), int WXUNUSED(height) ) : + wxBitmap( bits ) { } -// Create from XBM data -wxIcon::wxIcon(const char bits[], int width, int height) -{ - (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, 1); -} - -// Create from XPM data -wxIcon::wxIcon(char **data) -{ - (void) Create((void*) data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); -} - -wxIcon::wxIcon(const char **data) -{ - (void) Create((void*) data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); -} - -wxIcon::wxIcon(const wxString& icon_file, long flags, - int desiredWidth, int desiredHeight) - -{ - LoadFile(icon_file, flags, desiredWidth, desiredHeight); -} - -wxIcon::~wxIcon() +wxIcon::wxIcon( char **bits, int WXUNUSED(width), int WXUNUSED(height) ) : + wxBitmap( bits ) { } -bool wxIcon::LoadFile(const wxString& filename, long type, - int desiredWidth, int desiredHeight) +wxIcon::wxIcon() : wxBitmap() { - UnRef(); - - m_refData = new wxBitmapRefData; - - wxBitmapHandler *handler = FindHandler(type); - - if ( handler ) - return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight); - else - return FALSE; } -bool wxIcon::CopyFromBitmap(const wxBitmap& bitmap) +wxIcon::wxIcon( const wxIcon& icon ) : wxBitmap() { - wxIcon* icon = (wxIcon*) (& bitmap); + Ref(icon); +} + +wxIcon& wxIcon::operator = ( const wxIcon& icon ) +{ + if (*this == icon) return (*this); + Ref(icon); + return *this; +} + +void wxIcon::CopyFromBitmap(const wxBitmap& bmp) +{ + wxIcon *icon = (wxIcon*)(&bmp); *this = *icon; - return TRUE; } diff --git a/src/x11/toplevel.cpp b/src/x11/toplevel.cpp index 648bb6ac3a..a357025c69 100644 --- 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; - wmHints->icon_mask = (Pixmap) icon.GetMask()->GetPixmap(); + wmHints->icon_mask = (Pixmap) icon.GetMask()->GetBitmap(); } XSetWMHints(wxGlobalDisplay(), (Window) GetMainWindow(), wmHints); diff --git a/src/x11/utils.cpp b/src/x11/utils.cpp index eef7ceb4ec..b27a3f9428 100644 --- 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 -// ---------------------------------------------------------------------------- -// 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 // ---------------------------------------------------------------------------- @@ -682,10 +603,8 @@ WXDisplay *wxGetDisplay() { if (gs_currentDisplay) return gs_currentDisplay; - else if (wxTheApp) - return wxTheApp->GetInitialDisplay(); else - return (WXDisplay*) NULL; + return wxApp::GetDisplay(); } bool wxSetDisplay(const wxString& display_name) diff --git a/src/x11/window.cpp b/src/x11/window.cpp index 72833485e9..1983d4bb41 100644 --- a/src/x11/window.cpp +++ b/src/x11/window.cpp @@ -430,11 +430,10 @@ bool wxWindowX11::SetCursor(const wxCursor& cursor) else cursor2 = wxSTANDARD_CURSOR; - WXDisplay *dpy = GetXDisplay(); - WXCursor x_cursor = cursor2->GetXCursor(dpy); + WXCursor x_cursor = cursor2->GetCursor(); Window win = (Window) GetMainWindow(); - XDefineCursor((Display*) dpy, win, (Cursor) x_cursor); + XDefineCursor((Display*) wxGlobalDisplay(), win, (Cursor) x_cursor); return TRUE; }