Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. introduced wxUniversal::wxWindow and moved wxControl drawing to it

Browse Source 
2. wxStaticBox is more GTK-ish


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/wxUNIVERSAL@8197 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2000-08-27 15:42:15 +00:00
parent c21be757d6
commit bd9218ba08
20 changed files with 717 additions and 616 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
include/wx/control.h
View File

@@ -41,11 +41,6 @@ public:
const wxValidator& validator = wxDefaultValidator, const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr); const wxString& name = wxControlNameStr);
// set the background image
virtual void SetBackground(const wxBitmap& bitmap,
int alignment = wxALIGN_CENTRE,
wxStretch stretch = wxSTRETCH_NOT);
// simulates the event of given type (i.e. wxButton::Command() is just as // simulates the event of given type (i.e. wxButton::Command() is just as
// if the button was clicked) // if the button was clicked)
virtual void Command(wxCommandEvent &event); virtual void Command(wxCommandEvent &event);
@@ -53,10 +48,6 @@ public:
// get the control alignment (left/right/centre, top/bottom/centre) // get the control alignment (left/right/centre, top/bottom/centre)
int GetAlignment() const { return m_windowStyle & wxALIGN_MASK; } int GetAlignment() const { return m_windowStyle & wxALIGN_MASK; }
// get the control border style: uses the current style and falls back to
// the default style for this class otherwise
wxBorder GetBorder() const;
protected: protected:
// creates the control (calls wxWindowBase::CreateBase inside) and adds it // creates the control (calls wxWindowBase::CreateBase inside) and adds it
// to the list of parents children // to the list of parents children
@@ -73,10 +64,6 @@ protected:
// initialize the common fields of wxCommandEvent // initialize the common fields of wxCommandEvent
void InitCommandEvent(wxCommandEvent& event) const; void InitCommandEvent(wxCommandEvent& event) const;
// override this to change the default (i.e. used when no style is
// specified) border for the control
virtual wxBorder GetDefaultBorder() const;
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

23
include/wx/gtk/window.h
View File

