From: Robert Roebling Date: Wed, 13 Feb 2002 08:38:54 +0000 (+0000) Subject: wxX11: X-Git-Url: https://git.saurik.com/wxWidgets.git/commitdiff_plain/a11672a469f036436838911c268cb2f8d5da5bf8 wxX11: Lots of wxBitmap et al work. Adapted wxIcon, wxCursor to this. Split wxApp init things up so that the X11 display is available sooner. Changed initial display code accordingly. Corrected wxDC::DrawBitmap. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@14170 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- diff --git a/include/wx/x11/app.h b/include/wx/x11/app.h index 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" + +//----------------------------------------------------------------------------- +// classes +//----------------------------------------------------------------------------- + +class wxMask; +class wxBitmap; +class wxImage; -// Bitmap -class WXDLLEXPORT wxDC; -class WXDLLEXPORT wxControl; -class WXDLLEXPORT wxBitmap; -class WXDLLEXPORT wxBitmapHandler; -class WXDLLEXPORT wxIcon; -class WXDLLEXPORT wxCursor; -class WXDLLEXPORT wxImage; - -// A mask is a mono bitmap used for drawing bitmaps -// transparently. -class WXDLLEXPORT wxMask: public wxObject +//----------------------------------------------------------------------------- +// wxMask +//----------------------------------------------------------------------------- + +class wxMask: public wxObject { - DECLARE_DYNAMIC_CLASS(wxMask) - public: wxMask(); - - // 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); - - WXPixmap GetPixmap() const { return m_pixmap; } - void SetPixmap(WXPixmap pixmap) { m_pixmap = pixmap; } - -protected: - WXPixmap m_pixmap; -}; + + bool Create( const wxBitmap& bitmap, const wxColour& colour ); + bool Create( const wxBitmap& bitmap, int paletteIndex ); + bool Create( const wxBitmap& bitmap ); -class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData -{ - friend class WXDLLEXPORT wxBitmap; - friend class WXDLLEXPORT wxIcon; - friend class WXDLLEXPORT wxCursor; -public: - wxBitmapRefData(); - ~wxBitmapRefData(); - -public: - int m_width; - int m_height; - int m_depth; - bool m_ok; - int m_numColors; - wxPalette m_bitmapPalette; - int m_quality; - - wxMask * m_bitmapMask; // Optional mask - - // Motif implementation -public: - WXPixmap m_pixmap; - WXDisplay* m_display; - bool m_freePixmap; - unsigned long* m_freeColors; - long m_freeColorsCount; + // implementation + WXPixmap GetBitmap() const { return m_bitmap; } + void SetBitmap( WXPixmap bitmap ) { m_bitmap = bitmap; } + + WXDisplay *GetDisplay() const { return m_display; } + void SetDisplay( WXDisplay *display ) { m_display = display; } + +private: + WXPixmap m_bitmap; + WXDisplay *m_display; + +private: + DECLARE_DYNAMIC_CLASS(wxMask) }; -#define M_BITMAPDATA ((wxBitmapRefData *)m_refData) +//----------------------------------------------------------------------------- +// wxBitmap +//----------------------------------------------------------------------------- -class WXDLLEXPORT wxBitmapHandler: public wxObject +class wxBitmap: public wxGDIObject { - DECLARE_DYNAMIC_CLASS(wxBitmapHandler) public: - wxBitmapHandler() { m_name = ""; m_extension = ""; m_type = 0; }; + wxBitmap(); + wxBitmap( int width, int height, int depth = -1 ); + wxBitmap( const char bits[], int width, int height, int depth = 1 ); + wxBitmap( const char **bits ) { (void)CreateFromXpm(bits); } + wxBitmap( char **bits ) { (void)CreateFromXpm((const char **)bits); } + wxBitmap( const wxBitmap& bmp ); + wxBitmap( const wxString &filename, int type = wxBITMAP_TYPE_XPM ); + wxBitmap( const wxImage& image, int depth = -1 ) { (void)CreateFromImage(image, depth); } + ~wxBitmap(); + wxBitmap& operator = ( const wxBitmap& bmp ); + bool operator == ( const wxBitmap& bmp ) const; + bool operator != ( const wxBitmap& bmp ) const; + bool Ok() const; + + bool Create(int width, int height, int depth = -1); - virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1); - virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, - int desiredWidth, int desiredHeight); - virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL); + int GetHeight() const; + int GetWidth() const; + int GetDepth() const; - void SetName(const wxString& name) { m_name = name; } - void SetExtension(const wxString& ext) { m_extension = ext; } - void SetType(long type) { m_type = type; } - wxString GetName() const { return m_name; } - wxString GetExtension() const { return m_extension; } - long GetType() const { return m_type; } -protected: - wxString m_name; - wxString m_extension; - long m_type; -}; + wxImage ConvertToImage() const; -#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData()) + // copies the contents and mask of the given (colour) icon to the bitmap + virtual bool CopyFromIcon(const wxIcon& icon); -class WXDLLEXPORT wxBitmap: public wxGDIObject -{ - DECLARE_DYNAMIC_CLASS(wxBitmap) - - friend class WXDLLEXPORT wxBitmapHandler; - -public: - wxBitmap(); // Platform-specific - - // Copy constructors - wxBitmap(const wxBitmap& bitmap) - { Ref(bitmap); } - - // Initialize with raw XBM data - wxBitmap(const char bits[], int width, int height, int depth = 1); - - // from XPM - wxBitmap(const char **data) { (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); } - wxBitmap(char **data) { (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); } - - // Load a file or resource - wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_XPM); - - // Constructor for generalised creation from data - wxBitmap(void *data, long type, int width, int height, int depth = 1); - - // If depth is omitted, will create a bitmap compatible with the display - wxBitmap(int width, int height, int depth = -1); - - // Convert from wxImage: - wxBitmap(const wxImage& image, int depth = -1) { (void)CreateFromImage(image, depth); } - - ~wxBitmap(); - - virtual bool Create(int width, int height, int depth = -1); - virtual bool Create(void *data, long type, int width, int height, int depth = 1); + wxMask *GetMask() const; + void SetMask( wxMask *mask ); wxBitmap GetSubBitmap( const wxRect& rect ) const; - - virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_XPM); - virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL); - - wxImage ConvertToImage() const; - bool CopyFromIcon(const wxIcon& icon); - - bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); } - int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); } - int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); } - int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); } - int GetQuality() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); } - void SetWidth(int w); - void SetHeight(int h); - void SetDepth(int d); - void SetQuality(int q); - void SetOk(bool isOk); - - wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : (wxPalette*) NULL); } - void SetPalette(const wxPalette& palette); - - wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) NULL); } - void SetMask(wxMask *mask) ; - - wxBitmap& operator = (const wxBitmap& bitmap) { if (*this == bitmap) return (*this); Ref(bitmap); return *this; } - bool operator == (const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; } - bool operator != (const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; } - - // Format handling - static wxList& GetHandlers() { return sm_handlers; } - static void AddHandler(wxBitmapHandler *handler); - static void InsertHandler(wxBitmapHandler *handler); - static bool RemoveHandler(const wxString& name); - static wxBitmapHandler *FindHandler(const wxString& name); - static wxBitmapHandler *FindHandler(const wxString& extension, long bitmapType); - static wxBitmapHandler *FindHandler(long bitmapType); - - static void InitStandardHandlers(); - static void CleanUpHandlers(); - - // Motif implementation -public: - WXDisplay* GetDisplay() const { return M_BITMAPDATA->m_display; } - WXPixmap GetPixmap() const { return (WXPixmap) M_BITMAPDATA->m_pixmap; } - void SetPixmapNull() { M_BITMAPDATA->m_pixmap = 0; } + bool SaveFile( const wxString &name, int type, wxPalette *palette = (wxPalette *) NULL ); + bool LoadFile( const wxString &name, int type = wxBITMAP_TYPE_XPM ); + + wxPalette *GetPalette() const; + wxPalette *GetColourMap() const + { return GetPalette(); }; + + // implementation + // -------------- + + void SetHeight( int height ); + void SetWidth( int width ); + void SetDepth( int depth ); + void SetPixmap( WXPixmap pixmap ); + void SetBitmap( WXPixmap bitmap ); + + WXPixmap GetPixmap() const; + WXPixmap GetBitmap() const; -protected: - static wxList sm_handlers; + WXDisplay *GetDisplay() const; protected: - bool CreateFromImage(const wxImage& image, int depth); -}; + bool CreateFromXpm(const char **bits); + bool CreateFromImage(const wxImage& image, int depth); -// Creates a bitmap with transparent areas drawn in -// the given colour. -wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour); +private: + DECLARE_DYNAMIC_CLASS(wxBitmap) +}; #endif // _WX_BITMAP_H_ 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; -}; - -class WXDLLEXPORT wxCursorRefData: public wxBitmapRefData -{ - friend class WXDLLEXPORT wxBitmap; - friend class WXDLLEXPORT wxCursor; -public: - wxCursorRefData(); - ~wxCursorRefData(); - - wxList m_cursors; // wxXCursor objects, one per display - wxStockCursor m_cursorId; // wxWindows standard cursor id -}; +#if wxUSE_IMAGE +#include "wx/image.h" +#endif -#define M_CURSORDATA ((wxCursorRefData *)m_refData) -#define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData) +//----------------------------------------------------------------------------- +// wxCursor +//----------------------------------------------------------------------------- -// Cursor -class WXDLLEXPORT wxCursor: public wxBitmap +class wxCursor: public wxObject { - DECLARE_DYNAMIC_CLASS(wxCursor) - public: + 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)); } - - bool CopyFromBitmap(const wxBitmap& bitmap); + wxIcon( const wxIcon& icon); + wxIcon( const char **bits, int width=-1, int height=-1 ); + + // For compatibility with wxMSW where desired size is sometimes required to + // distinguish between multiple icons in a resource. + wxIcon( const wxString& filename, int type = wxBITMAP_TYPE_XPM, + int WXUNUSED(desiredWidth)=-1, int WXUNUSED(desiredHeight)=-1 ) : + wxBitmap(filename, type) + { + } + wxIcon( char **bits, int width=-1, int height=-1 ); + + wxIcon& operator = (const wxIcon& icon); + inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; } + inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; } + + // create from bitmap (which should have a mask unless it's monochrome): + // there shouldn't be any implicit bitmap -> icon conversion (i.e. no + // ctors, assignment operators...), but it's ok to have such function + void CopyFromBitmap(const wxBitmap& bmp); + +private: + DECLARE_DYNAMIC_CLASS(wxIcon) }; + #endif // _WX_ICON_H_ 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,1017 +26,1065 @@ #endif #include +//----------------------------------------------------------------------------- +// wxMask +//----------------------------------------------------------------------------- -IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) -IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) - -wxBitmapRefData::wxBitmapRefData() -{ - m_ok = FALSE; - m_width = 0; - m_height = 0; - m_depth = 0; - m_quality = 0; - m_numColors = 0; - m_bitmapMask = NULL; - - m_pixmap = (WXPixmap) 0; - m_display = (WXDisplay*) 0; - - m_freePixmap = TRUE; //TODO: necessary? - m_freeColors = (unsigned long*) 0; - m_freeColorsCount = 0; -} - -wxBitmapRefData::~wxBitmapRefData() -{ - if (m_pixmap && m_freePixmap) - XFreePixmap ((Display*) m_display, (Pixmap) m_pixmap); - - if (m_freeColors) - { - int screen = DefaultScreen((Display*) m_display); - Colormap cmp = DefaultColormap((Display*) m_display,screen); - long llp; - for(llp = 0;llp < m_freeColorsCount;llp++) - XFreeColors((Display*) m_display, cmp, &m_freeColors[llp], 1, 0L); - delete m_freeColors; - }; - - if (m_bitmapMask) - delete m_bitmapMask; - m_bitmapMask = NULL; -} - -wxList wxBitmap::sm_handlers; - -#define M_BMPDATA ((wxBitmapRefData *)m_refData) +IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject) -wxBitmap::wxBitmap() -{ - m_refData = NULL; -} - -wxBitmap::~wxBitmap() +wxMask::wxMask() { + m_bitmap = NULL; + m_display = NULL; } -wxBitmap::wxBitmap(const char bits[], int width, int height, int depth) +wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour ) { - m_refData = new wxBitmapRefData; - - (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth); + m_bitmap = NULL; + Create( bitmap, colour ); } -wxBitmap::wxBitmap(int w, int h, int d) +wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex ) { - (void)Create(w, h, d); + m_bitmap = NULL; + Create( bitmap, paletteIndex ); } -wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth) +wxMask::wxMask( const wxBitmap& bitmap ) { - (void) Create(data, type, width, height, depth); + m_bitmap = NULL; + Create( bitmap ); } -wxBitmap::wxBitmap(const wxString& filename, long type) +wxMask::~wxMask() { - LoadFile(filename, (int)type); + if (m_bitmap) + XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap ); } -bool wxBitmap::Create(int w, int h, int d) +bool wxMask::Create( const wxBitmap& bitmap, + const wxColour& colour ) { - UnRef(); + if (m_bitmap) + { + XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap ); + m_bitmap = NULL; + } - m_refData = new wxBitmapRefData; + m_display = bitmap.GetDisplay(); - if (d < 1) - d = wxDisplayDepth(); + wxImage image( bitmap ); + if (!image.Ok()) return FALSE; + + m_display = bitmap.GetDisplay(); + + Display *xdisplay = (Display*) m_display; - M_BITMAPDATA->m_width = w; - M_BITMAPDATA->m_height = h; - M_BITMAPDATA->m_depth = d; - M_BITMAPDATA->m_freePixmap = TRUE; + int xscreen = DefaultScreen( xdisplay ); + Window xroot = RootWindow( xdisplay, xscreen ); + Visual* xvisual = DefaultVisual( xdisplay, xscreen ); + int bpp = DefaultDepth( xdisplay, xscreen ); + + m_bitmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, image.GetWidth(), image.GetHeight(), 1 ); + GC gc = XCreateGC( xdisplay, (Pixmap) m_bitmap, 0, NULL ); - Display *dpy = (Display*) wxGetDisplay(); + XSetForeground( xdisplay, gc, WhitePixel(xdisplay,xscreen) ); + XSetFillStyle( xdisplay, gc, FillSolid ); + XFillRectangle( xdisplay, (Pixmap) m_bitmap, gc, 0, 0, image.GetWidth(), image.GetHeight() ); - M_BITMAPDATA->m_display = dpy; /* MATTHEW: [4] Remember the display */ + unsigned char *data = image.GetData(); + int index = 0; - M_BITMAPDATA->m_pixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)), - w, h, d); + unsigned char red = colour.Red(); + unsigned char green = colour.Green(); + unsigned char blue = colour.Blue(); - M_BITMAPDATA->m_ok = (M_BITMAPDATA->m_pixmap != (WXPixmap) 0) ; - return M_BITMAPDATA->m_ok; -} + XVisualInfo vinfo_template; + XVisualInfo *vi; -bool wxBitmap::LoadFile(const wxString& filename, long type) -{ - UnRef(); + vinfo_template.visual = xvisual; + vinfo_template.visualid = XVisualIDFromVisual( xvisual ); + vinfo_template.depth = bpp; + int nitem = 0; - m_refData = new wxBitmapRefData; + vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem ); + wxASSERT_MSG( vi, wxT("No visual info") ); + + if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15; + if (bpp == 15) + { + red = red & 0xf8; + green = green & 0xf8; + blue = blue & 0xf8; + } else + if (bpp == 16) + { + red = red & 0xf8; + green = green & 0xfc; + blue = blue & 0xf8; + } else + if (bpp == 12) + { + red = red & 0xf0; + green = green & 0xf0; + blue = blue & 0xf0; + } - wxBitmapHandler *handler = FindHandler(type); + XSetForeground( xdisplay, gc, BlackPixel(xdisplay,xscreen) ); - if ( handler == NULL ) { - wxImage image; - if (!image.LoadFile( filename, type )) return FALSE; - if (image.Ok()) + for (int j = 0; j < image.GetHeight(); j++) + { + int start_x = -1; + int i; + for (i = 0; i < image.GetWidth(); i++) { - *this = image.ConvertToBitmap(); - return TRUE; + if ((data[index] == red) && + (data[index+1] == green) && + (data[index+2] == blue)) + { + if (start_x == -1) + start_x = i; + } + else + { + if (start_x != -1) + { + XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i-1, j ); + start_x = -1; + } + } + index += 3; } - else return FALSE; + if (start_x != -1) + XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i, j ); } + + XFreeGC( xdisplay, gc ); - return handler->LoadFile(this, filename, type, -1, -1); + return TRUE; } -bool wxBitmap::Create(void *data, long type, int width, int height, int depth) +bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex ) { - UnRef(); - - m_refData = new wxBitmapRefData; + unsigned char r,g,b; + wxPalette *pal = bitmap.GetPalette(); - wxBitmapHandler *handler = FindHandler(type); + wxCHECK_MSG( pal, FALSE, wxT("Cannot create mask from bitmap without palette") ); - if ( handler == NULL ) { - wxLogWarning("no data bitmap handler for type %d defined.", type); - - return FALSE; - } + pal->GetRGB(paletteIndex, &r, &g, &b); - return handler->Create(this, data, type, width, height, depth); + return Create(bitmap, wxColour(r, g, b)); } -bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette) +bool wxMask::Create( const wxBitmap& bitmap ) { - wxBitmapHandler *handler = FindHandler(type); - - if ( handler == NULL ) { // try wxImage - wxImage image( *this ); - if (image.Ok()) return image.SaveFile( filename, type ); - else return FALSE; + if (m_bitmap) + { + XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap ); + m_bitmap = NULL; } - return handler->SaveFile(this, filename, type, palette); -} - -void wxBitmap::SetWidth(int w) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; + if (!bitmap.Ok()) return FALSE; - M_BITMAPDATA->m_width = w; -} + wxCHECK_MSG( bitmap.GetBitmap(), FALSE, wxT("Cannot create mask from colour bitmap") ); + + m_display = bitmap.GetDisplay(); -void wxBitmap::SetHeight(int h) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; + int xscreen = DefaultScreen( (Display*) m_display ); + Window xroot = RootWindow( (Display*) m_display, xscreen ); + + m_bitmap = (WXPixmap) XCreatePixmap( (Display*) m_display, xroot, bitmap.GetWidth(), bitmap.GetHeight(), 1 ); - M_BITMAPDATA->m_height = h; -} + if (!m_bitmap) return FALSE; + + GC gc = XCreateGC( (Display*) m_display, (Pixmap) m_bitmap, 0, NULL ); -void wxBitmap::SetDepth(int d) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; + XCopyPlane( (Display*) m_display, (Pixmap) bitmap.GetBitmap(), (Pixmap) m_bitmap, + gc, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), 0, 0, 1 ); + + XFreeGC( (Display*) m_display, gc ); - M_BITMAPDATA->m_depth = d; + return TRUE; } -void wxBitmap::SetQuality(int q) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_quality = q; -} +//----------------------------------------------------------------------------- +// wxBitmap +//----------------------------------------------------------------------------- -void wxBitmap::SetOk(bool isOk) +class wxBitmapRefData: public wxObjectRefData { - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_ok = isOk; -} +public: + wxBitmapRefData(); + ~wxBitmapRefData(); + + WXPixmap m_pixmap; + WXPixmap m_bitmap; + WXDisplay *m_display; + wxMask *m_mask; + int m_width; + int m_height; + int m_bpp; + wxPalette *m_palette; +}; -void wxBitmap::SetPalette(const wxPalette& palette) +wxBitmapRefData::wxBitmapRefData() { - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_bitmapPalette = palette ; + m_pixmap = NULL; + m_bitmap = NULL; + m_display = NULL; + m_mask = (wxMask *) NULL; + m_width = 0; + m_height = 0; + m_bpp = 0; + m_palette = (wxPalette *) NULL; } -void wxBitmap::SetMask(wxMask *mask) +wxBitmapRefData::~wxBitmapRefData() { - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_bitmapMask = mask ; + if (m_pixmap) XFreePixmap( (Display*) m_display, (Pixmap) m_pixmap ); + if (m_bitmap) XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap ); + if (m_mask) delete m_mask; + if (m_palette) delete m_palette; } -wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const -{ - wxCHECK_MSG( Ok() && - (rect.x >= 0) && (rect.y >= 0) && - (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height), - wxNullBitmap, wxT("invalid bitmap or bitmap region") ); +//----------------------------------------------------------------------------- - wxBitmap ret( rect.width, rect.height, 0 ); - wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") ); +#define M_BMPDATA ((wxBitmapRefData *)m_refData) - // The remaining still TODO - return ret; -} +IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject) -void wxBitmap::AddHandler(wxBitmapHandler *handler) +wxBitmap::wxBitmap() { - sm_handlers.Append(handler); } -void wxBitmap::InsertHandler(wxBitmapHandler *handler) +wxBitmap::wxBitmap( int width, int height, int depth ) { - sm_handlers.Insert(handler); + Create( width, height, depth ); } -bool wxBitmap::RemoveHandler(const wxString& name) +bool wxBitmap::Create( int width, int height, int depth ) { - wxBitmapHandler *handler = FindHandler(name); - if ( handler ) + UnRef(); + + wxCHECK_MSG( (width > 0) && (height > 0), FALSE, wxT("invalid bitmap size") ) + + m_refData = new wxBitmapRefData(); + + M_BMPDATA->m_display = wxGlobalDisplay(); + + wxASSERT_MSG( M_BMPDATA->m_display, wxT("No display") ); + + int xscreen = DefaultScreen( (Display*) M_BMPDATA->m_display ); + Window xroot = RootWindow( (Display*) M_BMPDATA->m_display, xscreen ); + + int bpp = DefaultDepth( (Display*) M_BMPDATA->m_display, xscreen ); + if (depth == -1) depth = bpp; + + wxCHECK_MSG( (depth == bpp) || + (depth == 1), FALSE, wxT("invalid bitmap depth") ) + + M_BMPDATA->m_mask = (wxMask *) NULL; + M_BMPDATA->m_width = width; + M_BMPDATA->m_height = height; + if (depth == 1) { - sm_handlers.DeleteObject(handler); - return TRUE; + M_BMPDATA->m_bitmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, 1 ); + + wxASSERT_MSG( M_BMPDATA->m_bitmap, wxT("Bitmap creation failed") ); + + M_BMPDATA->m_bpp = 1; } else - return FALSE; -} - -wxBitmapHandler *wxBitmap::FindHandler(const wxString& name) -{ - wxNode *node = sm_handlers.First(); - while ( node ) { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if ( handler->GetName() == name ) - return handler; - node = node->Next(); + M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, depth ); + + wxASSERT_MSG( M_BMPDATA->m_pixmap, wxT("Pixmap creation failed") ); + + M_BMPDATA->m_bpp = depth; } - return NULL; -} -wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType) -{ - wxNode *node = sm_handlers.First(); - while ( node ) - { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if ( handler->GetExtension() == extension && - (bitmapType == -1 || handler->GetType() == bitmapType) ) - return handler; - node = node->Next(); - } - return NULL; + return Ok(); } -wxBitmapHandler *wxBitmap::FindHandler(long bitmapType) +bool wxBitmap::CreateFromXpm( const char **bits ) { - wxNode *node = sm_handlers.First(); - while ( node ) + UnRef(); + + wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") ) + + m_refData = new wxBitmapRefData(); + + M_BMPDATA->m_display = wxGlobalDisplay(); + + Display *xdisplay = (Display*) M_BMPDATA->m_display; + + int xscreen = DefaultScreen( xdisplay ); + Window xroot = RootWindow( xdisplay, xscreen ); + + int bpp = DefaultDepth( xdisplay, xscreen ); + + XpmAttributes xpmAttr; + xpmAttr.valuemask = XpmReturnInfos; // nothing yet, but get infos back + + Pixmap pixmap; + Pixmap mask = 0; + + int ErrorStatus = XpmCreatePixmapFromData( xdisplay, xroot, (char**) bits, &pixmap, &mask, &xpmAttr ); + + if (ErrorStatus == XpmSuccess) { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if (handler->GetType() == bitmapType) - return handler; - node = node->Next(); - } - return NULL; -} + M_BMPDATA->m_width = xpmAttr.width; + M_BMPDATA->m_height = xpmAttr.height; -/* -* wxMask -*/ + M_BMPDATA->m_bpp = bpp; // mono as well? -wxMask::wxMask() -{ - m_pixmap = (WXPixmap) 0; -} +#if __WXDEBUG__ + unsigned int depthRet; + int xRet, yRet; + unsigned int widthRet, heightRet, borderWidthRet; + XGetGeometry( xdisplay, pixmap, &xroot, &xRet, &yRet, + &widthRet, &heightRet, &borderWidthRet, &depthRet); -// Construct a mask from a bitmap and a colour indicating -// the transparent area -wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour) -{ - m_pixmap = (WXPixmap) 0; + wxASSERT_MSG( bpp == (int)depthRet, wxT("colour depth mismatch") ) +#endif + + XpmFreeAttributes(&xpmAttr); + + M_BMPDATA->m_pixmap = (WXPixmap) pixmap; + + if (mask) + { + M_BMPDATA->m_mask = new wxMask; + M_BMPDATA->m_mask->SetBitmap( (WXPixmap) mask ); + M_BMPDATA->m_mask->SetDisplay( xdisplay ); + } + } + else + { + UnRef(); + + return FALSE; + } - Create(bitmap, colour); + return TRUE; } -// Construct a mask from a bitmap and a palette index indicating -// the transparent area -wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex) +bool wxBitmap::CreateFromImage( const wxImage& image, int depth ) { - m_pixmap = (WXPixmap) 0; + UnRef(); - Create(bitmap, paletteIndex); -} + wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") ) + wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") ) -// Construct a mask from a mono bitmap (copies the bitmap). -wxMask::wxMask(const wxBitmap& bitmap) -{ - m_pixmap = (WXPixmap) 0; + m_refData = new wxBitmapRefData(); - Create(bitmap); -} + M_BMPDATA->m_display = wxGlobalDisplay(); + + Display *xdisplay = (Display*) M_BMPDATA->m_display; + + int xscreen = DefaultScreen( xdisplay ); + Window xroot = RootWindow( xdisplay, xscreen ); + Visual* xvisual = DefaultVisual( xdisplay, xscreen ); + + int bpp = DefaultDepth( xdisplay, xscreen ); + + int width = image.GetWidth(); + int height = image.GetHeight(); + M_BMPDATA->m_width = width; + M_BMPDATA->m_height = height; -wxMask::~wxMask() -{ - // TODO: this may be the wrong display - if ( m_pixmap ) - XFreePixmap ((Display*) wxGetDisplay(), (Pixmap) m_pixmap); -} + if (depth != 1) depth = bpp; + M_BMPDATA->m_bpp = depth; + + if (depth == 1) + { + wxFAIL_MSG( "mono images later" ); + } + else + { + // Create image + + XImage *data_image = XCreateImage( xdisplay, xvisual, bpp, ZPixmap, 0, 0, width, height, 32, 0 ); + data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height ); + + if (data_image->data == NULL) + { + wxLogError( wxT("Out of memory.") ); // TODO clean + return FALSE; + } -// Create a mask from a mono bitmap (copies the bitmap). -bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap)) -{ - // TODO - return FALSE; -} + M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, depth ); -// Create a mask from a bitmap and a palette index indicating -// the transparent area -bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex)) -{ - // TODO - return FALSE; -} + // Create mask -// Create a mask from a bitmap and a colour indicating -// the transparent area -bool wxMask::Create(const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour)) -{ - // TODO - return FALSE; -} + XImage *mask_image = (XImage*) NULL; + if (image.HasMask()) + { + mask_image = XCreateImage( xdisplay, xvisual, 1, ZPixmap, 0, 0, width, height, 32, 0 ); + mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height ); + + if (mask_image->data == NULL) + { + wxLogError( wxT("Out of memory.") ); // TODO clean + return FALSE; + } + + wxMask *mask = new wxMask(); + mask->SetDisplay( xdisplay ); + mask->SetBitmap( (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, 1 ) ); -/* -* wxBitmapHandler -*/ + SetMask( mask ); + } -IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) + // Retrieve info -bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(type), - int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth)) -{ - return FALSE; -} + XVisualInfo vinfo_template; + XVisualInfo *vi; -bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), long WXUNUSED(type), - int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight)) -{ - return FALSE; -} + vinfo_template.visual = xvisual; + vinfo_template.visualid = XVisualIDFromVisual( xvisual ); + vinfo_template.depth = bpp; + int nitem = 0; -bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name), int WXUNUSED(type), - const wxPalette *WXUNUSED(palette)) -{ - return FALSE; -} + vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem ); + wxASSERT_MSG( vi, wxT("No visual info") ); -/* -* Standard handlers -*/ + if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15; + if (bpp < 8) bpp = 8; -class WXDLLEXPORT wxXBMFileHandler: public wxBitmapHandler -{ - DECLARE_DYNAMIC_CLASS(wxXBMFileHandler) -public: - inline wxXBMFileHandler() - { - m_name = "XBM file"; - m_extension = "xbm"; - m_type = wxBITMAP_TYPE_XBM; - }; + // Render - virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, - int desiredWidth, int desiredHeight); -}; -IMPLEMENT_DYNAMIC_CLASS(wxXBMFileHandler, wxBitmapHandler) + enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR }; + byte_order b_o = RGB; -bool wxXBMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long WXUNUSED(flags), - int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight)) -{ - M_BITMAPHANDLERDATA->m_freePixmap = TRUE; + if (bpp > 8) + { + if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask)) b_o = RGB; + else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask)) b_o = RBG; + else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask)) b_o = BRG; + else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR; + else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask)) b_o = GRB; + else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask)) b_o = GBR; + } - int hotX, hotY; - unsigned int w, h; - Pixmap pixmap; + XFree( vi ); - Display *dpy = (Display*) wxGetDisplay(); - M_BITMAPDATA->m_display = (WXDisplay*) dpy; + int r_mask = image.GetMaskRed(); + int g_mask = image.GetMaskGreen(); + int b_mask = image.GetMaskBlue(); - int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)), - (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY); - M_BITMAPHANDLERDATA->m_width = w; - M_BITMAPHANDLERDATA->m_height = h; - M_BITMAPHANDLERDATA->m_depth = 1; - M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) pixmap; + unsigned char* data = image.GetData(); + wxASSERT_MSG( data, "No image data" ); - if ((value == BitmapFileInvalid) || - (value == BitmapOpenFailed) || - (value == BitmapNoMemory)) - { - M_BITMAPHANDLERDATA->m_ok = FALSE; - M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) 0; - } - else - M_BITMAPHANDLERDATA->m_ok = TRUE; + bool hasMask = image.HasMask(); - return M_BITMAPHANDLERDATA->m_ok ; -} + int index = 0; + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + int r = data[index]; + index++; + int g = data[index]; + index++; + int b = data[index]; + index++; + + if (hasMask) + { + if ((r == r_mask) && (b == b_mask) && (g == g_mask)) + XPutPixel( mask_image, x, y, 0 ); + else + XPutPixel( mask_image, x, y, 1 ); + } -class WXDLLEXPORT wxXBMDataHandler: public wxBitmapHandler -{ - DECLARE_DYNAMIC_CLASS(wxXBMDataHandler) -public: - inline wxXBMDataHandler() - { - m_name = "XBM data"; - m_extension = "xbm"; - m_type = wxBITMAP_TYPE_XBM_DATA; - }; + switch (bpp) + { + case 8: + { + int pixel = 0; +#if 0 + if (wxTheApp->m_colorCube) + { + pixel = wxTheApp->m_colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ]; + } + else + { + GdkColormap *cmap = gtk_widget_get_default_colormap(); + GdkColor *colors = cmap->colors; + int max = 3 * (65536); + + for (int i = 0; i < cmap->size; i++) + { + int rdiff = (r << 8) - colors[i].red; + int gdiff = (g << 8) - colors[i].green; + int bdiff = (b << 8) - colors[i].blue; + int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff); + if (sum < max) { pixel = i; max = sum; } + } + } +#endif + XPutPixel( data_image, x, y, pixel ); + break; + } + case 12: // SGI only + { + int pixel = 0; + switch (b_o) + { + case RGB: pixel = ((r & 0xf0) << 4) | (g & 0xf0) | ((b & 0xf0) >> 4); break; + case RBG: pixel = ((r & 0xf0) << 4) | (b & 0xf0) | ((g & 0xf0) >> 4); break; + case GRB: pixel = ((g & 0xf0) << 4) | (r & 0xf0) | ((b & 0xf0) >> 4); break; + case GBR: pixel = ((g & 0xf0) << 4) | (b & 0xf0) | ((r & 0xf0) >> 4); break; + case BRG: pixel = ((b & 0xf0) << 4) | (r & 0xf0) | ((g & 0xf0) >> 4); break; + case BGR: pixel = ((b & 0xf0) << 4) | (g & 0xf0) | ((r & 0xf0) >> 4); break; + } + XPutPixel( data_image, x, y, pixel ); + break; + } + case 15: + { + int pixel = 0; + switch (b_o) + { + case RGB: pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); break; + case RBG: pixel = ((r & 0xf8) << 7) | ((b & 0xf8) << 2) | ((g & 0xf8) >> 3); break; + case GRB: pixel = ((g & 0xf8) << 7) | ((r & 0xf8) << 2) | ((b & 0xf8) >> 3); break; + case GBR: pixel = ((g & 0xf8) << 7) | ((b & 0xf8) << 2) | ((r & 0xf8) >> 3); break; + case BRG: pixel = ((b & 0xf8) << 7) | ((r & 0xf8) << 2) | ((g & 0xf8) >> 3); break; + case BGR: pixel = ((b & 0xf8) << 7) | ((g & 0xf8) << 2) | ((r & 0xf8) >> 3); break; + } + XPutPixel( data_image, x, y, pixel ); + break; + } + case 16: + { + // I actually don't know if for 16-bit displays, it is alway the green + // component or the second component which has 6 bits. + int pixel = 0; + switch (b_o) + { + case RGB: pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); break; + case RBG: pixel = ((r & 0xf8) << 8) | ((b & 0xfc) << 3) | ((g & 0xf8) >> 3); break; + case GRB: pixel = ((g & 0xf8) << 8) | ((r & 0xfc) << 3) | ((b & 0xf8) >> 3); break; + case GBR: pixel = ((g & 0xf8) << 8) | ((b & 0xfc) << 3) | ((r & 0xf8) >> 3); break; + case BRG: pixel = ((b & 0xf8) << 8) | ((r & 0xfc) << 3) | ((g & 0xf8) >> 3); break; + case BGR: pixel = ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | ((r & 0xf8) >> 3); break; + } + XPutPixel( data_image, x, y, pixel ); + break; + } + case 32: + case 24: + { + int pixel = 0; + switch (b_o) + { + case RGB: pixel = (r << 16) | (g << 8) | b; break; + case RBG: pixel = (r << 16) | (b << 8) | g; break; + case BRG: pixel = (b << 16) | (r << 8) | g; break; + case BGR: pixel = (b << 16) | (g << 8) | r; break; + case GRB: pixel = (g << 16) | (r << 8) | b; break; + case GBR: pixel = (g << 16) | (b << 8) | r; break; + } + XPutPixel( data_image, x, y, pixel ); + } + default: break; + } + } // for + } // for - virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1); -}; -IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler) + // Blit picture -bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *data, long WXUNUSED(flags), - int width, int height, int WXUNUSED(depth)) -{ - M_BITMAPHANDLERDATA->m_width = width; - M_BITMAPHANDLERDATA->m_height = height; - M_BITMAPHANDLERDATA->m_depth = 1; - M_BITMAPHANDLERDATA->m_freePixmap = TRUE; + GC gc = XCreateGC( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, 0, NULL ); + XPutImage( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, gc, data_image, 0, 0, 0, 0, width, height ); - Display *dpy = (Display*) wxGetDisplay(); - M_BITMAPHANDLERDATA->m_display = (WXDisplay*) dpy; + XDestroyImage( data_image ); + XFreeGC( xdisplay, gc ); - M_BITMAPHANDLERDATA->m_pixmap = (WXPixmap) XCreateBitmapFromData (dpy, RootWindow (dpy, DefaultScreen (dpy)), (char*) data, width, height); - M_BITMAPHANDLERDATA->m_ok = (M_BITMAPHANDLERDATA->m_pixmap != (WXPixmap) 0) ; + // Blit mask + + if (image.HasMask()) + { + GC gc = XCreateGC( xdisplay, (Pixmap) GetMask()->GetBitmap(), 0, NULL ); + XPutImage( xdisplay, (Pixmap) GetMask()->GetBitmap(), gc, data_image, 0, 0, 0, 0, width, height ); + + XDestroyImage( mask_image ); + XFreeGC( xdisplay, gc ); + } + } return TRUE; } -void wxBitmap::CleanUpHandlers() +static void wxCalcPrecAndShift( unsigned long mask, int *shift, int *prec ) { - wxNode *node = sm_handlers.First(); - while ( node ) + *shift = 0; + *prec = 0; + + while (!(mask & 0x1)) { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - wxNode *next = node->Next(); - delete handler; - delete node; - node = next; + (*shift)++; + mask >>= 1; } -} - -void wxBitmap::InitStandardHandlers() -{ - // Initialize all standard bitmap or derived class handlers here. - AddHandler(new wxXBMFileHandler); - AddHandler(new wxXBMDataHandler); - // XPM will be handled by wxImage + while (mask & 0x1) + { + (*prec)++; + mask >>= 1; + } } -// Creates a bitmap with transparent areas drawn in -// the given colour. -wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour) +wxImage wxBitmap::ConvertToImage() const { - wxBitmap newBitmap(bitmap.GetWidth(), - bitmap.GetHeight(), - bitmap.GetDepth()); - wxMemoryDC destDC; - wxMemoryDC srcDC; - srcDC.SelectObject(bitmap); - destDC.SelectObject(newBitmap); - -#if 0 - wxBrush brush(colour, wxSOLID); - destDC.SetOptimization(FALSE); - destDC.SetBackground(brush); - destDC.Clear(); - destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), & srcDC, 0, 0, wxCOPY, TRUE); -#endif - - return newBitmap; -} - -//----------------------------------------------------------------------------- -// wxImage conversion routines -//----------------------------------------------------------------------------- + wxImage image; -/* + wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") ); -Date: Wed, 05 Jan 2000 11:45:40 +0100 -From: Frits Boel -To: julian.smart@ukonline.co.uk -Subject: Patch for Motif ConvertToBitmap + Display *xdisplay = (Display*) M_BMPDATA->m_display; + wxASSERT_MSG( xdisplay, wxT("No display") ); + + int xscreen = DefaultScreen( xdisplay ); + Visual* xvisual = DefaultVisual( xdisplay, xscreen ); + + int bpp = DefaultDepth( xdisplay, xscreen ); + + XImage *x_image = NULL; + if (GetPixmap()) + { + x_image = XGetImage( xdisplay, (Pixmap) GetPixmap(), + 0, 0, + GetWidth(), GetHeight(), + AllPlanes, ZPixmap ); + } else + if (GetBitmap()) + { + x_image = XGetImage( xdisplay, (Pixmap) GetBitmap(), + 0, 0, + GetWidth(), GetHeight(), + AllPlanes, ZPixmap ); + } else + { + wxFAIL_MSG( wxT("Ill-formed bitmap") ); + } -Hi Julian, + wxCHECK_MSG( x_image, wxNullImage, wxT("couldn't create image") ); -I've been working on a wxWin application for image processing. From the -beginning, I was surprised by the (lack of) speed of ConvertToBitmap, -till I looked in the source code of image.cpp. I saw that converting a -wxImage to a bitmap with 8-bit pixels is done with comparing every pixel -to the 256 colors of the palet. A very time-consuming piece of code! + image.Create( GetWidth(), GetHeight() ); + char unsigned *data = image.GetData(); -Because I wanted a faster application, I've made a 'patch' for this. In -short: every pixel of the image is compared to a sorted list with -colors. If the color is found in the list, the palette entry is -returned; if the color is not found, the color palette is searched and -then the palette entry is returned and the color added to the sorted -list. + if (!data) + { + XDestroyImage( x_image ); + wxFAIL_MSG( wxT("couldn't create image") ); + return wxNullImage; + } -Maybe there is another method for this, namely changing the palette -itself (if the colors are known, as is the case with tiffs with a -colormap). I did not look at this, maybe someone else did? + XImage *x_image_mask = NULL; + if (GetMask()) + { + x_image_mask = XGetImage( xdisplay, (Pixmap) GetMask()->GetBitmap(), + 0, 0, + GetWidth(), GetHeight(), + AllPlanes, ZPixmap ); -The code of the patch is attached, have a look on it, and maybe you will -ship it with the next release of wxMotif? + image.SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable + } -Regards, + int red_shift_right = 0; + int green_shift_right = 0; + int blue_shift_right = 0; + int red_shift_left = 0; + int green_shift_left = 0; + int blue_shift_left = 0; + bool use_shift = FALSE; -Frits Boel -Software engineer at Hubrecht Laboratory, The Netherlands. + if (GetPixmap()) + { + // Retrieve info + + XVisualInfo vinfo_template; + XVisualInfo *vi; + + vinfo_template.visual = xvisual; + vinfo_template.visualid = XVisualIDFromVisual( xvisual ); + vinfo_template.depth = bpp; + int nitem = 0; + + vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem ); + wxASSERT_MSG( vi, wxT("No visual info") ); + + int red_prec,green_prec,blue_prec; + int red_shift,green_shift,blue_shift; + wxCalcPrecAndShift( vi->red_mask, &red_shift, &red_prec ); + wxCalcPrecAndShift( vi->green_mask, &green_shift, &green_prec ); + wxCalcPrecAndShift( vi->blue_mask, &blue_shift, &blue_prec ); + if (bpp == 16) bpp = red_prec + green_prec + blue_prec; + + red_shift_right = red_shift; + red_shift_left = 8-red_prec; + green_shift_right = green_shift; + green_shift_left = 8-green_prec; + blue_shift_right = blue_shift; + blue_shift_left = 8-blue_prec; + +#if 0 + use_shift = (vi->visual->c_class == TrueColor) || (vi->visual->c_class == DirectColor); +#else + use_shift = TRUE; +#endif + + XFree( vi ); + } + if (GetBitmap()) + { + bpp = 1; + } -*/ -class wxSearchColor -{ -public: - wxSearchColor( void ); - wxSearchColor( int size, XColor *colors ); - ~wxSearchColor( void ); +// GdkColormap *cmap = gtk_widget_get_default_colormap(); - int SearchColor( int r, int g, int b ); -private: - int AddColor( unsigned int value, int pos ); + long pos = 0; + for (int j = 0; j < GetHeight(); j++) + { + for (int i = 0; i < GetWidth(); i++) + { + unsigned long pixel = XGetPixel( x_image, i, j ); + if (bpp == 1) + { + if (pixel == 0) + { + data[pos] = 0; + data[pos+1] = 0; + data[pos+2] = 0; + } + else + { + data[pos] = 255; + data[pos+1] = 255; + data[pos+2] = 255; + } + } + else if (use_shift) + { + data[pos] = (pixel >> red_shift_right) << red_shift_left; + data[pos+1] = (pixel >> green_shift_right) << green_shift_left; + data[pos+2] = (pixel >> blue_shift_right) << blue_shift_left; + } +#if 0 + else if (cmap->colors) + { + data[pos] = cmap->colors[pixel].red >> 8; + data[pos+1] = cmap->colors[pixel].green >> 8; + data[pos+2] = cmap->colors[pixel].blue >> 8; + } +#endif + else + { + wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") ); + } - int size; - XColor *colors; - unsigned int *color; - int *entry; + if (x_image_mask) + { + int mask_pixel = XGetPixel( x_image_mask, i, j ); + if (mask_pixel == 0) + { + data[pos] = 16; + data[pos+1] = 16; + data[pos+2] = 16; + } + } - int bottom; - int top; -}; + pos += 3; + } + } -wxSearchColor::wxSearchColor( void ) -{ - size = 0; - colors = (XColor*) NULL; - color = (unsigned int *) NULL; - entry = (int*) NULL; + XDestroyImage( x_image ); + if (x_image_mask) XDestroyImage( x_image_mask ); - bottom = 0; - top = 0; + return image; } -wxSearchColor::wxSearchColor( int size_, XColor *colors_ ) +wxBitmap::wxBitmap( const wxBitmap& bmp ) { - int i; - size = size_; - colors = colors_; - color = new unsigned int[size]; - entry = new int [size]; - - for (i = 0; i < size; i++ ) { - entry[i] = -1; - } - - bottom = top = ( size >> 1 ); + Ref( bmp ); } -wxSearchColor::~wxSearchColor( void ) +wxBitmap::wxBitmap( const wxString &filename, int type ) { - if ( color ) delete color; - if ( entry ) delete entry; + LoadFile( filename, type ); } -int wxSearchColor::SearchColor( int r, int g, int b ) +wxBitmap::wxBitmap( const char bits[], int width, int height, int WXUNUSED(depth) ) { - unsigned int value = ( ( ( r * 256 ) + g ) * 256 ) + b; - int begin = bottom; - int end = top; - int middle = 0; - - while ( begin <= end ) { - - middle = ( begin + end ) >> 1; + m_refData = new wxBitmapRefData(); - if ( value == color[middle] ) { - return( entry[middle] ); - } else if ( value < color[middle] ) { - end = middle - 1; - } else { - begin = middle + 1; - } + M_BMPDATA->m_display = wxGlobalDisplay(); - } + Display *xdisplay = (Display*) M_BMPDATA->m_display; + + int xscreen = DefaultScreen( xdisplay ); + Window xroot = RootWindow( xdisplay, xscreen ); + + M_BMPDATA->m_mask = (wxMask *) NULL; + M_BMPDATA->m_bitmap = (WXPixmap) XCreateBitmapFromData( xdisplay, xroot, (char *) bits, width, height ); + M_BMPDATA->m_width = width; + M_BMPDATA->m_height = height; + M_BMPDATA->m_bpp = 1; - return AddColor( value, middle ); + wxCHECK_RET( M_BMPDATA->m_bitmap, wxT("couldn't create bitmap") ); } -int wxSearchColor::AddColor( unsigned int value, int pos ) +wxBitmap::~wxBitmap() { - int i; - int pixel = -1; - int max = 3 * (65536); - for ( i = 0; i < 256; i++ ) { - int rdiff = ((value >> 8) & 0xFF00 ) - colors[i].red; - int gdiff = ((value ) & 0xFF00 ) - colors[i].green; - int bdiff = ((value << 8) & 0xFF00 ) - colors[i].blue; - int sum = abs (rdiff) + abs (gdiff) + abs (bdiff); - if (sum < max) { pixel = i; max = sum; } - } - - if ( entry[pos] < 0 ) { - color[pos] = value; - entry[pos] = pixel; - } else if ( value < color[pos] ) { - - if ( bottom > 0 ) { - for ( i = bottom; i < pos; i++ ) { - color[i-1] = color[i]; - entry[i-1] = entry[i]; - } - bottom--; - color[pos-1] = value; - entry[pos-1] = pixel; - } else if ( top < size-1 ) { - for ( i = top; i >= pos; i-- ) { - color[i+1] = color[i]; - entry[i+1] = entry[i]; - } - top++; - color[pos] = value; - entry[pos] = pixel; - } - - } else { - - if ( top < size-1 ) { - for ( i = top; i > pos; i-- ) { - color[i+1] = color[i]; - entry[i+1] = entry[i]; - } - top++; - color[pos+1] = value; - entry[pos+1] = pixel; - } else if ( bottom > 0 ) { - for ( i = bottom; i < pos; i++ ) { - color[i-1] = color[i]; - entry[i-1] = entry[i]; - } - bottom--; - color[pos] = value; - entry[pos] = pixel; - } - - } - - return( pixel ); } - -bool wxBitmap::CreateFromImage( const wxImage& image, int depth ) +wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp ) { - wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") ) - wxCHECK_MSG( depth == -1, FALSE, wxT("invalid bitmap depth") ) + if ( m_refData != bmp.m_refData ) + Ref( bmp ); - m_refData = new wxBitmapRefData(); + return *this; +} - int width = image.GetWidth(); - int height = image.GetHeight(); +bool wxBitmap::operator == ( const wxBitmap& bmp ) const +{ + return m_refData == bmp.m_refData; +} - SetHeight( height ); - SetWidth( width ); +bool wxBitmap::operator != ( const wxBitmap& bmp ) const +{ + return m_refData != bmp.m_refData; +} - Display *dpy = (Display*) wxGetDisplay(); - Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) ); - int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) ); +bool wxBitmap::Ok() const +{ + return (m_refData != NULL); +} - // Create image +int wxBitmap::GetHeight() const +{ + wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); - XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 ); - data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height ); + return M_BMPDATA->m_height; +} - Create( width, height, bpp ); +int wxBitmap::GetWidth() const +{ + wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); - // Create mask + return M_BMPDATA->m_width; +} - XImage *mask_image = (XImage*) NULL; - if (image.HasMask()) - { - mask_image = XCreateImage( dpy, vis, 1, ZPixmap, 0, 0, width, height, 32, 0 ); - mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height ); - } +int wxBitmap::GetDepth() const +{ + wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); - // Retrieve depth info + return M_BMPDATA->m_bpp; +} - XVisualInfo vinfo_template; - XVisualInfo *vi; +wxMask *wxBitmap::GetMask() const +{ + wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") ); - vinfo_template.visual = vis; - vinfo_template.visualid = XVisualIDFromVisual( vis ); - vinfo_template.depth = bpp; - int nitem = 0; + return M_BMPDATA->m_mask; +} - vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem ); +void wxBitmap::SetMask( wxMask *mask ) +{ + wxCHECK_RET( Ok(), wxT("invalid bitmap") ); - wxCHECK_MSG( vi, FALSE, wxT("no visual") ); + if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask; - XFree( vi ); + M_BMPDATA->m_mask = mask; +} - if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15; - if (bpp < 8) bpp = 8; +bool wxBitmap::CopyFromIcon(const wxIcon& icon) +{ + *this = icon; + return TRUE; +} - // Render +wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const +{ + wxCHECK_MSG( Ok() && + (rect.x >= 0) && (rect.y >= 0) && + (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height), + wxNullBitmap, wxT("invalid bitmap or bitmap region") ); - enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR }; - byte_order b_o = RGB; + wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp ); + wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") ); - if (bpp >= 24) + + wxFAIL_MSG( "wxBitmap::GetSubBitmap not yet implemented" ); + +#if 0 + if (ret.GetPixmap()) { - if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask)) b_o = RGB; - else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask)) b_o = RGB; - else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask)) b_o = BRG; - else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR; - else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask)) b_o = GRB; - else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask)) b_o = GBR; + GdkGC *gc = gdk_gc_new( ret.GetPixmap() ); + gdk_draw_pixmap( ret.GetPixmap(), gc, GetPixmap(), rect.x, rect.y, 0, 0, rect.width, rect.height ); + gdk_gc_destroy( gc ); + } + else + { + GdkGC *gc = gdk_gc_new( ret.GetBitmap() ); + gdk_wx_draw_bitmap( ret.GetBitmap(), gc, GetBitmap(), rect.x, rect.y, 0, 0, rect.width, rect.height ); + gdk_gc_destroy( gc ); } - int r_mask = image.GetMaskRed(); - int g_mask = image.GetMaskGreen(); - int b_mask = image.GetMaskBlue(); - - XColor colors[256]; - if (bpp == 8) + if (GetMask()) { - Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy ); + wxMask *mask = new wxMask; + mask->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, rect.width, rect.height, 1 ); + + GdkGC *gc = gdk_gc_new( mask->m_bitmap ); + gdk_wx_draw_bitmap( mask->m_bitmap, gc, M_BMPDATA->m_mask->m_bitmap, 0, 0, rect.x, rect.y, rect.width, rect.height ); + gdk_gc_destroy( gc ); - for (int i = 0; i < 256; i++) colors[i].pixel = i; - XQueryColors( dpy, cmap, colors, 256 ); + ret.SetMask( mask ); } +#endif - wxSearchColor scolor( 256, colors ); - unsigned char* data = image.GetData(); + return ret; +} - bool hasMask = image.HasMask(); +bool wxBitmap::SaveFile( const wxString &name, int type, wxPalette *WXUNUSED(palette) ) +{ + wxCHECK_MSG( Ok(), FALSE, wxT("invalid bitmap") ); - int index = 0; - for (int y = 0; y < height; y++) + // Try to save the bitmap via wxImage handlers: { - for (int x = 0; x < width; x++) - { - int r = data[index]; - index++; - int g = data[index]; - index++; - int b = data[index]; - index++; - - if (hasMask) - { - if ((r == r_mask) && (b == b_mask) && (g == g_mask)) - XPutPixel( mask_image, x, y, 0 ); - else - XPutPixel( mask_image, x, y, 1 ); - } - - switch (bpp) - { - case 8: - { -#if 0 // Old, slower code - int pixel = -1; - /* - if (wxTheApp->m_colorCube) - { - pixel = wxTheApp->m_colorCube - [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ]; - } - else - { - */ - int max = 3 * (65536); - for (int i = 0; i < 256; i++) - { - int rdiff = (r << 8) - colors[i].red; - int gdiff = (g << 8) - colors[i].green; - int bdiff = (b << 8) - colors[i].blue; - int sum = abs (rdiff) + abs (gdiff) + abs (bdiff); - if (sum < max) { pixel = i; max = sum; } - } - /* - } - */ -#endif + wxImage image( *this ); + if (image.Ok()) return image.SaveFile( name, type ); + } - // And this is all to get the 'right' color... - int pixel = scolor.SearchColor( r, g, b ); - XPutPixel( data_image, x, y, pixel ); - break; - } - case 15: - { - int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); - XPutPixel( data_image, x, y, pixel ); - break; - } - case 16: - { - int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); - XPutPixel( data_image, x, y, pixel ); - break; - } - case 32: - case 24: - { - int pixel = 0; - switch (b_o) - { - case RGB: pixel = (r << 16) | (g << 8) | b; break; - case RBG: pixel = (r << 16) | (b << 8) | g; break; - case BRG: pixel = (b << 16) | (r << 8) | g; break; - case BGR: pixel = (b << 16) | (g << 8) | r; break; - case GRB: pixel = (g << 16) | (r << 8) | b; break; - case GBR: pixel = (g << 16) | (b << 8) | r; break; - } - XPutPixel( data_image, x, y, pixel ); - } - default: break; - } - } // for - } // for + return FALSE; +} - // Blit picture +bool wxBitmap::LoadFile( const wxString &name, int type ) +{ + UnRef(); - XGCValues gcvalues; - gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) ); - GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues ); - XPutImage( dpy, (Drawable)GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height ); + if (!wxFileExists(name)) return FALSE; - XDestroyImage( data_image ); - XFreeGC( dpy, gc ); - // Blit mask - if (image.HasMask()) + if (type == wxBITMAP_TYPE_XPM) { - wxBitmap maskBitmap(width, height, 1); + m_refData = new wxBitmapRefData(); - GC gcMask = XCreateGC( dpy, (Pixmap) maskBitmap.GetPixmap(), 0, (XGCValues*)NULL ); - XPutImage( dpy, (Drawable)maskBitmap.GetPixmap(), gcMask, mask_image, 0, 0, 0, 0, width, height ); + M_BMPDATA->m_display = wxGlobalDisplay(); + + Display *xdisplay = (Display*) M_BMPDATA->m_display; + + int xscreen = DefaultScreen( xdisplay ); + Window xroot = RootWindow( xdisplay, xscreen ); + + int bpp = DefaultDepth( xdisplay, xscreen ); - XDestroyImage( mask_image ); - XFreeGC( dpy, gcMask ); + XpmAttributes xpmAttr; + xpmAttr.valuemask = XpmReturnInfos; // nothing yet, but get infos back - wxMask* mask = new wxMask; - mask->SetPixmap(maskBitmap.GetPixmap()); + Pixmap pixmap; + Pixmap mask = 0; + + int ErrorStatus = XpmReadFileToPixmap( xdisplay, xroot, (char*) name.c_str(), &pixmap, &mask, &xpmAttr); + + if (ErrorStatus == XpmSuccess) + { + M_BMPDATA->m_width = xpmAttr.width; + M_BMPDATA->m_height = xpmAttr.height; - SetMask(mask); + M_BMPDATA->m_bpp = bpp; // mono as well? - maskBitmap.SetPixmapNull(); + XpmFreeAttributes(&xpmAttr); + + M_BMPDATA->m_bitmap = (WXPixmap) pixmap; + + if (mask) + { + M_BMPDATA->m_mask = new wxMask; + M_BMPDATA->m_mask->SetBitmap( (WXPixmap) mask ); + M_BMPDATA->m_mask->SetDisplay( xdisplay ); + } + } + else + { + UnRef(); + + return FALSE; + } + } + else // try if wxImage can load it + { + wxImage image; + if (!image.LoadFile( name, type )) return FALSE; + if (image.Ok()) *this = image.ConvertToBitmap(); + else return FALSE; } - return TRUE; } -wxImage wxBitmap::ConvertToImage() const +wxPalette *wxBitmap::GetPalette() const { - wxImage image; - - wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") ); - - Display *dpy = (Display*) wxGetDisplay(); - Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) ); - int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) ); - - XImage *ximage = XGetImage( dpy, - (Drawable)GetPixmap(), - 0, 0, - GetWidth(), GetHeight(), - AllPlanes, ZPixmap ); - - wxCHECK_MSG( ximage, wxNullImage, wxT("couldn't create image") ); - - image.Create( GetWidth(), GetHeight() ); - char unsigned *data = image.GetData(); - - if (!data) - { - XDestroyImage( ximage ); - wxFAIL_MSG( wxT("couldn't create image") ); - return wxNullImage; - } + if (!Ok()) return (wxPalette *) NULL; - /* - GdkImage *gdk_image_mask = (GdkImage*) NULL; - if (GetMask()) - { - gdk_image_mask = gdk_image_get( GetMask()->GetBitmap(), - 0, 0, - GetWidth(), GetHeight() ); - - image.SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable - } - */ + return M_BMPDATA->m_palette; +} - // Retrieve depth info +void wxBitmap::SetHeight( int height ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); - XVisualInfo vinfo_template; - XVisualInfo *vi; + M_BMPDATA->m_height = height; +} - vinfo_template.visual = vis; - vinfo_template.visualid = XVisualIDFromVisual( vis ); - vinfo_template.depth = bpp; - int nitem = 0; +void wxBitmap::SetWidth( int width ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); - vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem ); + M_BMPDATA->m_width = width; +} - wxCHECK_MSG( vi, wxNullImage, wxT("no visual") ); +void wxBitmap::SetDepth( int depth ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); - if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15; + M_BMPDATA->m_bpp = depth; +} - XFree( vi ); +void wxBitmap::SetPixmap( WXPixmap pixmap ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); - XColor colors[256]; - if (bpp == 8) - { - Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy ); + M_BMPDATA->m_pixmap = pixmap; +} - for (int i = 0; i < 256; i++) colors[i].pixel = i; - XQueryColors( dpy, cmap, colors, 256 ); - } +void wxBitmap::SetBitmap( WXPixmap bitmap ) +{ + if (!m_refData) m_refData = new wxBitmapRefData(); - long pos = 0; - for (int j = 0; j < GetHeight(); j++) - { - for (int i = 0; i < GetWidth(); i++) - { - int pixel = XGetPixel( ximage, i, j ); - if (bpp <= 8) - { - data[pos] = colors[pixel].red >> 8; - data[pos+1] = colors[pixel].green >> 8; - data[pos+2] = colors[pixel].blue >> 8; - } else if (bpp == 15) - { - data[pos] = (pixel >> 7) & 0xf8; - data[pos+1] = (pixel >> 2) & 0xf8; - data[pos+2] = (pixel << 3) & 0xf8; - } else if (bpp == 16) - { - data[pos] = (pixel >> 8) & 0xf8; - data[pos+1] = (pixel >> 3) & 0xfc; - data[pos+2] = (pixel << 3) & 0xf8; - } else - { - data[pos] = (pixel >> 16) & 0xff; - data[pos+1] = (pixel >> 8) & 0xff; - data[pos+2] = pixel & 0xff; - } + M_BMPDATA->m_bitmap = bitmap; +} - /* - if (gdk_image_mask) - { - int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j ); - if (mask_pixel == 0) - { - data[pos] = 16; - data[pos+1] = 16; - data[pos+2] = 16; - } - } - */ +WXPixmap wxBitmap::GetPixmap() const +{ + wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") ); - pos += 3; - } - } + return M_BMPDATA->m_pixmap; +} - XDestroyImage( ximage ); - /* - if (gdk_image_mask) gdk_image_destroy( gdk_image_mask ); - */ +WXPixmap wxBitmap::GetBitmap() const +{ + wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") ); - return image; + return M_BMPDATA->m_bitmap; } -bool wxBitmap::CopyFromIcon(const wxIcon& icon) +WXDisplay *wxBitmap::GetDisplay() const { - wxBitmap* bitmap = (wxBitmap*) & icon; + wxCHECK_MSG( Ok(), (WXDisplay*) NULL, wxT("invalid bitmap") ); - *this = *bitmap; - - return TRUE; + return M_BMPDATA->m_display; } + diff --git a/src/x11/cursor.cpp b/src/x11/cursor.cpp index 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; - - Display *dpy = (Display*) wxGetDisplay(); - int screen_num = DefaultScreen (dpy); + m_refData = new wxCursorRefData(); - Pixmap pixmap = XCreatePixmapFromBitmapData (dpy, - RootWindow (dpy, DefaultScreen(dpy)), - (char*) bits, width, height, - 1 , 0 , 1); - - Pixmap mask_pixmap = None; - if (maskBits != NULL) + M_CURSORDATA->m_display = wxGlobalDisplay(); + wxASSERT_MSG( M_CURSORDATA->m_display, wxT("No display") ); + + int x_cur = XC_left_ptr; + switch (cursorId) { - mask_pixmap = XCreatePixmapFromBitmapData (dpy, - RootWindow (dpy, DefaultScreen(dpy)), - (char*) maskBits, width, height, - 1 , 0 , 1); + case wxCURSOR_DEFAULT: x_cur = XC_left_ptr; break; + case wxCURSOR_HAND: x_cur = XC_hand1; break; + case wxCURSOR_CROSS: x_cur = XC_crosshair; break; + case wxCURSOR_SIZEWE: x_cur = XC_sb_h_double_arrow; break; + case wxCURSOR_SIZENS: x_cur = XC_sb_v_double_arrow; break; + case wxCURSOR_ARROWWAIT: + case wxCURSOR_WAIT: + case wxCURSOR_WATCH: x_cur = XC_watch; break; + case wxCURSOR_SIZING: x_cur = XC_sizing; break; + case wxCURSOR_SPRAYCAN: x_cur = XC_spraycan; break; + case wxCURSOR_IBEAM: x_cur = XC_xterm; break; + case wxCURSOR_PENCIL: x_cur = XC_pencil; break; + case wxCURSOR_NO_ENTRY: x_cur = XC_pirate; break; + case wxCURSOR_SIZENWSE: + case wxCURSOR_SIZENESW: x_cur = XC_fleur; break; + case wxCURSOR_QUESTION_ARROW: x_cur = XC_question_arrow; break; + case wxCURSOR_PAINT_BRUSH: x_cur = XC_spraycan; break; + case wxCURSOR_MAGNIFIER: x_cur = XC_plus; break; + case wxCURSOR_CHAR: x_cur = XC_xterm; break; + case wxCURSOR_LEFT_BUTTON: x_cur = XC_leftbutton; break; + case wxCURSOR_MIDDLE_BUTTON: x_cur = XC_middlebutton; break; + case wxCURSOR_RIGHT_BUTTON: x_cur = XC_rightbutton; break; + case wxCURSOR_BULLSEYE: x_cur = XC_target; break; + + case wxCURSOR_POINT_LEFT: x_cur = XC_sb_left_arrow; break; + case wxCURSOR_POINT_RIGHT: x_cur = XC_sb_right_arrow; break; +/* + case wxCURSOR_DOUBLE_ARROW: x_cur = XC_double_arrow; break; + case wxCURSOR_CROSS_REVERSE: x_cur = XC_cross_reverse; break; + case wxCURSOR_BASED_ARROW_UP: x_cur = XC_based_arrow_up; break; + case wxCURSOR_BASED_ARROW_DOWN: x_cur = XC_based_arrow_down; break; +*/ + default: + wxFAIL_MSG(wxT("unsupported cursor type")); + // will use the standard one } - XColor foreground_color; - XColor background_color; - foreground_color.pixel = BlackPixel(dpy, screen_num); - background_color.pixel = WhitePixel(dpy, screen_num); - Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy); - XQueryColor(dpy, cmap, &foreground_color); - XQueryColor(dpy, cmap, &background_color); - - Cursor cursor = XCreatePixmapCursor (dpy, - pixmap, - mask_pixmap, - &foreground_color, - &background_color, - hotSpotX , - hotSpotY); - - XFreePixmap( dpy, pixmap ); - if (mask_pixmap != None) - { - XFreePixmap( dpy, mask_pixmap ); - } + M_CURSORDATA->m_cursor = (WXCursor) XCreateFontCursor( (Display*) M_CURSORDATA->m_display, x_cur ); +} - if (cursor) - { - wxXCursor *c = new wxXCursor; +wxCursor::wxCursor(const char bits[], int width, int height, + int hotSpotX, int hotSpotY, + const char maskBits[], wxColour *fg, wxColour *bg) +{ + wxFAIL_MSG( "wxCursor creation from bits not yet implemented" ); +} - c->m_cursor = (WXCursor) cursor; - c->m_display = (WXDisplay*) dpy; - M_CURSORDATA->m_cursors.Append(c); - M_CURSORDATA->m_ok = TRUE; - } - else - { - M_CURSORDATA->m_ok = TRUE; - } + +wxCursor::wxCursor( const wxCursor &cursor ) +{ + Ref( cursor ); } -wxCursor::wxCursor(const wxString& name, long flags, int hotSpotX, int hotSpotY) +#if wxUSE_IMAGE +wxCursor::wxCursor( const wxImage & image ) { - // Must be an XBM file - if (flags != wxBITMAP_TYPE_XBM) - return; + wxFAIL_MSG( "wxCursor creation from wxImage not yet implemented" ); +} +#endif - m_refData = new wxCursorRefData; +wxCursor::~wxCursor() +{ +} - int hotX = -1, hotY = -1; - unsigned int w, h; - Pixmap pixmap; +wxCursor& wxCursor::operator = ( const wxCursor& cursor ) +{ + if (*this == cursor) + return (*this); - Display *dpy = (Display*) wxGetDisplay(); - int screen_num = DefaultScreen (dpy); + Ref( cursor ); - int value = XReadBitmapFile (dpy, RootWindow (dpy, DefaultScreen (dpy)), - (char*) (const char*) name, &w, &h, &pixmap, &hotX, &hotY); + return *this; +} - M_BITMAPDATA->m_width = w; - M_BITMAPDATA->m_height = h; - M_BITMAPDATA->m_depth = 1; +bool wxCursor::operator == ( const wxCursor& cursor ) const +{ + return m_refData == cursor.m_refData; +} - if ((value == BitmapFileInvalid) || - (value == BitmapOpenFailed) || - (value == BitmapNoMemory)) - { - } - else - { - XColor foreground_color; - XColor background_color; - foreground_color.pixel = BlackPixel(dpy, screen_num); - background_color.pixel = WhitePixel(dpy, screen_num); - Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy); - XQueryColor(dpy, cmap, &foreground_color); - XQueryColor(dpy, cmap, &background_color); - - // TODO: how do we determine whether hotX, hotY were read correctly? - if (hotX < 0 || hotY < 0) - { - hotX = hotSpotX; - hotY = hotSpotY; - } - if (hotX < 0 || hotY < 0) - { - hotX = 0; - hotY = 0; - } - - Pixmap mask_pixmap = None; - Cursor cursor = XCreatePixmapCursor (dpy, - pixmap, - mask_pixmap, - &foreground_color, - &background_color, - hotX, - hotY); - - XFreePixmap( dpy, pixmap ); - if (cursor) - { - wxXCursor *c = new wxXCursor; - - c->m_cursor = (WXCursor) cursor; - c->m_display = (WXDisplay*) dpy; - M_CURSORDATA->m_cursors.Append(c); - M_CURSORDATA->m_ok = TRUE; - } - } +bool wxCursor::operator != ( const wxCursor& cursor ) const +{ + return m_refData != cursor.m_refData; +} +bool wxCursor::Ok() const +{ + return (m_refData != NULL); } -// Cursors by stock number -wxCursor::wxCursor(wxStockCursor id) +WXCursor wxCursor::GetCursor() const { - m_refData = new wxCursorRefData; - M_CURSORDATA->m_cursorId = id; - M_CURSORDATA->m_ok = TRUE; + return M_CURSORDATA->m_cursor; +} - WXDisplay* display = wxGetDisplay(); - if (!display) - return; +//----------------------------------------------------------------------------- +// busy cursor routines +//----------------------------------------------------------------------------- - WXCursor cursor = GetXCursor(display); - if (cursor) - { - wxXCursor* c = new wxXCursor; - c->m_cursor = cursor; - c->m_display = wxGetDisplay(); - M_CURSORDATA->m_cursors.Append(c); - M_CURSORDATA->m_ok = TRUE; - } -} +/* extern */ wxCursor g_globalCursor; -wxCursor::~wxCursor() +static wxCursor gs_savedCursor; +static int gs_busyCount = 0; + +const wxCursor &wxBusyCursor::GetStoredCursor() { + return gs_savedCursor; } -// Motif-specific: create/get a cursor for the current display -WXCursor wxCursor::GetXCursor(WXDisplay* display) +const wxCursor wxBusyCursor::GetBusyCursor() { - if (!M_CURSORDATA) - return (WXCursor) 0; - wxNode* node = M_CURSORDATA->m_cursors.First(); - while (node) - { - wxXCursor* c = (wxXCursor*) node->Data(); - if (c->m_display == display) - return c->m_cursor; - node = node->Next(); - } + return wxCursor(wxCURSOR_WATCH); +} - // No cursor for this display, so let's see if we're an id-type cursor. +void wxEndBusyCursor() +{ + if (--gs_busyCount > 0) + return; - if (M_CURSORDATA->m_cursorId != wxCURSOR_NONE) - { - WXCursor cursor = MakeCursor(display, M_CURSORDATA->m_cursorId); - if (cursor) - { - wxXCursor* c = new wxXCursor; - c->m_cursor = cursor; - c->m_display = display; - M_CURSORDATA->m_cursors.Append(c); - return cursor; - } - else - return (WXCursor) 0; - } + wxSetCursor( gs_savedCursor ); + gs_savedCursor = wxNullCursor; - // Not an id-type cursor, so we don't know how to create it. - return (WXCursor) 0; + if (wxTheApp) + wxTheApp->SendIdleEvents(); } -// Make a cursor from standard id -WXCursor wxCursor::MakeCursor(WXDisplay* display, wxStockCursor id) +void wxBeginBusyCursor( wxCursor *WXUNUSED(cursor) ) { - Display* dpy = (Display*) display; - Cursor cursor = (Cursor) 0; + if (gs_busyCount++ > 0) + return; - switch (id) - { - case wxCURSOR_WAIT: - { - cursor = XCreateFontCursor (dpy, XC_watch); - break; - } - case wxCURSOR_CROSS: - { - cursor = XCreateFontCursor (dpy, XC_crosshair); - break; - } - case wxCURSOR_CHAR: - { - // Nothing - break; - } - case wxCURSOR_HAND: - { - cursor = XCreateFontCursor (dpy, XC_hand1); - break; - } - case wxCURSOR_BULLSEYE: - { - cursor = XCreateFontCursor (dpy, XC_target); - break; - } - case wxCURSOR_PENCIL: - { - cursor = XCreateFontCursor (dpy, XC_pencil); - break; - } - case wxCURSOR_MAGNIFIER: - { - cursor = XCreateFontCursor (dpy, XC_sizing); - break; - } - case wxCURSOR_IBEAM: - { - cursor = XCreateFontCursor (dpy, XC_xterm); - break; - } - case wxCURSOR_NO_ENTRY: - { - cursor = XCreateFontCursor (dpy, XC_pirate); - break; - } - case wxCURSOR_LEFT_BUTTON: - { - cursor = XCreateFontCursor (dpy, XC_leftbutton); - break; - } - case wxCURSOR_RIGHT_BUTTON: - { - cursor = XCreateFontCursor (dpy, XC_rightbutton); - break; - } - case wxCURSOR_MIDDLE_BUTTON: - { - cursor = XCreateFontCursor (dpy, XC_middlebutton); - break; - } - case wxCURSOR_QUESTION_ARROW: - { - cursor = XCreateFontCursor (dpy, XC_question_arrow); - break; - } - case wxCURSOR_SIZING: - { - cursor = XCreateFontCursor (dpy, XC_sizing); - break; - } - case wxCURSOR_WATCH: - { - cursor = XCreateFontCursor (dpy, XC_watch); - break; - } - case wxCURSOR_SPRAYCAN: - { - cursor = XCreateFontCursor (dpy, XC_spraycan); - break; - } - case wxCURSOR_PAINT_BRUSH: - { - cursor = XCreateFontCursor (dpy, XC_spraycan); - break; - } - case wxCURSOR_SIZENWSE: - case wxCURSOR_SIZENESW: - { - // Not available in X - cursor = XCreateFontCursor (dpy, XC_crosshair); - break; - } - case wxCURSOR_SIZEWE: - { - cursor = XCreateFontCursor (dpy, XC_sb_h_double_arrow); - break; - } - case wxCURSOR_SIZENS: - { - cursor = XCreateFontCursor (dpy, XC_sb_v_double_arrow); - break; - } - case wxCURSOR_POINT_LEFT: - { - cursor = XCreateFontCursor (dpy, XC_sb_left_arrow); - break; - } - case wxCURSOR_POINT_RIGHT: - { - cursor = XCreateFontCursor (dpy, XC_sb_right_arrow); - break; - } - // (JD Huggins) added more stock cursors for X - // X-only cursors BEGIN - case wxCURSOR_CROSS_REVERSE: - { - cursor = XCreateFontCursor(dpy, XC_cross_reverse); - break; - } - case wxCURSOR_DOUBLE_ARROW: - { - cursor = XCreateFontCursor(dpy, XC_double_arrow); - break; - } - case wxCURSOR_BASED_ARROW_UP: - { - cursor = XCreateFontCursor(dpy, XC_based_arrow_up); - break; - } - case wxCURSOR_BASED_ARROW_DOWN: - { - cursor = XCreateFontCursor(dpy, XC_based_arrow_down); - break; - } - default: - case wxCURSOR_ARROW: - { - cursor = XCreateFontCursor (dpy, XC_top_left_arrow); - break; - } - case wxCURSOR_BLANK: - { - GC gc; - XGCValues gcv; - Pixmap empty_pixmap; - XColor blank_color; - - empty_pixmap = XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)), - 16, 16, 1); - gcv.function = GXxor; - gc = XCreateGC (dpy, - empty_pixmap, - GCFunction, - &gcv); - XCopyArea (dpy, - empty_pixmap, - empty_pixmap, - gc, - 0, 0, - 16, 16, - 0, 0); - XFreeGC (dpy, gc); - cursor = XCreatePixmapCursor (dpy, - empty_pixmap, - empty_pixmap, - &blank_color, - &blank_color, - 8, 8); - - break; - } - } - return (WXCursor) cursor; + wxASSERT_MSG( !gs_savedCursor.Ok(), + wxT("forgot to call wxEndBusyCursor, will leak memory") ); + + gs_savedCursor = g_globalCursor; + + wxSetCursor( wxCursor(wxCURSOR_WATCH) ); + + if (wxTheApp) + wxTheApp->SendIdleEvents(); } -// Global cursor setting -void wxSetCursor(const wxCursor& WXUNUSED(cursor)) +bool wxIsBusy() { - // Nothing to do for Motif (no global cursor) + return gs_busyCount > 0; } - +void wxSetCursor( const wxCursor& cursor ) +{ + g_globalCursor = cursor; +} diff --git a/src/x11/dcclient.cpp b/src/x11/dcclient.cpp index 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) - -/* -* Icons -*/ +//----------------------------------------------------------------------------- +// wxIcon +//----------------------------------------------------------------------------- -wxIcon::wxIcon() -{ -} - -// Create from XBM data -wxIcon::wxIcon(const char bits[], int width, int height) -{ - (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, 1); -} +IMPLEMENT_DYNAMIC_CLASS(wxIcon,wxBitmap) -// Create from XPM data -wxIcon::wxIcon(char **data) +wxIcon::wxIcon( const char **bits, int WXUNUSED(width), int WXUNUSED(height) ) : + wxBitmap( bits ) { - (void) Create((void*) data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); } -wxIcon::wxIcon(const char **data) +wxIcon::wxIcon( char **bits, int WXUNUSED(width), int WXUNUSED(height) ) : + wxBitmap( bits ) { - (void) Create((void*) data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); } -wxIcon::wxIcon(const wxString& icon_file, long flags, - int desiredWidth, int desiredHeight) - +wxIcon::wxIcon() : wxBitmap() { - LoadFile(icon_file, flags, desiredWidth, desiredHeight); } -wxIcon::~wxIcon() +wxIcon::wxIcon( const wxIcon& icon ) : wxBitmap() { + Ref(icon); } -bool wxIcon::LoadFile(const wxString& filename, long type, - int desiredWidth, int desiredHeight) +wxIcon& wxIcon::operator = ( const wxIcon& icon ) { - UnRef(); - - m_refData = new wxBitmapRefData; - - wxBitmapHandler *handler = FindHandler(type); - - if ( handler ) - return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight); - else - return FALSE; + if (*this == icon) return (*this); + Ref(icon); + return *this; } -bool wxIcon::CopyFromBitmap(const wxBitmap& bitmap) +void wxIcon::CopyFromBitmap(const wxBitmap& bmp) { - wxIcon* icon = (wxIcon*) (& bitmap); + wxIcon *icon = (wxIcon*)(&bmp); *this = *icon; - 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; }