@@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: window.h // Name: wx/gtk/window.h
// Purpose: // Purpose:
// Author: Robert Roebling // Author: Robert Roebling
// Id: $Id$ // Id: $Id$
@@ -19,21 +19,22 @@
// callback definition for inserting a window (internal) // callback definition for inserting a window (internal)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
typedef void (*wxInsertChildFunction)( wxWindow*, wxWindow* ); class wxWindowGTK;
typedef void (*wxInsertChildFunction)( wxWindowGTK*, wxWindowGTK* );
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxWindow // wxWindowGTK
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class wxWindow : public wxWindowBase class wxWindowGTK : public wxWindowBase
{ {
DECLARE_DYNAMIC_CLASS(wxWindow) DECLARE_DYNAMIC_CLASS(wxWindowGTK)
public: public:
// creating the window // creating the window
// ------------------- // -------------------
wxWindow(); wxWindowGTK();
wxWindow(wxWindow *parent, wxWindowGTK(wxWindow *parent,
wxWindowID id, wxWindowID id,
const wxPoint& pos = wxDefaultPosition, const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, const wxSize& size = wxDefaultSize,
@@ -45,7 +46,7 @@ public:
const wxSize& size = wxDefaultSize, const wxSize& size = wxDefaultSize,
long style = 0, long style = 0,
const wxString& name = wxPanelNameStr); const wxString& name = wxPanelNameStr);
virtual ~wxWindow(); virtual ~wxWindowGTK();
// implement base class (pure) virtual methods // implement base class (pure) virtual methods
// ------------------------------------------- // -------------------------------------------
@@ -117,13 +118,13 @@ public:
void OnIdle(wxIdleEvent& WXUNUSED(event)) {}; void OnIdle(wxIdleEvent& WXUNUSED(event)) {};
/* used by all window classes in the widget creation process */ /* used by all window classes in the widget creation process */
bool PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize &size ); bool PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size );
void PostCreation(); void PostCreation();
/* internal addition of child windows. differs from class /* internal addition of child windows. differs from class
to class not by using virtual functions but by using to class not by using virtual functions but by using
the m_insertCallback */ the m_insertCallback */
void DoAddChild(wxWindow *child); void DoAddChild(wxWindowGTK *child);
/* the methods below are required because many native widgets /* the methods below are required because many native widgets
are composed of several subwidgets and setting a style for are composed of several subwidgets and setting a style for
@@ -228,7 +229,7 @@ public:
void Init(); void Init();
private: private:
DECLARE_NO_COPY_CLASS(wxWindow); DECLARE_NO_COPY_CLASS(wxWindowGTK);
}; };
#endif // __GTKWINDOWH__ #endif // __GTKWINDOWH__

23
include/wx/gtk1/window.h
View File

@@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: window.h // Name: wx/gtk/window.h
// Purpose: // Purpose:
// Author: Robert Roebling // Author: Robert Roebling
// Id: $Id$ // Id: $Id$
@@ -19,21 +19,22 @@
// callback definition for inserting a window (internal) // callback definition for inserting a window (internal)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
typedef void (*wxInsertChildFunction)( wxWindow*, wxWindow* ); class wxWindowGTK;
typedef void (*wxInsertChildFunction)( wxWindowGTK*, wxWindowGTK* );
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxWindow // wxWindowGTK
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class wxWindow : public wxWindowBase class wxWindowGTK : public wxWindowBase
{ {
DECLARE_DYNAMIC_CLASS(wxWindow) DECLARE_DYNAMIC_CLASS(wxWindowGTK)
public: public:
// creating the window // creating the window
// ------------------- // -------------------
wxWindow(); wxWindowGTK();
wxWindow(wxWindow *parent, wxWindowGTK(wxWindow *parent,
wxWindowID id, wxWindowID id,
const wxPoint& pos = wxDefaultPosition, const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, const wxSize& size = wxDefaultSize,
@@ -45,7 +46,7 @@ public:
const wxSize& size = wxDefaultSize, const wxSize& size = wxDefaultSize,
long style = 0, long style = 0,
const wxString& name = wxPanelNameStr); const wxString& name = wxPanelNameStr);
virtual ~wxWindow(); virtual ~wxWindowGTK();
// implement base class (pure) virtual methods // implement base class (pure) virtual methods
// ------------------------------------------- // -------------------------------------------
@@ -117,13 +118,13 @@ public:
void OnIdle(wxIdleEvent& WXUNUSED(event)) {}; void OnIdle(wxIdleEvent& WXUNUSED(event)) {};
/* used by all window classes in the widget creation process */ /* used by all window classes in the widget creation process */
bool PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize &size ); bool PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size );
void PostCreation(); void PostCreation();
/* internal addition of child windows. differs from class /* internal addition of child windows. differs from class
to class not by using virtual functions but by using to class not by using virtual functions but by using
the m_insertCallback */ the m_insertCallback */
void DoAddChild(wxWindow *child); void DoAddChild(wxWindowGTK *child);
/* the methods below are required because many native widgets /* the methods below are required because many native widgets
are composed of several subwidgets and setting a style for are composed of several subwidgets and setting a style for
@@ -228,7 +229,7 @@ public:
void Init(); void Init();
private: private:
DECLARE_NO_COPY_CLASS(wxWindow); DECLARE_NO_COPY_CLASS(wxWindowGTK);
}; };
#endif // __GTKWINDOWH__ #endif // __GTKWINDOWH__

61
include/wx/univ/control.h
View File

@@ -16,28 +16,10 @@
#pragma interface "control.h" #pragma interface "control.h"
#endif #endif
#include "wx/bitmap.h" // for m_bitmapBg
class WXDLLEXPORT wxControlRenderer; class WXDLLEXPORT wxControlRenderer;
class WXDLLEXPORT wxInputHandler; class WXDLLEXPORT wxInputHandler;
class WXDLLEXPORT wxRenderer; class WXDLLEXPORT wxRenderer;
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// control state flags used in wxRenderer and wxColourScheme
enum
{
wxCONTROL_DISABLED = 0x00000001, // control is disabled
wxCONTROL_FOCUSED = 0x00000002, // currently has keyboard focus
wxCONTROL_PRESSED = 0x00000004, // (button) is pressed
wxCONTROL_ISDEFAULT = 0x00000008, // only applies to the buttons
wxCONTROL_CURRENT = 0x00000010, // mouse is currently over the control
wxCONTROL_FLAGS_MASK = 0x0000001f
};
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxControlAction: the action is currently just a string which identifies it, // wxControlAction: the action is currently just a string which identifies it,
// later it might become an atom (i.e. an opaque handler to string). As one // later it might become an atom (i.e. an opaque handler to string). As one
@@ -105,26 +87,6 @@ public:
virtual void SetLabel(const wxString &label); virtual void SetLabel(const wxString &label);
virtual wxString GetLabel() const; virtual wxString GetLabel() const;
// set/query the bg image
virtual void SetBackground(const wxBitmap& bitmap,
int alignment = wxALIGN_CENTRE,
wxStretch stretch = wxSTRETCH_NOT);
const wxBitmap& GetBackgroundBitmap(int *alignment = NULL,
wxStretch *stretch = NULL) const;
// get the state information
virtual bool IsFocused() const;
virtual bool IsCurrent() const;
virtual bool IsPressed() const;
virtual bool IsDefault() const;
// return all state flags at once (combination of wxCONTROL_XXX values)
int GetStateFlags() const;
// operations
virtual void SetCurrent(bool doit = TRUE);
// implementation only from now on // implementation only from now on
// return the index of the accel char in the label or -1 if none // return the index of the accel char in the label or -1 if none
@@ -143,30 +105,15 @@ public:
const wxEvent& event); const wxEvent& event);
protected: protected:
// returns the (low level) renderer to use for drawing the control by
// querying the current theme
wxRenderer *GetRenderer() const;
// create the event translator object for this control: the base class // create the event translator object for this control: the base class
// action creates the default one which doesn't do anything // action creates the default one which doesn't do anything
virtual wxInputHandler *CreateInputHandler() const; virtual wxInputHandler *CreateInputHandler() const;
// draw the control background, return TRUE if done
virtual bool DoDrawBackground(wxControlRenderer *renderer);
// draw the controls contents
virtual void DoDraw(wxControlRenderer *renderer);
// adjust the size of the control to take into account its borders
wxSize AdjustSize(const wxSize& size) const;
// event handlers // event handlers
void OnMouse(wxMouseEvent& event); void OnMouse(wxMouseEvent& event);
void OnKeyDown(wxKeyEvent& event); void OnKeyDown(wxKeyEvent& event);
void OnKeyUp(wxKeyEvent& event); void OnKeyUp(wxKeyEvent& event);
void OnFocus(wxFocusEvent& event); void OnFocus(wxFocusEvent& event);
void OnPaint(wxPaintEvent& event);
void OnErase(wxEraseEvent& event);
private: private:
// common part of all ctors // common part of all ctors
@@ -182,14 +129,6 @@ private:
wxString m_label; wxString m_label;
int m_indexAccel; int m_indexAccel;
// background bitmap info
wxBitmap m_bitmapBg;
int m_alignBgBitmap;
wxStretch m_stretchBgBitmap;
// state
bool m_isCurrent;
DECLARE_DYNAMIC_CLASS(wxControl) DECLARE_DYNAMIC_CLASS(wxControl)
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
}; };

12
include/wx/univ/renderer.h
View File

@@ -28,7 +28,6 @@
#ifndef _WX_UNIV_RENDERER_H_ #ifndef _WX_UNIV_RENDERER_H_
#define _WX_UNIV_RENDERER_H_ #define _WX_UNIV_RENDERER_H_
class WXDLLEXPORT wxControl;
class WXDLLEXPORT wxDC; class WXDLLEXPORT wxDC;
class WXDLLEXPORT wxScrollBar; class WXDLLEXPORT wxScrollBar;
class WXDLLEXPORT wxWindow; class WXDLLEXPORT wxWindow;
@@ -157,6 +156,12 @@ public:
virtual ~wxRenderer(); virtual ~wxRenderer();
protected: protected:
// draw a frame around rectFrame rectangle but not touching the rectLabel
// one: this is used by DrawFrame()
void StandardDrawFrame(wxDC& dc,
const wxRect& rectFrame,
const wxRect& rectLabel);
// standard scrollbar hit testing: this assumes that it only has 2 arrows // standard scrollbar hit testing: this assumes that it only has 2 arrows
// and a thumb, so the themes which have more complicated scrollbars (e.g. // and a thumb, so the themes which have more complicated scrollbars (e.g.
// BeOS) can't use this method // BeOS) can't use this method
@@ -261,7 +266,7 @@ class WXDLLEXPORT wxControlRenderer
{ {
public: public:
// create a renderer for this dc with this "fundamental" renderer // create a renderer for this dc with this "fundamental" renderer
wxControlRenderer(wxControl *control, wxDC& dc, wxRenderer *renderer); wxControlRenderer(wxWindow *control, wxDC& dc, wxRenderer *renderer);
// operations // operations
void DrawLabel(const wxBitmap& bitmap = wxNullBitmap, void DrawLabel(const wxBitmap& bitmap = wxNullBitmap,
@@ -280,6 +285,7 @@ public:
void DrawScrollbar(const wxScrollBar *scrollbar); void DrawScrollbar(const wxScrollBar *scrollbar);
// accessors // accessors
wxWindow *GetWindow() const { return m_window; }
wxRenderer *GetRenderer() const { return m_renderer; } wxRenderer *GetRenderer() const { return m_renderer; }
wxDC& GetDC() { return m_dc; } wxDC& GetDC() { return m_dc; }
@@ -288,7 +294,7 @@ public:
wxRect& GetRect() { return m_rect; } wxRect& GetRect() { return m_rect; }
private: private:
wxControl *m_ctrl; wxWindow *m_window;
wxRenderer *m_renderer; wxRenderer *m_renderer;
wxDC& m_dc; wxDC& m_dc;
wxRect m_rect; wxRect m_rect;

111
include/wx/univ/window.h
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/window.h // Name: wx/univ/window.h
// Purpose: wxUniversalWindow class which is the base class for all // Purpose: wxWindow class which is the base class for all
// wxUniv port controls, it supports the customization of the // wxUniv port controls, it supports the customization of the
// window drawing and input processing. // window drawing and input processing.
// Author: Vadim Zeitlin // Author: Vadim Zeitlin
@@ -18,37 +18,122 @@
#pragma interface "univwindow.h" #pragma interface "univwindow.h"
#endif #endif
#include "wx/bitmap.h" // for m_bitmapBg
class WXDLLEXPORT wxControlRenderer;
class WXDLLEXPORT wxRenderer; class WXDLLEXPORT wxRenderer;
class WXDLLEXPORT wxScrollBar;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxUniversalWindow // constants
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT wxUniversalWindow : public wxWindow // control state flags used in wxRenderer and wxColourScheme
enum
{
wxCONTROL_DISABLED = 0x00000001, // control is disabled
wxCONTROL_FOCUSED = 0x00000002, // currently has keyboard focus
wxCONTROL_PRESSED = 0x00000004, // (button) is pressed
wxCONTROL_ISDEFAULT = 0x00000008, // only applies to the buttons
wxCONTROL_CURRENT = 0x00000010, // mouse is currently over the control
wxCONTROL_FLAGS_MASK = 0x0000001f
};
// ----------------------------------------------------------------------------
// wxWindow
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxWindow : public wxWindowNative
{ {
public: public:
// ctor // ctors and creatie functions
wxUniversalWindow(wxWindowBase *parent, // ---------------------------
wxWindow() { Init(); }
wxWindow(wxWindow *parent,
wxWindowID id, wxWindowID id,
const wxPoint& pos = wxDefaultPosition, const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, const wxSize& size = wxDefaultSize,
long style = 0, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxPanelNameStr) const wxString& name = wxPanelNameStr)
: wxWindow(parent, id, pos, size, style, validator, name) : wxWindowNative(parent, id, pos, size, style, name)
{ } { Init(); }
// background pixmap support
// -------------------------
virtual void SetBackground(const wxBitmap& bitmap,
int alignment = wxALIGN_CENTRE,
wxStretch stretch = wxSTRETCH_NOT);
const wxBitmap& GetBackgroundBitmap(int *alignment = NULL,
wxStretch *stretch = NULL) const;
// scrollbars: we (re)implement it ourselves using our own scrollbars
// instead of the native ones
// ------------------------------------------------------------------
virtual void SetScrollbar( int orient,
int pos,
int thumbVisible,
int range,
bool refresh = TRUE );
virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE );
virtual int GetScrollPos( int orient ) const;
virtual int GetScrollThumb( int orient ) const;
virtual int GetScrollRange( int orient ) const;
// miscellaneous other methods
// ---------------------------
// get the state information
virtual bool IsFocused() const;
virtual bool IsCurrent() const;
virtual bool IsPressed() const;
virtual bool IsDefault() const;
// return all state flags at once (combination of wxCONTROL_XXX values)
int GetStateFlags() const;
// operations
virtual void SetCurrent(bool doit = TRUE);
protected: protected:
// draw the controls contents: the base class version draws the border as // common part of all ctors
// required (depending on the window style flags and enabled state) and void Init();
// adjusts the DC so that subsequent drawing is clipped to the area inside
// the border
virtual void DoDraw(wxDC& dc, wxRenderer *renderer);
// event handlers // event handlers
void OnPaint(wxPaintEvent& event); void OnPaint(wxPaintEvent& event);
void OnErase(wxEraseEvent& event);
// returns the (low level) renderer to use for drawing the control by
// querying the current theme
wxRenderer *GetRenderer() const;
// draw the control background, return TRUE if done
virtual bool DoDrawBackground(wxControlRenderer *renderer);
// draw the controls contents
virtual void DoDraw(wxControlRenderer *renderer);
// adjust the size of the window to take into account its borders
wxSize AdjustSize(const wxSize& size) const;
// background bitmap info
wxBitmap m_bitmapBg;
int m_alignBgBitmap;
wxStretch m_stretchBgBitmap;
// is the mouse currently inside the window?
bool m_isCurrent;
private: private:
// the window scrollbars
wxScrollBar *m_scrollbarHorz,
*m_scrollbarVert;
DECLARE_DYNAMIC_CLASS(wxWindow)
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
}; };

27
include/wx/window.h
View File

@@ -554,6 +554,10 @@ public:
// misc // misc
// ---- // ----
// get the window border style: uses the current style and falls back to
// the default style for this class otherwise (see GetDefaultBorder())
wxBorder GetBorder() const;
void UpdateWindowUI(); void UpdateWindowUI();
#if wxUSE_MENUS #if wxUSE_MENUS
@@ -569,10 +573,10 @@ public:
// configure the window scrollbars // configure the window scrollbars
virtual void SetScrollbar( int orient, virtual void SetScrollbar( int orient,
int pos, int pos,
int thumbVisible, int thumbvisible,
int range, int range,
bool refresh = TRUE ) = 0; bool refresh = true ) = 0;
virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE ) = 0; virtual void SetScrollPos( int orient, int pos, bool refresh = true ) = 0;
virtual int GetScrollPos( int orient ) const = 0; virtual int GetScrollPos( int orient ) const = 0;
virtual int GetScrollThumb( int orient ) const = 0; virtual int GetScrollThumb( int orient ) const = 0;
virtual int GetScrollRange( int orient ) const = 0; virtual int GetScrollRange( int orient ) const = 0;
@@ -762,6 +766,10 @@ protected:
// ctor // ctor
void InitBase(); void InitBase();
// override this to change the default (i.e. used when no style is
// specified) border for the window class
virtual wxBorder GetDefaultBorder() const;
// get the default size for the new window if no explicit size given // get the default size for the new window if no explicit size given
// FIXME why 20 and not 30, 10 or ...? // FIXME why 20 and not 30, 10 or ...?
static int WidthDefault(int w) { return w == -1 ? 20 : w; } static int WidthDefault(int w) { return w == -1 ? 20 : w; }
@@ -861,12 +869,15 @@ private:
// now include the declaration of wxWindow class // now include the declaration of wxWindow class
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// include the declaration of the platform-specific class
#if defined(__WXMSW__) #if defined(__WXMSW__)
#include "wx/msw/window.h" #include "wx/msw/window.h"
#define wxWindowNative wxWindowMSW
#elif defined(__WXMOTIF__) #elif defined(__WXMOTIF__)
#include "wx/motif/window.h" #include "wx/motif/window.h"
#elif defined(__WXGTK__) #elif defined(__WXGTK__)
#include "wx/gtk/window.h" #include "wx/gtk/window.h"
#define wxWindowNative wxWindowGTK
#elif defined(__WXQT__) #elif defined(__WXQT__)
#include "wx/qt/window.h" #include "wx/qt/window.h"
#elif defined(__WXMAC__) #elif defined(__WXMAC__)
@@ -875,6 +886,14 @@ private:
#include "wx/os2/window.h" #include "wx/os2/window.h"
#endif #endif
// for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
// for the native ports we just rename wxWindow<platform> into wxWindows
#if defined(__WXUNIVERSAL__)
#include "wx/univ/window.h"
#else
#define wxWindow wxWindowNative
#endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// inline functions which couldn't be declared in the class body because of // inline functions which couldn't be declared in the class body because of
// forward dependencies // forward dependencies
@@ -889,7 +908,7 @@ inline wxWindow *wxWindowBase::GetGrandParent() const
// global function // global function
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
WXDLLEXPORT extern wxWindow* wxGetActiveWindow(); WXDLLEXPORT extern wxWindow *wxGetActiveWindow();
// deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId() // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
inline WXDLLEXPORT int NewControlId() { return wxWindowBase::NewControlId(); } inline WXDLLEXPORT int NewControlId() { return wxWindowBase::NewControlId(); }

6
samples/univ/univ.cpp
View File

@@ -131,7 +131,11 @@ END_EVENT_TABLE()
bool MyUnivApp::OnInitGui() bool MyUnivApp::OnInitGui()
{ {
#ifdef __WXMSW__
m_colourBg = *wxLIGHT_GREY; m_colourBg = *wxLIGHT_GREY;
#else
m_colourBg = wxColour(0xd6d6d6);
#endif
if ( argc > 1 ) if ( argc > 1 )
{ {
@@ -143,6 +147,8 @@ bool MyUnivApp::OnInitGui()
// manually use the right colours // manually use the right colours
if ( themeName == _T("gtk") ) if ( themeName == _T("gtk") )
m_colourBg = wxColour(0xd6d6d6); m_colourBg = wxColour(0xd6d6d6);
else if ( themeName == _T("win32") )
m_colourBg = *wxLIGHT_GREY;
wxTheme::Set(theme); wxTheme::Set(theme);
} }

26
src/common/ctrlcmn.cpp
View File

@@ -119,32 +119,6 @@ void wxControlBase::InitCommandEvent(wxCommandEvent& event) const
} }
} }
// ----------------------------------------------------------------------------
// other stuff
// ----------------------------------------------------------------------------
void wxControlBase::SetBackground(const wxBitmap& bitmap,
int alignment,
wxStretch stretch)
{
}
wxBorder wxControlBase::GetBorder() const
{
wxBorder border = (wxBorder)(m_windowStyle & wxBORDER_MASK);
if ( border == wxBORDER_DEFAULT )
{
border = GetDefaultBorder();
}
return border;
}
wxBorder wxControlBase::GetDefaultBorder() const
{
return wxBORDER_NONE;
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxStaticBitmap // wxStaticBitmap
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

20
src/common/wincmn.cpp
View File

@@ -1473,3 +1473,23 @@ void wxWindowListNode::DeleteData()
delete (wxWindow *)GetData(); delete (wxWindow *)GetData();
} }
// ----------------------------------------------------------------------------
// borders
// ----------------------------------------------------------------------------
wxBorder wxWindowBase::GetBorder() const
{
wxBorder border = (wxBorder)(m_windowStyle & wxBORDER_MASK);
if ( border == wxBORDER_DEFAULT )
{
border = GetDefaultBorder();
}
return border;
}
wxBorder wxWindowBase::GetDefaultBorder() const
{
return wxBORDER_NONE;
}

6
src/gtk/app.cpp
View File

@@ -620,12 +620,12 @@ int wxEntryInitGui()
{ {
int retValue = 0; int retValue = 0;
if ( !wxTheApp->OnInitGui() )
retValue = -1;
wxRootWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL ); wxRootWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_realize( wxRootWindow ); gtk_widget_realize( wxRootWindow );
if ( !wxTheApp->OnInitGui() )
retValue = -1;
return retValue; return retValue;
} }

241
src/gtk/window.cpp
View File

@@ -198,15 +198,15 @@ extern wxCursor g_globalCursor;
// mouse capture state: the window which has it and if the mouse is currently // mouse capture state: the window which has it and if the mouse is currently
// inside it // inside it
static wxWindow *g_captureWindow = (wxWindow*) NULL; static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
static bool g_captureWindowHasMouse = FALSE; static bool g_captureWindowHasMouse = FALSE;
/* extern */ wxWindow *g_focusWindow = (wxWindow*) NULL; /* extern */ wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL;
// the last window which had the focus - this is normally never NULL (except // the last window which had the focus - this is normally never NULL (except
// if we never had focus at all) as even when g_focusWindow is NULL it still // if we never had focus at all) as even when g_focusWindow is NULL it still
// keeps its previous value // keeps its previous value
static wxWindow *g_focusWindowLast = (wxWindow *)NULL; static wxWindowGTK *g_focusWindowLast = (wxWindowGTK *)NULL;
// if we detect that the app has got/lost the focus, we set this variable to // if we detect that the app has got/lost the focus, we set this variable to
// either TRUE or FALSE and an activate event will be sent during the next // either TRUE or FALSE and an activate event will be sent during the next
@@ -325,11 +325,11 @@ extern bool g_isIdle;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// returns the child of win which currently has focus or NULL if not found // returns the child of win which currently has focus or NULL if not found
static wxWindow *FindFocusedChild(wxWindow *win) static wxWindowGTK *FindFocusedChild(wxWindowGTK *win)
{ {
wxWindow *winFocus = wxWindow::FindFocus(); wxWindowGTK *winFocus = wxWindowGTK::FindFocus();
if ( !winFocus ) if ( !winFocus )
return (wxWindow *)NULL; return (wxWindowGTK *)NULL;
if ( winFocus == win ) if ( winFocus == win )
return win; return win;
@@ -338,15 +338,15 @@ static wxWindow *FindFocusedChild(wxWindow *win)
node; node;
node = node->GetNext() ) node = node->GetNext() )
{ {
wxWindow *child = FindFocusedChild(node->GetData()); wxWindowGTK *child = FindFocusedChild(node->GetData());
if ( child ) if ( child )
return child; return child;
} }
return (wxWindow *)NULL; return (wxWindowGTK *)NULL;
} }
static void draw_frame( GtkWidget *widget, wxWindow *win ) static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
{ {
if (!win->m_hasVMT) if (!win->m_hasVMT)
return; return;
@@ -435,7 +435,7 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
// "expose_event" of m_widget // "expose_event" of m_widget
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ) gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )
{ {
if (gdk_event->count > 0) return FALSE; if (gdk_event->count > 0) return FALSE;
@@ -448,7 +448,7 @@ gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_even
// "draw" of m_widget // "draw" of m_widget
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win ) static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
{ {
draw_frame( widget, win ); draw_frame( widget, win );
} }
@@ -667,7 +667,9 @@ static long map_to_wx_keysym( KeySym keysym )
// "expose_event" of m_wxwindow // "expose_event" of m_wxwindow
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ) static int gtk_window_expose_callback( GtkWidget *widget,
GdkEventExpose *gdk_event,
wxWindow *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -746,7 +748,9 @@ static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_ev
There, we look for expose events ourselves whereas all other events are There, we look for expose events ourselves whereas all other events are
handled normally. */ handled normally. */
gint gtk_window_event_event_callback( GtkWidget *widget, GdkEventExpose *event, wxWindow *win ) gint gtk_window_event_event_callback( GtkWidget *widget,
GdkEventExpose *event,
wxWindow *win )
{ {
if (event->type == GDK_EXPOSE) if (event->type == GDK_EXPOSE)
{ {
@@ -764,7 +768,7 @@ gint gtk_window_event_event_callback( GtkWidget *widget, GdkEventExpose *event,
/* This callback is a complete replacement of the gtk_pizza_draw() function, /* This callback is a complete replacement of the gtk_pizza_draw() function,
which disabled. */ which disabled. */
static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win ) static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -828,7 +832,9 @@ static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxW
// "key_press_event" from any window // "key_press_event" from any window
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win ) static gint gtk_window_key_press_callback( GtkWidget *widget,
GdkEventKey *gdk_event,
wxWindow *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -873,7 +879,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
#if wxUSE_ACCEL #if wxUSE_ACCEL
if (!ret) if (!ret)
{ {
wxWindow *ancestor = win; wxWindowGTK *ancestor = win;
while (ancestor) while (ancestor)
{ {
int command = ancestor->GetAcceleratorTable()->GetCommand( event ); int command = ancestor->GetAcceleratorTable()->GetCommand( event );
@@ -950,7 +956,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
if ( (!ret) && if ( (!ret) &&
(gdk_event->keyval == GDK_F10) ) (gdk_event->keyval == GDK_F10) )
{ {
wxWindow *ancestor = win; wxWindowGTK *ancestor = win;
while (ancestor) while (ancestor)
{ {
if (wxIsKindOf(ancestor,wxFrame)) if (wxIsKindOf(ancestor,wxFrame))
@@ -988,7 +994,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
// "key_release_event" from any window // "key_release_event" from any window
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win ) static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1078,7 +1084,7 @@ static void AdjustEventButtonState(wxMouseEvent& event)
// "button_press_event" // "button_press_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win ) static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1181,7 +1187,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
wxNode *node = win->GetChildren().First(); wxNode *node = win->GetChildren().First();
while (node) while (node)
{ {
wxWindow *child = (wxWindow*)node->Data(); wxWindowGTK *child = (wxWindowGTK*)node->Data();
node = node->Next(); node = node->Next();
if (!child->IsShown()) if (!child->IsShown())
@@ -1252,7 +1258,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
// "button_release_event" // "button_release_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win ) static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1313,7 +1319,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
wxNode *node = win->GetChildren().First(); wxNode *node = win->GetChildren().First();
while (node) while (node)
{ {
wxWindow *child = (wxWindow*)node->Data(); wxWindowGTK *child = (wxWindowGTK*)node->Data();
node = node->Next(); node = node->Next();
if (!child->IsShown()) if (!child->IsShown())
@@ -1395,7 +1401,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
static gint gtk_window_motion_notify_callback( GtkWidget *widget, static gint gtk_window_motion_notify_callback( GtkWidget *widget,
GdkEventMotion *gdk_event, GdkEventMotion *gdk_event,
wxWindow *win ) wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1461,7 +1467,7 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
wxNode *node = win->GetChildren().First(); wxNode *node = win->GetChildren().First();
while (node) while (node)
{ {
wxWindow *child = (wxWindow*)node->Data(); wxWindowGTK *child = (wxWindowGTK*)node->Data();
node = node->Next(); node = node->Next();
if (!child->IsShown()) if (!child->IsShown())
@@ -1523,7 +1529,9 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
// "focus_in_event" // "focus_in_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win ) static gint gtk_window_focus_in_callback( GtkWidget *widget,
GdkEvent *WXUNUSED(event),
wxWindow *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1595,7 +1603,7 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
// "focus_out_event" // "focus_out_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win ) static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1610,11 +1618,11 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
// g_sendActivateEvent to -1 // g_sendActivateEvent to -1
g_sendActivateEvent = 0; g_sendActivateEvent = 0;
wxWindow *winFocus = FindFocusedChild(win); wxWindowGTK *winFocus = FindFocusedChild(win);
if ( winFocus ) if ( winFocus )
win = winFocus; win = winFocus;
g_focusWindow = (wxWindow *)NULL; g_focusWindow = (wxWindowGTK *)NULL;
/* /*
printf( "OnKillFocus from " ); printf( "OnKillFocus from " );
@@ -1653,7 +1661,7 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
// "enter_notify_event" // "enter_notify_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win ) static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1692,7 +1700,7 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
// "leave_notify_event" // "leave_notify_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win ) static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1740,7 +1748,7 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
// "value_changed" from m_vAdjust // "value_changed" from m_vAdjust
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win ) static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1776,7 +1784,7 @@ static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win )
// "value_changed" from m_hAdjust // "value_changed" from m_hAdjust
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win ) static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1813,7 +1821,7 @@ static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win )
static gint gtk_scrollbar_button_press_callback( GtkRange *widget, static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
GdkEventButton *gdk_event, GdkEventButton *gdk_event,
wxWindow *win) wxWindowGTK *win)
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1833,7 +1841,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
static gint gtk_scrollbar_button_release_callback( GtkRange *widget, static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
GdkEventButton *WXUNUSED(gdk_event), GdkEventButton *WXUNUSED(gdk_event),
wxWindow *win) wxWindowGTK *win)
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1879,7 +1887,8 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
wxWindow *wxWindowBase::FindFocus() wxWindow *wxWindowBase::FindFocus()
{ {
return g_focusWindow; // the cast is necessary when we compile in wxUniversal mode
return (wxWindow *)g_focusWindow;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -1953,7 +1962,7 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
static static
void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
GtkAllocation* WXUNUSED_UNLESS_XIM(alloc), GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
wxWindow* WXUNUSED_UNLESS_XIM(win) ) wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
{ {
if (g_isIdle) if (g_isIdle)
wxapp_install_idle_handler(); wxapp_install_idle_handler();
@@ -1982,7 +1991,7 @@ void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
static gint static gint
gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget), gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
wxWindow * WXUNUSED_UNLESS_XIM(win) ) wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
{ {
if (g_isIdle) if (g_isIdle)
wxapp_install_idle_handler(); wxapp_install_idle_handler();
@@ -2068,17 +2077,17 @@ gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// InsertChild for wxWindow. // InsertChild for wxWindowGTK.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/* Callback for wxWindow. This very strange beast has to be used because /* Callback for wxWindowGTK. This very strange beast has to be used because
* C++ has no virtual methods in a constructor. We have to emulate a * C++ has no virtual methods in a constructor. We have to emulate a
* virtual function here as wxNotebook requires a different way to insert * virtual function here as wxNotebook requires a different way to insert
* a child in it. I had opted for creating a wxNotebookPage window class * a child in it. I had opted for creating a wxNotebookPage window class
* which would have made this superfluous (such in the MDI window system), * which would have made this superfluous (such in the MDI window system),
* but no-one was listening to me... */ * but no-one was listening to me... */
static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child ) static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
{ {
/* the window might have been scrolled already, do we /* the window might have been scrolled already, do we
have to adapt the position */ have to adapt the position */
@@ -2098,18 +2107,19 @@ static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
// global functions // global functions
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
wxWindow* wxGetActiveWindow() wxWindow *wxGetActiveWindow()
{ {
return g_focusWindow; // the cast is necessary when we compile in wxUniversal mode
return (wxWindow *)g_focusWindow;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxWindow // wxWindowGTK
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase) IMPLEMENT_DYNAMIC_CLASS(wxWindowGTK, wxWindowBase)
void wxWindow::Init() void wxWindowGTK::Init()
{ {
// common init // common init
InitBase(); InitBase();
@@ -2163,28 +2173,34 @@ void wxWindow::Init()
#endif #endif
} }
wxWindow::wxWindow() wxWindowGTK::wxWindowGTK()
{ {
Init(); Init();
} }
wxWindow::wxWindow( wxWindow *parent, wxWindowID id, wxWindowGTK::wxWindowGTK( wxWindow *parent,
const wxPoint &pos, const wxSize &size, wxWindowID id,
long style, const wxString &name ) const wxPoint &pos,
const wxSize &size,
long style,
const wxString &name )
{ {
Init(); Init();
Create( parent, id, pos, size, style, name ); Create( parent, id, pos, size, style, name );
} }
bool wxWindow::Create( wxWindow *parent, wxWindowID id, bool wxWindowGTK::Create( wxWindow *parent,
const wxPoint &pos, const wxSize &size, wxWindowID id,
long style, const wxString &name ) const wxPoint &pos,
const wxSize &size,
long style,
const wxString &name )
{ {
if (!PreCreation( parent, pos, size ) || if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{ {
wxFAIL_MSG( wxT("wxWindow creation failed") ); wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
return FALSE; return FALSE;
} }
@@ -2307,7 +2323,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
return TRUE; return TRUE;
} }
wxWindow::~wxWindow() wxWindowGTK::~wxWindowGTK()
{ {
m_isBeingDeleted = TRUE; m_isBeingDeleted = TRUE;
m_hasVMT = FALSE; m_hasVMT = FALSE;
@@ -2350,7 +2366,7 @@ wxWindow::~wxWindow()
} }
} }
bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize &size ) bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
{ {
wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") ); wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
@@ -2382,7 +2398,7 @@ bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize
return TRUE; return TRUE;
} }
void wxWindow::PostCreation() void wxWindowGTK::PostCreation()
{ {
wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
@@ -2461,7 +2477,7 @@ void wxWindow::PostCreation()
m_hasVMT = TRUE; m_hasVMT = TRUE;
} }
void wxWindow::ConnectWidget( GtkWidget *widget ) void wxWindowGTK::ConnectWidget( GtkWidget *widget )
{ {
gtk_signal_connect( GTK_OBJECT(widget), "key_press_event", gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this ); GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
@@ -2485,7 +2501,7 @@ void wxWindow::ConnectWidget( GtkWidget *widget )
GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this ); GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
} }
bool wxWindow::Destroy() bool wxWindowGTK::Destroy()
{ {
wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
@@ -2494,15 +2510,15 @@ bool wxWindow::Destroy()
return wxWindowBase::Destroy(); return wxWindowBase::Destroy();
} }
void wxWindow::DoMoveWindow(int x, int y, int width, int height) void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
{ {
gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height ); gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
} }
void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags ) void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
{ {
wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
wxASSERT_MSG( (m_parent != NULL), wxT("wxWindow::SetSize requires parent.\n") ); wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
if (m_resizing) return; /* I don't like recursions */ if (m_resizing) return; /* I don't like recursions */
m_resizing = TRUE; m_resizing = TRUE;
@@ -2593,7 +2609,7 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
m_resizing = FALSE; m_resizing = FALSE;
} }
void wxWindow::OnInternalIdle() void wxWindowGTK::OnInternalIdle()
{ {
if ( g_sendActivateEvent != -1 ) if ( g_sendActivateEvent != -1 )
{ {
@@ -2602,7 +2618,7 @@ void wxWindow::OnInternalIdle()
// do it only once // do it only once
g_sendActivateEvent = -1; g_sendActivateEvent = -1;
wxTheApp->SetActive(activate, g_focusWindowLast); wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
wxActivateEvent event(wxEVT_ACTIVATE, activate, GetId()); wxActivateEvent event(wxEVT_ACTIVATE, activate, GetId());
event.SetEventObject(this); event.SetEventObject(this);
@@ -2647,7 +2663,7 @@ void wxWindow::OnInternalIdle()
UpdateWindowUI(); UpdateWindowUI();
} }
void wxWindow::DoGetSize( int *width, int *height ) const void wxWindowGTK::DoGetSize( int *width, int *height ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2655,7 +2671,7 @@ void wxWindow::DoGetSize( int *width, int *height ) const
if (height) (*height) = m_height; if (height) (*height) = m_height;
} }
void wxWindow::DoSetClientSize( int width, int height ) void wxWindowGTK::DoSetClientSize( int width, int height )
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2718,7 +2734,7 @@ void wxWindow::DoSetClientSize( int width, int height )
} }
} }
void wxWindow::DoGetClientSize( int *width, int *height ) const void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2783,7 +2799,7 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
} }
} }
void wxWindow::DoGetPosition( int *x, int *y ) const void wxWindowGTK::DoGetPosition( int *x, int *y ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2800,7 +2816,7 @@ void wxWindow::DoGetPosition( int *x, int *y ) const
if (y) (*y) = m_y - dy; if (y) (*y) = m_y - dy;
} }
void wxWindow::DoClientToScreen( int *x, int *y ) const void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2829,7 +2845,7 @@ void wxWindow::DoClientToScreen( int *x, int *y ) const
if (y) *y += org_y; if (y) *y += org_y;
} }
void wxWindow::DoScreenToClient( int *x, int *y ) const void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2858,7 +2874,7 @@ void wxWindow::DoScreenToClient( int *x, int *y ) const
if (y) *y -= org_y; if (y) *y -= org_y;
} }
bool wxWindow::Show( bool show ) bool wxWindowGTK::Show( bool show )
{ {
wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
@@ -2876,7 +2892,7 @@ bool wxWindow::Show( bool show )
return TRUE; return TRUE;
} }
bool wxWindow::Enable( bool enable ) bool wxWindowGTK::Enable( bool enable )
{ {
wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
@@ -2893,7 +2909,7 @@ bool wxWindow::Enable( bool enable )
return TRUE; return TRUE;
} }
int wxWindow::GetCharHeight() const int wxWindowGTK::GetCharHeight() const
{ {
wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
@@ -2904,7 +2920,7 @@ int wxWindow::GetCharHeight() const
return font->ascent + font->descent; return font->ascent + font->descent;
} }
int wxWindow::GetCharWidth() const int wxWindowGTK::GetCharWidth() const
{ {
wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
@@ -2915,7 +2931,7 @@ int wxWindow::GetCharWidth() const
return gdk_string_width( font, "H" ); return gdk_string_width( font, "H" );
} }
void wxWindow::GetTextExtent( const wxString& string, void wxWindowGTK::GetTextExtent( const wxString& string,
int *x, int *x,
int *y, int *y,
int *descent, int *descent,
@@ -2934,7 +2950,7 @@ void wxWindow::GetTextExtent( const wxString& string,
if (externalLeading) (*externalLeading) = 0; // ?? if (externalLeading) (*externalLeading) = 0; // ??
} }
void wxWindow::SetFocus() void wxWindowGTK::SetFocus()
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2962,17 +2978,17 @@ void wxWindow::SetFocus()
} }
} }
bool wxWindow::AcceptsFocus() const bool wxWindowGTK::AcceptsFocus() const
{ {
return m_acceptsFocus && wxWindowBase::AcceptsFocus(); return m_acceptsFocus && wxWindowBase::AcceptsFocus();
} }
bool wxWindow::Reparent( wxWindowBase *newParentBase ) bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
{ {
wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
wxWindow *oldParent = m_parent, wxWindowGTK *oldParent = m_parent,
*newParent = (wxWindow *)newParentBase; *newParent = (wxWindowGTK *)newParentBase;
wxASSERT( GTK_IS_WIDGET(m_widget) ); wxASSERT( GTK_IS_WIDGET(m_widget) );
@@ -3003,7 +3019,7 @@ bool wxWindow::Reparent( wxWindowBase *newParentBase )
return TRUE; return TRUE;
} }
void wxWindow::DoAddChild(wxWindow *child) void wxWindowGTK::DoAddChild(wxWindowGTK *child)
{ {
wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
@@ -3018,7 +3034,7 @@ void wxWindow::DoAddChild(wxWindow *child)
(*m_insertCallback)(this, child); (*m_insertCallback)(this, child);
} }
void wxWindow::Raise() void wxWindowGTK::Raise()
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -3027,7 +3043,7 @@ void wxWindow::Raise()
gdk_window_raise( m_widget->window ); gdk_window_raise( m_widget->window );
} }
void wxWindow::Lower() void wxWindowGTK::Lower()
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -3036,7 +3052,7 @@ void wxWindow::Lower()
gdk_window_lower( m_widget->window ); gdk_window_lower( m_widget->window );
} }
bool wxWindow::SetCursor( const wxCursor &cursor ) bool wxWindowGTK::SetCursor( const wxCursor &cursor )
{ {
wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
@@ -3052,7 +3068,7 @@ bool wxWindow::SetCursor( const wxCursor &cursor )
return wxWindowBase::SetCursor( cursor ); return wxWindowBase::SetCursor( cursor );
} }
void wxWindow::WarpPointer( int x, int y ) void wxWindowGTK::WarpPointer( int x, int y )
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -3069,7 +3085,7 @@ void wxWindow::WarpPointer( int x, int y )
gdk_window_warp_pointer( window, x, y ); gdk_window_warp_pointer( window, x, y );
} }
void wxWindow::Refresh( bool eraseBackground, const wxRect *rect ) void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
{ {
if (!m_widget) return; if (!m_widget) return;
if (!m_widget->window) return; if (!m_widget->window) return;
@@ -3111,8 +3127,7 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
gdk_event.area.y = 0; gdk_event.area.y = 0;
gdk_event.area.width = m_wxwindow->allocation.width; gdk_event.area.width = m_wxwindow->allocation.width;
gdk_event.area.height = m_wxwindow->allocation.height; gdk_event.area.height = m_wxwindow->allocation.height;
gtk_window_expose_callback( m_wxwindow, &gdk_event, this ); gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );
} }
else else
{ {
@@ -3147,7 +3162,7 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
gdk_event.area.y = rect->y; gdk_event.area.y = rect->y;
gdk_event.area.width = rect->width; gdk_event.area.width = rect->width;
gdk_event.area.height = rect->height; gdk_event.area.height = rect->height;
gtk_window_expose_callback( m_wxwindow, &gdk_event, this ); gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );
} }
else else
{ {
@@ -3161,7 +3176,7 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
} }
} }
void wxWindow::Clear() void wxWindowGTK::Clear()
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3174,7 +3189,7 @@ void wxWindow::Clear()
} }
#if wxUSE_TOOLTIPS #if wxUSE_TOOLTIPS
void wxWindow::DoSetToolTip( wxToolTip *tip ) void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
{ {
wxWindowBase::DoSetToolTip(tip); wxWindowBase::DoSetToolTip(tip);
@@ -3182,13 +3197,13 @@ void wxWindow::DoSetToolTip( wxToolTip *tip )
m_tooltip->Apply( this ); m_tooltip->Apply( this );
} }
void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip ) void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
{ {
gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL ); gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
} }
#endif // wxUSE_TOOLTIPS #endif // wxUSE_TOOLTIPS
bool wxWindow::SetBackgroundColour( const wxColour &colour ) bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
{ {
wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
@@ -3229,7 +3244,7 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
return TRUE; return TRUE;
} }
bool wxWindow::SetForegroundColour( const wxColour &colour ) bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
{ {
wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
@@ -3259,7 +3274,7 @@ bool wxWindow::SetForegroundColour( const wxColour &colour )
return TRUE; return TRUE;
} }
GtkStyle *wxWindow::GetWidgetStyle() GtkStyle *wxWindowGTK::GetWidgetStyle()
{ {
if (m_widgetStyle) if (m_widgetStyle)
{ {
@@ -3293,7 +3308,7 @@ GtkStyle *wxWindow::GetWidgetStyle()
return m_widgetStyle; return m_widgetStyle;
} }
void wxWindow::SetWidgetStyle() void wxWindowGTK::SetWidgetStyle()
{ {
#if DISABLE_STYLE_IF_BROKEN_THEM #if DISABLE_STYLE_IF_BROKEN_THEM
if (m_widget->style->engine_data) if (m_widget->style->engine_data)
@@ -3382,7 +3397,7 @@ void wxWindow::SetWidgetStyle()
} }
} }
void wxWindow::ApplyWidgetStyle() void wxWindowGTK::ApplyWidgetStyle()
{ {
} }
@@ -3397,7 +3412,7 @@ static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting
*is_waiting = FALSE; *is_waiting = FALSE;
} }
static void SetInvokingWindow( wxMenu *menu, wxWindow *win ) static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
{ {
menu->SetInvokingWindow( win ); menu->SetInvokingWindow( win );
wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst(); wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
@@ -3418,14 +3433,14 @@ static gint gs_pop_y = 0;
static void pop_pos_callback( GtkMenu * WXUNUSED(menu), static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
gint *x, gint *y, gint *x, gint *y,
wxWindow *win ) wxWindowGTK *win )
{ {
win->ClientToScreen( &gs_pop_x, &gs_pop_y ); win->ClientToScreen( &gs_pop_x, &gs_pop_y );
*x = gs_pop_x; *x = gs_pop_x;
*y = gs_pop_y; *y = gs_pop_y;
} }
bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y ) bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
{ {
wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
@@ -3466,7 +3481,7 @@ bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
#if wxUSE_DRAG_AND_DROP #if wxUSE_DRAG_AND_DROP
void wxWindow::SetDropTarget( wxDropTarget *dropTarget ) void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3482,7 +3497,7 @@ void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
#endif // wxUSE_DRAG_AND_DROP #endif // wxUSE_DRAG_AND_DROP
GtkWidget* wxWindow::GetConnectWidget() GtkWidget* wxWindowGTK::GetConnectWidget()
{ {
GtkWidget *connect_widget = m_widget; GtkWidget *connect_widget = m_widget;
if (m_wxwindow) connect_widget = m_wxwindow; if (m_wxwindow) connect_widget = m_wxwindow;
@@ -3490,7 +3505,7 @@ GtkWidget* wxWindow::GetConnectWidget()
return connect_widget; return connect_widget;
} }
bool wxWindow::IsOwnGtkWindow( GdkWindow *window ) bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
{ {
if (m_wxwindow) if (m_wxwindow)
return (window == GTK_PIZZA(m_wxwindow)->bin_window); return (window == GTK_PIZZA(m_wxwindow)->bin_window);
@@ -3498,7 +3513,7 @@ bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
return (window == m_widget->window); return (window == m_widget->window);
} }
bool wxWindow::SetFont( const wxFont &font ) bool wxWindowGTK::SetFont( const wxFont &font )
{ {
wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
@@ -3522,7 +3537,7 @@ bool wxWindow::SetFont( const wxFont &font )
return TRUE; return TRUE;
} }
void wxWindow::CaptureMouse() void wxWindowGTK::CaptureMouse()
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3553,7 +3568,7 @@ void wxWindow::CaptureMouse()
g_captureWindowHasMouse = TRUE; g_captureWindowHasMouse = TRUE;
} }
void wxWindow::ReleaseMouse() void wxWindowGTK::ReleaseMouse()
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3569,15 +3584,15 @@ void wxWindow::ReleaseMouse()
return; return;
gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME ); gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
g_captureWindow = (wxWindow*) NULL; g_captureWindow = (wxWindowGTK*) NULL;
} }
bool wxWindow::IsRetained() const bool wxWindowGTK::IsRetained() const
{ {
return FALSE; return FALSE;
} }
void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible, void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
int range, bool refresh ) int range, bool refresh )
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3641,7 +3656,7 @@ void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" ); gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
} }
void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) ) void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3693,7 +3708,7 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
} }
} }
int wxWindow::GetScrollThumb( int orient ) const int wxWindowGTK::GetScrollThumb( int orient ) const
{ {
wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
@@ -3705,7 +3720,7 @@ int wxWindow::GetScrollThumb( int orient ) const
return (int)(m_vAdjust->page_size+0.5); return (int)(m_vAdjust->page_size+0.5);
} }
int wxWindow::GetScrollPos( int orient ) const int wxWindowGTK::GetScrollPos( int orient ) const
{ {
wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
@@ -3717,7 +3732,7 @@ int wxWindow::GetScrollPos( int orient ) const
return (int)(m_vAdjust->value+0.5); return (int)(m_vAdjust->value+0.5);
} }
int wxWindow::GetScrollRange( int orient ) const int wxWindowGTK::GetScrollRange( int orient ) const
{ {
wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
@@ -3729,7 +3744,7 @@ int wxWindow::GetScrollRange( int orient ) const
return (int)(m_vAdjust->upper+0.5); return (int)(m_vAdjust->upper+0.5);
} }
void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );

6
src/gtk1/app.cpp
View File

@@ -620,12 +620,12 @@ int wxEntryInitGui()
{ {
int retValue = 0; int retValue = 0;
if ( !wxTheApp->OnInitGui() )
retValue = -1;
wxRootWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL ); wxRootWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_realize( wxRootWindow ); gtk_widget_realize( wxRootWindow );
if ( !wxTheApp->OnInitGui() )
retValue = -1;
return retValue; return retValue;
} }

241
src/gtk1/window.cpp
View File

@@ -198,15 +198,15 @@ extern wxCursor g_globalCursor;
// mouse capture state: the window which has it and if the mouse is currently // mouse capture state: the window which has it and if the mouse is currently
// inside it // inside it
static wxWindow *g_captureWindow = (wxWindow*) NULL; static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
static bool g_captureWindowHasMouse = FALSE; static bool g_captureWindowHasMouse = FALSE;
/* extern */ wxWindow *g_focusWindow = (wxWindow*) NULL; /* extern */ wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL;
// the last window which had the focus - this is normally never NULL (except // the last window which had the focus - this is normally never NULL (except
// if we never had focus at all) as even when g_focusWindow is NULL it still // if we never had focus at all) as even when g_focusWindow is NULL it still
// keeps its previous value // keeps its previous value
static wxWindow *g_focusWindowLast = (wxWindow *)NULL; static wxWindowGTK *g_focusWindowLast = (wxWindowGTK *)NULL;
// if we detect that the app has got/lost the focus, we set this variable to // if we detect that the app has got/lost the focus, we set this variable to
// either TRUE or FALSE and an activate event will be sent during the next // either TRUE or FALSE and an activate event will be sent during the next
@@ -325,11 +325,11 @@ extern bool g_isIdle;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// returns the child of win which currently has focus or NULL if not found // returns the child of win which currently has focus or NULL if not found
static wxWindow *FindFocusedChild(wxWindow *win) static wxWindowGTK *FindFocusedChild(wxWindowGTK *win)
{ {
wxWindow *winFocus = wxWindow::FindFocus(); wxWindowGTK *winFocus = wxWindowGTK::FindFocus();
if ( !winFocus ) if ( !winFocus )
return (wxWindow *)NULL; return (wxWindowGTK *)NULL;
if ( winFocus == win ) if ( winFocus == win )
return win; return win;
@@ -338,15 +338,15 @@ static wxWindow *FindFocusedChild(wxWindow *win)
node; node;
node = node->GetNext() ) node = node->GetNext() )
{ {
wxWindow *child = FindFocusedChild(node->GetData()); wxWindowGTK *child = FindFocusedChild(node->GetData());
if ( child ) if ( child )
return child; return child;
} }
return (wxWindow *)NULL; return (wxWindowGTK *)NULL;
} }
static void draw_frame( GtkWidget *widget, wxWindow *win ) static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
{ {
if (!win->m_hasVMT) if (!win->m_hasVMT)
return; return;
@@ -435,7 +435,7 @@ static void draw_frame( GtkWidget *widget, wxWindow *win )
// "expose_event" of m_widget // "expose_event" of m_widget
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ) gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )
{ {
if (gdk_event->count > 0) return FALSE; if (gdk_event->count > 0) return FALSE;
@@ -448,7 +448,7 @@ gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_even
// "draw" of m_widget // "draw" of m_widget
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win ) static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
{ {
draw_frame( widget, win ); draw_frame( widget, win );
} }
@@ -667,7 +667,9 @@ static long map_to_wx_keysym( KeySym keysym )
// "expose_event" of m_wxwindow // "expose_event" of m_wxwindow
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ) static int gtk_window_expose_callback( GtkWidget *widget,
GdkEventExpose *gdk_event,
wxWindow *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -746,7 +748,9 @@ static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_ev
There, we look for expose events ourselves whereas all other events are There, we look for expose events ourselves whereas all other events are
handled normally. */ handled normally. */
gint gtk_window_event_event_callback( GtkWidget *widget, GdkEventExpose *event, wxWindow *win ) gint gtk_window_event_event_callback( GtkWidget *widget,
GdkEventExpose *event,
wxWindow *win )
{ {
if (event->type == GDK_EXPOSE) if (event->type == GDK_EXPOSE)
{ {
@@ -764,7 +768,7 @@ gint gtk_window_event_event_callback( GtkWidget *widget, GdkEventExpose *event,
/* This callback is a complete replacement of the gtk_pizza_draw() function, /* This callback is a complete replacement of the gtk_pizza_draw() function,
which disabled. */ which disabled. */
static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win ) static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -828,7 +832,9 @@ static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxW
// "key_press_event" from any window // "key_press_event" from any window
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win ) static gint gtk_window_key_press_callback( GtkWidget *widget,
GdkEventKey *gdk_event,
wxWindow *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -873,7 +879,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
#if wxUSE_ACCEL #if wxUSE_ACCEL
if (!ret) if (!ret)
{ {
wxWindow *ancestor = win; wxWindowGTK *ancestor = win;
while (ancestor) while (ancestor)
{ {
int command = ancestor->GetAcceleratorTable()->GetCommand( event ); int command = ancestor->GetAcceleratorTable()->GetCommand( event );
@@ -950,7 +956,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
if ( (!ret) && if ( (!ret) &&
(gdk_event->keyval == GDK_F10) ) (gdk_event->keyval == GDK_F10) )
{ {
wxWindow *ancestor = win; wxWindowGTK *ancestor = win;
while (ancestor) while (ancestor)
{ {
if (wxIsKindOf(ancestor,wxFrame)) if (wxIsKindOf(ancestor,wxFrame))
@@ -988,7 +994,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e
// "key_release_event" from any window // "key_release_event" from any window
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win ) static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1078,7 +1084,7 @@ static void AdjustEventButtonState(wxMouseEvent& event)
// "button_press_event" // "button_press_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win ) static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1181,7 +1187,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
wxNode *node = win->GetChildren().First(); wxNode *node = win->GetChildren().First();
while (node) while (node)
{ {
wxWindow *child = (wxWindow*)node->Data(); wxWindowGTK *child = (wxWindowGTK*)node->Data();
node = node->Next(); node = node->Next();
if (!child->IsShown()) if (!child->IsShown())
@@ -1252,7 +1258,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
// "button_release_event" // "button_release_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win ) static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1313,7 +1319,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
wxNode *node = win->GetChildren().First(); wxNode *node = win->GetChildren().First();
while (node) while (node)
{ {
wxWindow *child = (wxWindow*)node->Data(); wxWindowGTK *child = (wxWindowGTK*)node->Data();
node = node->Next(); node = node->Next();
if (!child->IsShown()) if (!child->IsShown())
@@ -1395,7 +1401,7 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
static gint gtk_window_motion_notify_callback( GtkWidget *widget, static gint gtk_window_motion_notify_callback( GtkWidget *widget,
GdkEventMotion *gdk_event, GdkEventMotion *gdk_event,
wxWindow *win ) wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1461,7 +1467,7 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
wxNode *node = win->GetChildren().First(); wxNode *node = win->GetChildren().First();
while (node) while (node)
{ {
wxWindow *child = (wxWindow*)node->Data(); wxWindowGTK *child = (wxWindowGTK*)node->Data();
node = node->Next(); node = node->Next();
if (!child->IsShown()) if (!child->IsShown())
@@ -1523,7 +1529,9 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget,
// "focus_in_event" // "focus_in_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win ) static gint gtk_window_focus_in_callback( GtkWidget *widget,
GdkEvent *WXUNUSED(event),
wxWindow *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1595,7 +1603,7 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(
// "focus_out_event" // "focus_out_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win ) static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1610,11 +1618,11 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
// g_sendActivateEvent to -1 // g_sendActivateEvent to -1
g_sendActivateEvent = 0; g_sendActivateEvent = 0;
wxWindow *winFocus = FindFocusedChild(win); wxWindowGTK *winFocus = FindFocusedChild(win);
if ( winFocus ) if ( winFocus )
win = winFocus; win = winFocus;
g_focusWindow = (wxWindow *)NULL; g_focusWindow = (wxWindowGTK *)NULL;
/* /*
printf( "OnKillFocus from " ); printf( "OnKillFocus from " );
@@ -1653,7 +1661,7 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED
// "enter_notify_event" // "enter_notify_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win ) static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1692,7 +1700,7 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_
// "leave_notify_event" // "leave_notify_event"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win ) static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1740,7 +1748,7 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_
// "value_changed" from m_vAdjust // "value_changed" from m_vAdjust
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win ) static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1776,7 +1784,7 @@ static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win )
// "value_changed" from m_hAdjust // "value_changed" from m_hAdjust
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win ) static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win )
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1813,7 +1821,7 @@ static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win )
static gint gtk_scrollbar_button_press_callback( GtkRange *widget, static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
GdkEventButton *gdk_event, GdkEventButton *gdk_event,
wxWindow *win) wxWindowGTK *win)
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1833,7 +1841,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
static gint gtk_scrollbar_button_release_callback( GtkRange *widget, static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
GdkEventButton *WXUNUSED(gdk_event), GdkEventButton *WXUNUSED(gdk_event),
wxWindow *win) wxWindowGTK *win)
{ {
DEBUG_MAIN_THREAD DEBUG_MAIN_THREAD
@@ -1879,7 +1887,8 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
wxWindow *wxWindowBase::FindFocus() wxWindow *wxWindowBase::FindFocus()
{ {
return g_focusWindow; // the cast is necessary when we compile in wxUniversal mode
return (wxWindow *)g_focusWindow;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -1953,7 +1962,7 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
static static
void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
GtkAllocation* WXUNUSED_UNLESS_XIM(alloc), GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
wxWindow* WXUNUSED_UNLESS_XIM(win) ) wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
{ {
if (g_isIdle) if (g_isIdle)
wxapp_install_idle_handler(); wxapp_install_idle_handler();
@@ -1982,7 +1991,7 @@ void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
static gint static gint
gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget), gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
wxWindow * WXUNUSED_UNLESS_XIM(win) ) wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
{ {
if (g_isIdle) if (g_isIdle)
wxapp_install_idle_handler(); wxapp_install_idle_handler();
@@ -2068,17 +2077,17 @@ gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// InsertChild for wxWindow. // InsertChild for wxWindowGTK.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/* Callback for wxWindow. This very strange beast has to be used because /* Callback for wxWindowGTK. This very strange beast has to be used because
* C++ has no virtual methods in a constructor. We have to emulate a * C++ has no virtual methods in a constructor. We have to emulate a
* virtual function here as wxNotebook requires a different way to insert * virtual function here as wxNotebook requires a different way to insert
* a child in it. I had opted for creating a wxNotebookPage window class * a child in it. I had opted for creating a wxNotebookPage window class
* which would have made this superfluous (such in the MDI window system), * which would have made this superfluous (such in the MDI window system),
* but no-one was listening to me... */ * but no-one was listening to me... */
static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child ) static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
{ {
/* the window might have been scrolled already, do we /* the window might have been scrolled already, do we
have to adapt the position */ have to adapt the position */
@@ -2098,18 +2107,19 @@ static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
// global functions // global functions
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
wxWindow* wxGetActiveWindow() wxWindow *wxGetActiveWindow()
{ {
return g_focusWindow; // the cast is necessary when we compile in wxUniversal mode
return (wxWindow *)g_focusWindow;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxWindow // wxWindowGTK
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase) IMPLEMENT_DYNAMIC_CLASS(wxWindowGTK, wxWindowBase)
void wxWindow::Init() void wxWindowGTK::Init()
{ {
// common init // common init
InitBase(); InitBase();
@@ -2163,28 +2173,34 @@ void wxWindow::Init()
#endif #endif
} }
wxWindow::wxWindow() wxWindowGTK::wxWindowGTK()
{ {
Init(); Init();
} }
wxWindow::wxWindow( wxWindow *parent, wxWindowID id, wxWindowGTK::wxWindowGTK( wxWindow *parent,
const wxPoint &pos, const wxSize &size, wxWindowID id,
long style, const wxString &name ) const wxPoint &pos,
const wxSize &size,
long style,
const wxString &name )
{ {
Init(); Init();
Create( parent, id, pos, size, style, name ); Create( parent, id, pos, size, style, name );
} }
bool wxWindow::Create( wxWindow *parent, wxWindowID id, bool wxWindowGTK::Create( wxWindow *parent,
const wxPoint &pos, const wxSize &size, wxWindowID id,
long style, const wxString &name ) const wxPoint &pos,
const wxSize &size,
long style,
const wxString &name )
{ {
if (!PreCreation( parent, pos, size ) || if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{ {
wxFAIL_MSG( wxT("wxWindow creation failed") ); wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
return FALSE; return FALSE;
} }
@@ -2307,7 +2323,7 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id,
return TRUE; return TRUE;
} }
wxWindow::~wxWindow() wxWindowGTK::~wxWindowGTK()
{ {
m_isBeingDeleted = TRUE; m_isBeingDeleted = TRUE;
m_hasVMT = FALSE; m_hasVMT = FALSE;
@@ -2350,7 +2366,7 @@ wxWindow::~wxWindow()
} }
} }
bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize &size ) bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
{ {
wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") ); wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
@@ -2382,7 +2398,7 @@ bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize
return TRUE; return TRUE;
} }
void wxWindow::PostCreation() void wxWindowGTK::PostCreation()
{ {
wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
@@ -2461,7 +2477,7 @@ void wxWindow::PostCreation()
m_hasVMT = TRUE; m_hasVMT = TRUE;
} }
void wxWindow::ConnectWidget( GtkWidget *widget ) void wxWindowGTK::ConnectWidget( GtkWidget *widget )
{ {
gtk_signal_connect( GTK_OBJECT(widget), "key_press_event", gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this ); GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
@@ -2485,7 +2501,7 @@ void wxWindow::ConnectWidget( GtkWidget *widget )
GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this ); GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
} }
bool wxWindow::Destroy() bool wxWindowGTK::Destroy()
{ {
wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
@@ -2494,15 +2510,15 @@ bool wxWindow::Destroy()
return wxWindowBase::Destroy(); return wxWindowBase::Destroy();
} }
void wxWindow::DoMoveWindow(int x, int y, int width, int height) void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
{ {
gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height ); gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
} }
void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags ) void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
{ {
wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
wxASSERT_MSG( (m_parent != NULL), wxT("wxWindow::SetSize requires parent.\n") ); wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
if (m_resizing) return; /* I don't like recursions */ if (m_resizing) return; /* I don't like recursions */
m_resizing = TRUE; m_resizing = TRUE;
@@ -2593,7 +2609,7 @@ void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
m_resizing = FALSE; m_resizing = FALSE;
} }
void wxWindow::OnInternalIdle() void wxWindowGTK::OnInternalIdle()
{ {
if ( g_sendActivateEvent != -1 ) if ( g_sendActivateEvent != -1 )
{ {
@@ -2602,7 +2618,7 @@ void wxWindow::OnInternalIdle()
// do it only once // do it only once
g_sendActivateEvent = -1; g_sendActivateEvent = -1;
wxTheApp->SetActive(activate, g_focusWindowLast); wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
wxActivateEvent event(wxEVT_ACTIVATE, activate, GetId()); wxActivateEvent event(wxEVT_ACTIVATE, activate, GetId());
event.SetEventObject(this); event.SetEventObject(this);
@@ -2647,7 +2663,7 @@ void wxWindow::OnInternalIdle()
UpdateWindowUI(); UpdateWindowUI();
} }
void wxWindow::DoGetSize( int *width, int *height ) const void wxWindowGTK::DoGetSize( int *width, int *height ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2655,7 +2671,7 @@ void wxWindow::DoGetSize( int *width, int *height ) const
if (height) (*height) = m_height; if (height) (*height) = m_height;
} }
void wxWindow::DoSetClientSize( int width, int height ) void wxWindowGTK::DoSetClientSize( int width, int height )
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2718,7 +2734,7 @@ void wxWindow::DoSetClientSize( int width, int height )
} }
} }
void wxWindow::DoGetClientSize( int *width, int *height ) const void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2783,7 +2799,7 @@ void wxWindow::DoGetClientSize( int *width, int *height ) const
} }
} }
void wxWindow::DoGetPosition( int *x, int *y ) const void wxWindowGTK::DoGetPosition( int *x, int *y ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2800,7 +2816,7 @@ void wxWindow::DoGetPosition( int *x, int *y ) const
if (y) (*y) = m_y - dy; if (y) (*y) = m_y - dy;
} }
void wxWindow::DoClientToScreen( int *x, int *y ) const void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2829,7 +2845,7 @@ void wxWindow::DoClientToScreen( int *x, int *y ) const
if (y) *y += org_y; if (y) *y += org_y;
} }
void wxWindow::DoScreenToClient( int *x, int *y ) const void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2858,7 +2874,7 @@ void wxWindow::DoScreenToClient( int *x, int *y ) const
if (y) *y -= org_y; if (y) *y -= org_y;
} }
bool wxWindow::Show( bool show ) bool wxWindowGTK::Show( bool show )
{ {
wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
@@ -2876,7 +2892,7 @@ bool wxWindow::Show( bool show )
return TRUE; return TRUE;
} }
bool wxWindow::Enable( bool enable ) bool wxWindowGTK::Enable( bool enable )
{ {
wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
@@ -2893,7 +2909,7 @@ bool wxWindow::Enable( bool enable )
return TRUE; return TRUE;
} }
int wxWindow::GetCharHeight() const int wxWindowGTK::GetCharHeight() const
{ {
wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
@@ -2904,7 +2920,7 @@ int wxWindow::GetCharHeight() const
return font->ascent + font->descent; return font->ascent + font->descent;
} }
int wxWindow::GetCharWidth() const int wxWindowGTK::GetCharWidth() const
{ {
wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
@@ -2915,7 +2931,7 @@ int wxWindow::GetCharWidth() const
return gdk_string_width( font, "H" ); return gdk_string_width( font, "H" );
} }
void wxWindow::GetTextExtent( const wxString& string, void wxWindowGTK::GetTextExtent( const wxString& string,
int *x, int *x,
int *y, int *y,
int *descent, int *descent,
@@ -2934,7 +2950,7 @@ void wxWindow::GetTextExtent( const wxString& string,
if (externalLeading) (*externalLeading) = 0; // ?? if (externalLeading) (*externalLeading) = 0; // ??
} }
void wxWindow::SetFocus() void wxWindowGTK::SetFocus()
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -2962,17 +2978,17 @@ void wxWindow::SetFocus()
} }
} }
bool wxWindow::AcceptsFocus() const bool wxWindowGTK::AcceptsFocus() const
{ {
return m_acceptsFocus && wxWindowBase::AcceptsFocus(); return m_acceptsFocus && wxWindowBase::AcceptsFocus();
} }
bool wxWindow::Reparent( wxWindowBase *newParentBase ) bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
{ {
wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
wxWindow *oldParent = m_parent, wxWindowGTK *oldParent = m_parent,
*newParent = (wxWindow *)newParentBase; *newParent = (wxWindowGTK *)newParentBase;
wxASSERT( GTK_IS_WIDGET(m_widget) ); wxASSERT( GTK_IS_WIDGET(m_widget) );
@@ -3003,7 +3019,7 @@ bool wxWindow::Reparent( wxWindowBase *newParentBase )
return TRUE; return TRUE;
} }
void wxWindow::DoAddChild(wxWindow *child) void wxWindowGTK::DoAddChild(wxWindowGTK *child)
{ {
wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
@@ -3018,7 +3034,7 @@ void wxWindow::DoAddChild(wxWindow *child)
(*m_insertCallback)(this, child); (*m_insertCallback)(this, child);
} }
void wxWindow::Raise() void wxWindowGTK::Raise()
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -3027,7 +3043,7 @@ void wxWindow::Raise()
gdk_window_raise( m_widget->window ); gdk_window_raise( m_widget->window );
} }
void wxWindow::Lower() void wxWindowGTK::Lower()
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -3036,7 +3052,7 @@ void wxWindow::Lower()
gdk_window_lower( m_widget->window ); gdk_window_lower( m_widget->window );
} }
bool wxWindow::SetCursor( const wxCursor &cursor ) bool wxWindowGTK::SetCursor( const wxCursor &cursor )
{ {
wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
@@ -3052,7 +3068,7 @@ bool wxWindow::SetCursor( const wxCursor &cursor )
return wxWindowBase::SetCursor( cursor ); return wxWindowBase::SetCursor( cursor );
} }
void wxWindow::WarpPointer( int x, int y ) void wxWindowGTK::WarpPointer( int x, int y )
{ {
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
@@ -3069,7 +3085,7 @@ void wxWindow::WarpPointer( int x, int y )
gdk_window_warp_pointer( window, x, y ); gdk_window_warp_pointer( window, x, y );
} }
void wxWindow::Refresh( bool eraseBackground, const wxRect *rect ) void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
{ {
if (!m_widget) return; if (!m_widget) return;
if (!m_widget->window) return; if (!m_widget->window) return;
@@ -3111,8 +3127,7 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
gdk_event.area.y = 0; gdk_event.area.y = 0;
gdk_event.area.width = m_wxwindow->allocation.width; gdk_event.area.width = m_wxwindow->allocation.width;
gdk_event.area.height = m_wxwindow->allocation.height; gdk_event.area.height = m_wxwindow->allocation.height;
gtk_window_expose_callback( m_wxwindow, &gdk_event, this ); gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );
} }
else else
{ {
@@ -3147,7 +3162,7 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
gdk_event.area.y = rect->y; gdk_event.area.y = rect->y;
gdk_event.area.width = rect->width; gdk_event.area.width = rect->width;
gdk_event.area.height = rect->height; gdk_event.area.height = rect->height;
gtk_window_expose_callback( m_wxwindow, &gdk_event, this ); gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );
} }
else else
{ {
@@ -3161,7 +3176,7 @@ void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
} }
} }
void wxWindow::Clear() void wxWindowGTK::Clear()
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3174,7 +3189,7 @@ void wxWindow::Clear()
} }
#if wxUSE_TOOLTIPS #if wxUSE_TOOLTIPS
void wxWindow::DoSetToolTip( wxToolTip *tip ) void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
{ {
wxWindowBase::DoSetToolTip(tip); wxWindowBase::DoSetToolTip(tip);
@@ -3182,13 +3197,13 @@ void wxWindow::DoSetToolTip( wxToolTip *tip )
m_tooltip->Apply( this ); m_tooltip->Apply( this );
} }
void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip ) void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
{ {
gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL ); gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
} }
#endif // wxUSE_TOOLTIPS #endif // wxUSE_TOOLTIPS
bool wxWindow::SetBackgroundColour( const wxColour &colour ) bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
{ {
wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
@@ -3229,7 +3244,7 @@ bool wxWindow::SetBackgroundColour( const wxColour &colour )
return TRUE; return TRUE;
} }
bool wxWindow::SetForegroundColour( const wxColour &colour ) bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
{ {
wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
@@ -3259,7 +3274,7 @@ bool wxWindow::SetForegroundColour( const wxColour &colour )
return TRUE; return TRUE;
} }
GtkStyle *wxWindow::GetWidgetStyle() GtkStyle *wxWindowGTK::GetWidgetStyle()
{ {
if (m_widgetStyle) if (m_widgetStyle)
{ {
@@ -3293,7 +3308,7 @@ GtkStyle *wxWindow::GetWidgetStyle()
return m_widgetStyle; return m_widgetStyle;
} }
void wxWindow::SetWidgetStyle() void wxWindowGTK::SetWidgetStyle()
{ {
#if DISABLE_STYLE_IF_BROKEN_THEM #if DISABLE_STYLE_IF_BROKEN_THEM
if (m_widget->style->engine_data) if (m_widget->style->engine_data)
@@ -3382,7 +3397,7 @@ void wxWindow::SetWidgetStyle()
} }
} }
void wxWindow::ApplyWidgetStyle() void wxWindowGTK::ApplyWidgetStyle()
{ {
} }
@@ -3397,7 +3412,7 @@ static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting
*is_waiting = FALSE; *is_waiting = FALSE;
} }
static void SetInvokingWindow( wxMenu *menu, wxWindow *win ) static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
{ {
menu->SetInvokingWindow( win ); menu->SetInvokingWindow( win );
wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst(); wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
@@ -3418,14 +3433,14 @@ static gint gs_pop_y = 0;
static void pop_pos_callback( GtkMenu * WXUNUSED(menu), static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
gint *x, gint *y, gint *x, gint *y,
wxWindow *win ) wxWindowGTK *win )
{ {
win->ClientToScreen( &gs_pop_x, &gs_pop_y ); win->ClientToScreen( &gs_pop_x, &gs_pop_y );
*x = gs_pop_x; *x = gs_pop_x;
*y = gs_pop_y; *y = gs_pop_y;
} }
bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y ) bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
{ {
wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
@@ -3466,7 +3481,7 @@ bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
#if wxUSE_DRAG_AND_DROP #if wxUSE_DRAG_AND_DROP
void wxWindow::SetDropTarget( wxDropTarget *dropTarget ) void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3482,7 +3497,7 @@ void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
#endif // wxUSE_DRAG_AND_DROP #endif // wxUSE_DRAG_AND_DROP
GtkWidget* wxWindow::GetConnectWidget() GtkWidget* wxWindowGTK::GetConnectWidget()
{ {
GtkWidget *connect_widget = m_widget; GtkWidget *connect_widget = m_widget;
if (m_wxwindow) connect_widget = m_wxwindow; if (m_wxwindow) connect_widget = m_wxwindow;
@@ -3490,7 +3505,7 @@ GtkWidget* wxWindow::GetConnectWidget()
return connect_widget; return connect_widget;
} }
bool wxWindow::IsOwnGtkWindow( GdkWindow *window ) bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
{ {
if (m_wxwindow) if (m_wxwindow)
return (window == GTK_PIZZA(m_wxwindow)->bin_window); return (window == GTK_PIZZA(m_wxwindow)->bin_window);
@@ -3498,7 +3513,7 @@ bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
return (window == m_widget->window); return (window == m_widget->window);
} }
bool wxWindow::SetFont( const wxFont &font ) bool wxWindowGTK::SetFont( const wxFont &font )
{ {
wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
@@ -3522,7 +3537,7 @@ bool wxWindow::SetFont( const wxFont &font )
return TRUE; return TRUE;
} }
void wxWindow::CaptureMouse() void wxWindowGTK::CaptureMouse()
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3553,7 +3568,7 @@ void wxWindow::CaptureMouse()
g_captureWindowHasMouse = TRUE; g_captureWindowHasMouse = TRUE;
} }
void wxWindow::ReleaseMouse() void wxWindowGTK::ReleaseMouse()
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3569,15 +3584,15 @@ void wxWindow::ReleaseMouse()
return; return;
gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME ); gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
g_captureWindow = (wxWindow*) NULL; g_captureWindow = (wxWindowGTK*) NULL;
} }
bool wxWindow::IsRetained() const bool wxWindowGTK::IsRetained() const
{ {
return FALSE; return FALSE;
} }
void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible, void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
int range, bool refresh ) int range, bool refresh )
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3641,7 +3656,7 @@ void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" ); gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
} }
void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) ) void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
@@ -3693,7 +3708,7 @@ void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
} }
} }
int wxWindow::GetScrollThumb( int orient ) const int wxWindowGTK::GetScrollThumb( int orient ) const
{ {
wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
@@ -3705,7 +3720,7 @@ int wxWindow::GetScrollThumb( int orient ) const
return (int)(m_vAdjust->page_size+0.5); return (int)(m_vAdjust->page_size+0.5);
} }
int wxWindow::GetScrollPos( int orient ) const int wxWindowGTK::GetScrollPos( int orient ) const
{ {
wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
@@ -3717,7 +3732,7 @@ int wxWindow::GetScrollPos( int orient ) const
return (int)(m_vAdjust->value+0.5); return (int)(m_vAdjust->value+0.5);
} }
int wxWindow::GetScrollRange( int orient ) const int wxWindowGTK::GetScrollRange( int orient ) const
{ {
wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
@@ -3729,7 +3744,7 @@ int wxWindow::GetScrollRange( int orient ) const
return (int)(m_vAdjust->upper+0.5); return (int)(m_vAdjust->upper+0.5);
} }
void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
{ {
wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); wxCHECK_RET( m_widget != NULL, wxT("invalid window") );

143
src/univ/control.cpp
View File

@@ -53,9 +53,6 @@ BEGIN_EVENT_TABLE(wxControl, wxControlBase)
EVT_SET_FOCUS(wxControl::OnFocus) EVT_SET_FOCUS(wxControl::OnFocus)
EVT_KILL_FOCUS(wxControl::OnFocus) EVT_KILL_FOCUS(wxControl::OnFocus)
EVT_PAINT(wxControl::OnPaint)
EVT_ERASE_BACKGROUND(wxControl::OnErase)
END_EVENT_TABLE() END_EVENT_TABLE()
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -65,7 +62,6 @@ END_EVENT_TABLE()
void wxControl::Init() void wxControl::Init()
{ {
m_indexAccel = -1; m_indexAccel = -1;
m_isCurrent = FALSE;
} }
bool wxControl::Create(wxWindow *parent, bool wxControl::Create(wxWindow *parent,
@@ -86,70 +82,6 @@ bool wxControl::Create(wxWindow *parent,
return TRUE; return TRUE;
} }
// ----------------------------------------------------------------------------
// state flags
// ----------------------------------------------------------------------------
bool wxControl::IsFocused() const
{
wxControl *self = wxConstCast(this, wxControl);
return self->FindFocus() == self;
}
bool wxControl::IsPressed() const
{
return FALSE;
}
bool wxControl::IsDefault() const
{
return FALSE;
}
bool wxControl::IsCurrent() const
{
return m_isCurrent;
}
void wxControl::SetCurrent(bool doit)
{
m_isCurrent = doit;
}
int wxControl::GetStateFlags() const
{
int flags = 0;
if ( !IsEnabled() )
flags |= wxCONTROL_DISABLED;
// the following states are only possible if our application is active - if
// it is not, even our default/focused controls shouldn't appear as such
if ( wxTheApp->IsActive() )
{
if ( IsCurrent() )
flags |= wxCONTROL_CURRENT;
if ( IsFocused() )
flags |= wxCONTROL_FOCUSED;
if ( IsPressed() )
flags |= wxCONTROL_PRESSED;
if ( IsDefault() )
flags |= wxCONTROL_ISDEFAULT;
}
return flags;
}
// ----------------------------------------------------------------------------
// size
// ----------------------------------------------------------------------------
wxSize wxControl::AdjustSize(const wxSize& size) const
{
wxSize sz = size;
wxTheme::Get()->GetRenderer()->AdjustSize(&sz, this);
return sz;
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// mnemonics handling // mnemonics handling
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -197,81 +129,6 @@ wxString wxControl::GetLabel() const
return m_label; return m_label;
} }
// ----------------------------------------------------------------------------
// background pixmap
// ----------------------------------------------------------------------------
void wxControl::SetBackground(const wxBitmap& bitmap,
int alignment,
wxStretch stretch)
{
m_bitmapBg = bitmap;
m_alignBgBitmap = alignment;
m_stretchBgBitmap = stretch;
}
const wxBitmap& wxControl::GetBackgroundBitmap(int *alignment,
wxStretch *stretch) const
{
if ( m_bitmapBg.Ok() )
{
if ( alignment )
*alignment = m_alignBgBitmap;
if ( stretch )
*stretch = m_stretchBgBitmap;
}
return m_bitmapBg;
}
// ----------------------------------------------------------------------------
// painting
// ----------------------------------------------------------------------------
wxRenderer *wxControl::GetRenderer() const
{
return wxTheme::Get()->GetRenderer();
}
// the event handler executed when the window background must be painted
void wxControl::OnErase(wxEraseEvent& event)
{
wxControlRenderer renderer(this, *event.GetDC(),
wxTheme::Get()->GetRenderer());
if ( !DoDrawBackground(&renderer) )
{
// not processed
event.Skip();
}
}
// the event handler executed when the window must be repainted
void wxControl::OnPaint(wxPaintEvent& event)
{
// get the DC to use and create renderer on it
wxPaintDC dc(this);
wxControlRenderer renderer(this, dc, GetRenderer());
// do draw the control!
DoDraw(&renderer);
}
bool wxControl::DoDrawBackground(wxControlRenderer *renderer)
{
if ( !m_bitmapBg.Ok() )
return FALSE;
renderer->DrawBackgroundBitmap();
return TRUE;
}
void wxControl::DoDraw(wxControlRenderer *renderer)
{
renderer->DrawBorder();
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// focus handling // focus handling
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

6
src/univ/files.lst
View File

@@ -12,7 +12,8 @@ UNIVOBJS = \
stattext.o \ stattext.o \
theme.o \ theme.o \
gtk.o \ gtk.o \
win32.o win32.o \
winuniv.o
UNIVDEPS = \ UNIVDEPS = \
bmpbuttn.d \ bmpbuttn.d \
@@ -28,4 +29,5 @@ UNIVDEPS = \
stattext.d \ stattext.d \
theme.d \ theme.d \
gtk.d \ gtk.d \
win32.d win32.d \
winuniv.d

71
src/univ/renderer.cpp
View File

@@ -43,6 +43,29 @@
// implementation // implementation
// ============================================================================ // ============================================================================
// ----------------------------------------------------------------------------
// wxRenderer: drawing helpers
// ----------------------------------------------------------------------------
void wxRenderer::StandardDrawFrame(wxDC& dc,
const wxRect& rectFrame,
const wxRect& rectLabel)
{
// draw left, bottom and right lines entirely
DrawVerticalLine(dc, rectFrame.GetLeft(),
rectFrame.GetTop(), rectFrame.GetBottom() - 2);
DrawHorizontalLine(dc, rectFrame.GetBottom() - 1,
rectFrame.GetLeft(), rectFrame.GetRight());
DrawVerticalLine(dc, rectFrame.GetRight() - 1,
rectFrame.GetTop(), rectFrame.GetBottom() - 1);
// and 2 parts of the top line
DrawHorizontalLine(dc, rectFrame.GetTop(),
rectFrame.GetLeft() + 1, rectLabel.GetLeft());
DrawHorizontalLine(dc, rectFrame.GetTop(),
rectLabel.GetRight(), rectFrame.GetRight() - 2);
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxRenderer: scrollbar geometry // wxRenderer: scrollbar geometry
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -173,15 +196,15 @@ wxRenderer::~wxRenderer()
// wxControlRenderer // wxControlRenderer
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxControlRenderer::wxControlRenderer(wxControl *control, wxControlRenderer::wxControlRenderer(wxWindow *window,
wxDC& dc, wxDC& dc,
wxRenderer *renderer) wxRenderer *renderer)
: m_dc(dc) : m_dc(dc)
{ {
m_ctrl = control; m_window = window;
m_renderer = renderer; m_renderer = renderer;
wxSize size = m_ctrl->GetSize(); wxSize size = m_window->GetSize();
m_rect.x = m_rect.x =
m_rect.y = 0; m_rect.y = 0;
m_rect.width = size.x; m_rect.width = size.x;
@@ -190,10 +213,10 @@ wxControlRenderer::wxControlRenderer(wxControl *control,
void wxControlRenderer::DrawBorder() void wxControlRenderer::DrawBorder()
{ {
int flags = m_ctrl->GetStateFlags(); int flags = m_window->GetStateFlags();
// draw outline // draw outline
m_renderer->DrawBorder(m_dc, m_ctrl->GetBorder(), m_renderer->DrawBorder(m_dc, m_window->GetBorder(),
m_rect, flags, &m_rect); m_rect, flags, &m_rect);
// fill the inside (TODO: query the theme for bg bitmap) // fill the inside (TODO: query the theme for bg bitmap)
@@ -203,10 +226,10 @@ void wxControlRenderer::DrawBorder()
void wxControlRenderer::DrawLabel(const wxBitmap& bitmap, void wxControlRenderer::DrawLabel(const wxBitmap& bitmap,
wxCoord marginX, wxCoord marginY) wxCoord marginX, wxCoord marginY)
{ {
m_dc.SetFont(m_ctrl->GetFont()); m_dc.SetFont(m_window->GetFont());
m_dc.SetTextForeground(m_ctrl->GetForegroundColour()); m_dc.SetTextForeground(m_window->GetForegroundColour());
wxString label = m_ctrl->GetLabel(); wxString label = m_window->GetLabel();
if ( !label.empty() || bitmap.Ok() ) if ( !label.empty() || bitmap.Ok() )
{ {
wxRect rectLabel = m_rect; wxRect rectLabel = m_rect;
@@ -215,33 +238,37 @@ void wxControlRenderer::DrawLabel(const wxBitmap& bitmap,
rectLabel.Inflate(-marginX, -marginY); rectLabel.Inflate(-marginX, -marginY);
} }
wxControl *ctrl = wxStaticCast(m_window, wxControl);
m_renderer->DrawLabel(m_dc, m_renderer->DrawLabel(m_dc,
label, label,
bitmap, bitmap,
rectLabel, rectLabel,
m_ctrl->GetStateFlags(), m_window->GetStateFlags(),
m_ctrl->GetAlignment(), ctrl->GetAlignment(),
m_ctrl->GetAccelIndex()); ctrl->GetAccelIndex());
} }
} }
void wxControlRenderer::DrawFrame() void wxControlRenderer::DrawFrame()
{ {
m_dc.SetFont(m_ctrl->GetFont()); m_dc.SetFont(m_window->GetFont());
m_dc.SetTextForeground(m_ctrl->GetForegroundColour()); m_dc.SetTextForeground(m_window->GetForegroundColour());
m_dc.SetTextBackground(m_ctrl->GetBackgroundColour()); m_dc.SetTextBackground(m_window->GetBackgroundColour());
wxControl *ctrl = wxStaticCast(m_window, wxControl);
m_renderer->DrawFrame(m_dc, m_renderer->DrawFrame(m_dc,
m_ctrl->GetLabel(), m_window->GetLabel(),
m_rect, m_rect,
m_ctrl->GetStateFlags(), m_window->GetStateFlags(),
m_ctrl->GetAlignment(), ctrl->GetAlignment(),
m_ctrl->GetAccelIndex()); ctrl->GetAccelIndex());
} }
void wxControlRenderer::DrawButtonBorder() void wxControlRenderer::DrawButtonBorder()
{ {
int flags = m_ctrl->GetStateFlags(); int flags = m_window->GetStateFlags();
m_renderer->DrawButtonBorder(m_dc, m_rect, flags, &m_rect); m_renderer->DrawButtonBorder(m_dc, m_rect, flags, &m_rect);
@@ -250,7 +277,7 @@ void wxControlRenderer::DrawButtonBorder()
void wxControlRenderer::DrawBitmap(const wxBitmap& bitmap) void wxControlRenderer::DrawBitmap(const wxBitmap& bitmap)
{ {
int style = m_ctrl->GetWindowStyle(); int style = m_window->GetWindowStyle();
DrawBitmap(bitmap, m_rect, DrawBitmap(bitmap, m_rect,
style & wxALIGN_MASK, style & wxALIGN_MASK,
style & wxBI_EXPAND ? wxEXPAND : wxSTRETCH_NOT); style & wxBI_EXPAND ? wxEXPAND : wxSTRETCH_NOT);
@@ -261,7 +288,7 @@ void wxControlRenderer::DrawBackgroundBitmap()
// get the bitmap and the flags // get the bitmap and the flags
int alignment; int alignment;
wxStretch stretch; wxStretch stretch;
wxBitmap bmp = m_ctrl->GetBackgroundBitmap(&alignment, &stretch); wxBitmap bmp = m_window->GetBackgroundBitmap(&alignment, &stretch);
DrawBitmap(bmp, m_rect, alignment, stretch); DrawBitmap(bmp, m_rect, alignment, stretch);
} }
@@ -355,7 +382,7 @@ void wxControlRenderer::DrawScrollbar(const wxScrollBar *scrollbar)
} }
m_renderer->DrawScrollbar(m_dc, m_renderer->DrawScrollbar(m_dc,
m_ctrl->GetWindowStyle() & wxVERTICAL m_window->GetWindowStyle() & wxVERTICAL
? wxVERTICAL ? wxVERTICAL
: wxHORIZONTAL, : wxHORIZONTAL,
thumbStart, thumbEnd, m_rect, thumbStart, thumbEnd, m_rect,

37
src/univ/themes/gtk.cpp
View File

@@ -535,32 +535,33 @@ void wxGTKRenderer::DrawFrame(wxDC& dc,
dc.GetTextExtent(label, NULL, &height); dc.GetTextExtent(label, NULL, &height);
rectFrame.y += height / 2; rectFrame.y += height / 2;
rectFrame.height -= height / 2; rectFrame.height -= height / 2;
}
// draw the frame // TODO: the +4 should be customizable
DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
// and overwrite it with label (if any)
if ( !label.empty() )
{
// TODO: the +2 should be customizable
wxRect rectText; wxRect rectText;
rectText.x = rectFrame.x + 2; rectText.x = rectFrame.x + 4;
rectText.y = rect.y; rectText.y = rect.y;
rectText.width = rectFrame.width - 4; // +2 border width rectText.width = rectFrame.width - 8;
rectText.height = height; rectText.height = height;
dc.SetBackgroundMode(wxSOLID); wxRect rectLabel;
DrawLabel(dc, label, wxNullBitmap, rectText, DrawLabel(dc, label, wxNullBitmap,
flags, alignment, indexAccel); rectText, flags, alignment, indexAccel, &rectLabel);
dc.SetBackgroundMode(wxTRANSPARENT); rectLabel.x -= 1;
rectLabel.width += 2;
// GTK+ does this - don't know if this is intentional or not StandardDrawFrame(dc, rectFrame, rectLabel);
// GTK+ does it like this
dc.SetPen(m_penHighlight); dc.SetPen(m_penHighlight);
dc.DrawPoint(rectFrame.GetPosition()); dc.DrawPoint(rectText.x, rectFrame.y);
dc.DrawPoint(rectFrame.x + rectText.width, rectFrame.y); dc.DrawPoint(rectText.x + rectLabel.width - 3, rectFrame.y);
}
else
{
// just draw the complete frame
DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
} }
} }

14
src/univ/themes/win32.cpp
View File

@@ -803,19 +803,7 @@ void wxWin32Renderer::DrawFrame(wxDC& dc,
DrawLabel(dc, label2, wxNullBitmap, DrawLabel(dc, label2, wxNullBitmap,
rectText, flags, alignment, indexAccel, &rectLabel); rectText, flags, alignment, indexAccel, &rectLabel);
// draw left, bottom and right lines entirely StandardDrawFrame(dc, rectFrame, rectLabel);
DrawVerticalLine(dc, rectFrame.GetLeft(),
rectFrame.GetTop(), rectFrame.GetBottom() - 2);
DrawHorizontalLine(dc, rectFrame.GetBottom() - 1,
rectFrame.GetLeft(), rectFrame.GetRight());
DrawVerticalLine(dc, rectFrame.GetRight() - 1,
rectFrame.GetTop(), rectFrame.GetBottom() - 1);
// and 2 parts of the top line
DrawHorizontalLine(dc, rectFrame.GetTop(),
rectFrame.GetLeft() + 1, rectLabel.GetLeft());
DrawHorizontalLine(dc, rectFrame.GetTop(),
rectLabel.GetRight(), rectFrame.GetRight() - 2);
} }
else else
{ {

206
src/univ/winuniv.cpp
View File

@@ -29,8 +29,8 @@
#endif #endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/app.h"
#include "wx/window.h" #include "wx/window.h"
#include "wx/dc.h"
#include "wx/dcclient.h" #include "wx/dcclient.h"
#include "wx/event.h" #include "wx/event.h"
#endif // WX_PRECOMP #endif // WX_PRECOMP
@@ -38,44 +38,202 @@
#include "wx/univ/renderer.h" #include "wx/univ/renderer.h"
#include "wx/univ/theme.h" #include "wx/univ/theme.h"
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
// we don't have any objects of type wxWindowBase so this cast is always safe
#define self ((wxWindow *)this)
// ============================================================================ // ============================================================================
// implementation // implementation
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// drawing // event tables
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// the event handler executed when the window must be repainted IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
void wxWindowBase::OnPaint(wxPaintEvent& event)
BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
EVT_PAINT(wxWindow::OnPaint)
EVT_ERASE_BACKGROUND(wxWindow::OnErase)
END_EVENT_TABLE()
// ----------------------------------------------------------------------------
// creation
// ----------------------------------------------------------------------------
void wxWindow::Init()
{ {
// get the renderer and the DC to use m_scrollbarVert =
wxWindowRenderer renderer = wxTheme::Get()->GetRenderer(); m_scrollbarHorz = (wxScrollBar *)NULL;
wxPaintDC dc(self);
// draw the border m_isCurrent = FALSE;
DoDrawBorder(dc, renderer);
// draw the control
DoDraw(dc, renderer);
} }
// draw the border // ----------------------------------------------------------------------------
void wxWindowBase::DoDrawBorder(wxDC& dc, wxRenderer *renderer) // background pixmap
// ----------------------------------------------------------------------------
void wxWindow::SetBackground(const wxBitmap& bitmap,
int alignment,
wxStretch stretch)
{ {
if ( !IsTopLevel() && !(m_windowStyle & wxNO_BORDER) ) m_bitmapBg = bitmap;
m_alignBgBitmap = alignment;
m_stretchBgBitmap = stretch;
}
const wxBitmap& wxWindow::GetBackgroundBitmap(int *alignment,
wxStretch *stretch) const
{
if ( m_bitmapBg.Ok() )
{ {
renderer->DrawBorder(dc, self); if ( alignment )
*alignment = m_alignBgBitmap;
if ( stretch )
*stretch = m_stretchBgBitmap;
}
return m_bitmapBg;
}
// ----------------------------------------------------------------------------
// painting
// ----------------------------------------------------------------------------
wxRenderer *wxWindow::GetRenderer() const
{
return wxTheme::Get()->GetRenderer();
}
// the event handler executed when the window background must be painted
void wxWindow::OnErase(wxEraseEvent& event)
{
wxControlRenderer renderer(this, *event.GetDC(),
wxTheme::Get()->GetRenderer());
if ( !DoDrawBackground(&renderer) )
{
// not processed
event.Skip();
} }
} }
void wxWindowBase::DoDraw(wxDC& dc, wxRenderer *renderer) // the event handler executed when the window must be repainted
void wxWindow::OnPaint(wxPaintEvent& event)
{ {
// get the DC to use and create renderer on it
wxPaintDC dc(this);
wxControlRenderer renderer(this, dc, GetRenderer());
// do draw the control!
DoDraw(&renderer);
} }
bool wxWindow::DoDrawBackground(wxControlRenderer *renderer)
{
if ( !m_bitmapBg.Ok() )
return FALSE;
renderer->DrawBackgroundBitmap();
return TRUE;
}
void wxWindow::DoDraw(wxControlRenderer *renderer)
{
renderer->DrawBorder();
}
// ----------------------------------------------------------------------------
// state flags
// ----------------------------------------------------------------------------
bool wxWindow::IsFocused() const
{
wxWindow *self = wxConstCast(this, wxWindow);
return self->FindFocus() == self;
}
bool wxWindow::IsPressed() const
{
return FALSE;
}
bool wxWindow::IsDefault() const
{
return FALSE;
}
bool wxWindow::IsCurrent() const
{
return m_isCurrent;
}
void wxWindow::SetCurrent(bool doit)
{
m_isCurrent = doit;
}
int wxWindow::GetStateFlags() const
{
int flags = 0;
if ( !IsEnabled() )
flags |= wxCONTROL_DISABLED;
// the following states are only possible if our application is active - if
// it is not, even our default/focused controls shouldn't appear as such
if ( wxTheApp->IsActive() )
{
if ( IsCurrent() )
flags |= wxCONTROL_CURRENT;
if ( IsFocused() )
flags |= wxCONTROL_FOCUSED;
if ( IsPressed() )
flags |= wxCONTROL_PRESSED;
if ( IsDefault() )
flags |= wxCONTROL_ISDEFAULT;
}
return flags;
}
// ----------------------------------------------------------------------------
// size
// ----------------------------------------------------------------------------
wxSize wxWindow::AdjustSize(const wxSize& size) const
{
wxSize sz = size;
wxTheme::Get()->GetRenderer()->AdjustSize(&sz, this);
return sz;
}
// ----------------------------------------------------------------------------
// scrolling
// ----------------------------------------------------------------------------
void wxWindow::SetScrollbar(int orient,
int pos,
int thumb,
int range,
bool refresh)
{
return wxWindowNative::SetScrollbar(orient, pos, thumb, range, refresh);
}
void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
{
return wxWindowNative::SetScrollPos(orient, pos, refresh);
}
int wxWindow::GetScrollPos(int orient) const
{
return wxWindowNative::GetScrollPos(orient);
}
int wxWindow::GetScrollThumb(int orient) const
{
return wxWindowNative::GetScrollThumb(orient);
}
int wxWindow::GetScrollRange(int orient) const
{
return wxWindowNative::GetScrollRange(orient);
}