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

wxWindow split into wxWindowBase and wxWindow (wxGTK part)

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2383 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-05-09 22:17:03 +00:00
parent 358d140ac9
commit f03fc89fff
101 changed files with 6352 additions and 7343 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/wx/control.h
View File

@@ -1,6 +1,9 @@
#ifndef _WX_CONTROL_H_BASE_
#define _WX_CONTROL_H_BASE_
// all classes derived from wxControl need the validators
#include "wx/validate.h"
#if defined(__WXMSW__)
#include "wx/msw/control.h"
#elif defined(__WXMOTIF__)

8
include/wx/defs.h
View File

@@ -1106,7 +1106,8 @@ typedef int (__stdcall *WXFARPROC)();
typedef int (*WXFARPROC)();
#endif
#endif
typedef WXHWND WXWidget;
#endif // MSW
#ifdef __WXMOTIF__
/* Stand-ins for X/Xt/Motif types */
@@ -1125,7 +1126,7 @@ typedef void* WXFont;
typedef void* WXImage;
typedef void* WXCursor;
typedef void* WXFontList;
#endif
#endif // Motif
#ifdef __WXGTK__
/* Stand-ins for GLIB types */
@@ -1160,7 +1161,8 @@ typedef struct _GtkAccelGroup GtkAccelGroup;
typedef struct _GtkItemFactory GtkItemFactory;
typedef struct _GtkSelectionData GtkSelectionData;
#endif
typedef GtkWidget *WXWidget;
#endif // GTK
// This is required because of clashing macros in windows.h, which may be
// included before or after wxWindows classes, and therefore must be

336
include/wx/gdicmn.h
View File

@@ -12,6 +12,10 @@
#ifndef _WX_GDICMNH__
#define _WX_GDICMNH__
// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------
#ifdef __GNUG__
#pragma interface "gdicmn.h"
#endif
@@ -23,10 +27,55 @@
#include "wx/setup.h"
#include "wx/colour.h"
// ---------------------------------------------------------------------------
// forward declarations
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxBitmap;
class WXDLLEXPORT wxBrush;
class WXDLLEXPORT wxColour;
class WXDLLEXPORT wxCursor;
class WXDLLEXPORT wxFont;
class WXDLLEXPORT wxIcon;
class WXDLLEXPORT wxPalette;
class WXDLLEXPORT wxPen;
class WXDLLEXPORT wxRegion;
class WXDLLEXPORT wxString;
// ---------------------------------------------------------------------------
// constants
// ---------------------------------------------------------------------------
// Bitmap flags
enum
{
wxBITMAP_TYPE_BMP = 1,
wxBITMAP_TYPE_BMP_RESOURCE,
wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
wxBITMAP_TYPE_ICO,
wxBITMAP_TYPE_ICO_RESOURCE,
wxBITMAP_TYPE_CUR,
wxBITMAP_TYPE_CUR_RESOURCE,
wxBITMAP_TYPE_XBM,
wxBITMAP_TYPE_XBM_DATA,
wxBITMAP_TYPE_XPM,
wxBITMAP_TYPE_XPM_DATA,
wxBITMAP_TYPE_TIF,
wxBITMAP_TYPE_TIF_RESOURCE,
wxBITMAP_TYPE_GIF,
wxBITMAP_TYPE_GIF_RESOURCE,
wxBITMAP_TYPE_PNG,
wxBITMAP_TYPE_PNG_RESOURCE,
wxBITMAP_TYPE_JPEG,
wxBITMAP_TYPE_JPEG_RESOURCE,
wxBITMAP_TYPE_ANY = 50
};
// Standard cursors
typedef enum {
wxCURSOR_NONE = 0,
wxCURSOR_ARROW = 1,
enum wxStockCursor
{
wxCURSOR_NONE, // should be 0
wxCURSOR_ARROW,
wxCURSOR_BULLSEYE,
wxCURSOR_CHAR,
wxCURSOR_CROSS,
@@ -50,46 +99,94 @@ typedef enum {
wxCURSOR_SPRAYCAN,
wxCURSOR_WAIT,
wxCURSOR_WATCH,
wxCURSOR_BLANK
wxCURSOR_BLANK,
#ifdef __X__
/* Not yet implemented for Windows */
, wxCURSOR_CROSS_REVERSE,
// Not yet implemented for Windows
wxCURSOR_CROSS_REVERSE,
wxCURSOR_DOUBLE_ARROW,
wxCURSOR_BASED_ARROW_UP,
wxCURSOR_BASED_ARROW_DOWN
#endif
} wxStockCursor;
#endif // X11
wxCURSOR_MAX
};
// ---------------------------------------------------------------------------
// macros
// ---------------------------------------------------------------------------
/* Useful macro for creating icons portably, for example:
wxIcon *icon = new wxICON(mondrian);
expands into:
wxIcon *icon = new wxIcon("mondrian"); // On wxMSW
wxIcon *icon = new wxIcon(mondrian_xpm); // On wxGTK
*/
#ifdef __WXMSW__
// Load from a resource
#define wxICON(X) wxIcon("" #X "")
#elif defined(__WXGTK__)
// Initialize from an included XPM
#define wxICON(X) wxIcon( (const char**) X##_xpm )
#elif defined(__WXMOTIF__)
// Initialize from an included XPM
#define wxICON(X) wxIcon( X##_xpm )
#else
// This will usually mean something on any platform
#define wxICON(X) wxIcon("" #X "")
#endif // platform
// ===========================================================================
// classes
// ===========================================================================
// ---------------------------------------------------------------------------
// wxSize
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxSize
{
public:
// members are public for compatibility
long x;
long y;
inline wxSize() { x = 0; y = 0; }
inline wxSize(long xx, long yy) { x = xx; y = yy; }
inline wxSize(const wxSize& sz) { x = sz.x; y = sz.y; }
inline void operator = (const wxSize& sz) { x = sz.x; y = sz.y; }
inline bool operator == (const wxSize& sz) const { return (x == sz.x && y == sz.y); }
inline wxSize operator + (const wxSize& sz) { return wxSize(x + sz.x, y + sz.y); }
inline wxSize operator - (const wxSize& sz) { return wxSize(x - sz.x, y - sz.y); }
inline void Set(long xx, long yy) { x = xx; y = yy; }
inline long GetX() const { return x; }
inline long GetY() const { return y; }
// constructors
wxSize() { x = y = 0; }
wxSize(long xx, long yy) { Set(xx, yy); }
// no copy ctor or assignment operator - the defaults are ok
bool operator==(const wxSize& sz) const { return x == sz.x && y == sz.y; }
// FIXME are these really useful? If they're, we should have += &c as well
wxSize operator+(const wxSize& sz) { return wxSize(x + sz.x, y + sz.y); }
wxSize operator-(const wxSize& sz) { return wxSize(x - sz.x, y - sz.y); }
void Set(long xx, long yy) { x = xx; y = yy; }
long GetX() const { return x; }
long GetY() const { return y; }
};
// Point
// ---------------------------------------------------------------------------
// Point classes: with real or integer coordinates
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxRealPoint
{
public:
double x;
double y;
inline wxRealPoint() { x = 0.0; y = 0.0; };
inline wxRealPoint(double _x, double _y) { x = _x; y = _y; };
inline wxRealPoint operator + (const wxRealPoint& pt) { return wxRealPoint(x + pt.x, y + pt.y); }
inline wxRealPoint operator - (const wxRealPoint& pt) { return wxRealPoint(x - pt.x, y - pt.y); }
inline void operator = (const wxRealPoint& pt) { x = pt.x; y = pt.y; }
inline bool operator == (const wxRealPoint& pt) const { return (x == pt.x && y == pt.y); }
wxRealPoint() { x = y = 0.0; };
wxRealPoint(double xx, double yy) { x = xx; y = yy; };
wxRealPoint operator+(const wxRealPoint& pt) { return wxRealPoint(x + pt.x, y + pt.y); }
wxRealPoint operator-(const wxRealPoint& pt) { return wxRealPoint(x - pt.x, y - pt.y); }
bool operator==(const wxRealPoint& pt) const { return x == pt.x && y == pt.y; }
};
class WXDLLEXPORT wxPoint
@@ -103,20 +200,25 @@ class WXDLLEXPORT wxPoint
long y;
#endif
inline wxPoint() { x = 0; y = 0; };
wxPoint(long the_x, long the_y) { x = the_x; y = the_y; };
wxPoint(const wxPoint& pt) { x = pt.x; y = pt.y; };
wxPoint() { x = y = 0; };
wxPoint(long xx, long yy) { x = xx; y = yy; };
inline void operator = (const wxPoint& pt) { x = pt.x; y = pt.y; }
inline bool operator == (const wxPoint& pt) const { return (x == pt.x && y == pt.y); }
inline wxPoint operator + (const wxPoint& pt) { return wxPoint(x + pt.x, y + pt.y); }
inline wxPoint operator - (const wxPoint& pt) { return wxPoint(x - pt.x, y - pt.y); }
// no copy ctor or assignment operator - the defaults are ok
bool operator==(const wxPoint& pt) const { return x == pt.x && y == pt.y; }
wxPoint operator + (const wxPoint& pt) { return wxPoint(x + pt.x, y + pt.y); }
wxPoint operator - (const wxPoint& pt) { return wxPoint(x - pt.x, y - pt.y); }
};
#if WXWIN_COMPATIBILITY
#define wxIntPoint wxPoint
#define wxRectangle wxRect
#endif
#endif // WXWIN_COMPATIBILITY
// ---------------------------------------------------------------------------
// wxRect
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxRect
{
@@ -127,81 +229,46 @@ public:
wxRect(const wxPoint& pos, const wxSize& size);
wxRect(const wxRect& rect);
inline long GetX() const { return x; }
inline void SetX(long X) { x = X; }
inline long GetY() const { return y; }
inline void SetY(long Y) { y = Y; }
inline long GetWidth() const { return width; }
inline void SetWidth(long w) { width = w; }
inline long GetHeight() const { return height; }
inline void SetHeight(long h) { height = h; }
long GetX() const { return x; }
void SetX(long xx) { x = xx; }
inline wxPoint GetPosition() { return wxPoint(x, y); }
inline wxSize GetSize() { return wxSize(width, height); }
long GetY() const { return y; }
void SetY(long yy) { y = yy; }
inline long GetLeft() const { return x; }
inline long GetTop() const { return y; }
inline long GetBottom() const { return y + height; }
inline long GetRight() const { return x + width; }
long GetWidth() const { return width; }
void SetWidth(long w) { width = w; }
long GetHeight() const { return height; }
void SetHeight(long h) { height = h; }
wxPoint GetPosition() { return wxPoint(x, y); }
wxSize GetSize() { return wxSize(width, height); }
long GetLeft() const { return x; }
long GetTop() const { return y; }
long GetBottom() const { return y + height; }
long GetRight() const { return x + width; }
wxRect& operator = (const wxRect& rect);
bool operator == (const wxRect& rect);
bool operator != (const wxRect& rect);
public:
long x, y, width, height;
};
class WXDLLEXPORT wxBrush;
class WXDLLEXPORT wxPen;
class WXDLLEXPORT wxBitmap;
class WXDLLEXPORT wxIcon;
class WXDLLEXPORT wxCursor;
class WXDLLEXPORT wxFont;
class WXDLLEXPORT wxPalette;
class WXDLLEXPORT wxPalette;
class WXDLLEXPORT wxRegion;
/*
* Bitmap flags
*/
// Hint to indicate filetype
#define wxBITMAP_TYPE_BMP 1
#define wxBITMAP_TYPE_BMP_RESOURCE 2
#define wxBITMAP_TYPE_ICO 3
#define wxBITMAP_TYPE_ICO_RESOURCE 4
#define wxBITMAP_TYPE_CUR 5
#define wxBITMAP_TYPE_CUR_RESOURCE 6
#define wxBITMAP_TYPE_XBM 7
#define wxBITMAP_TYPE_XBM_DATA 8
#define wxBITMAP_TYPE_XPM 9
#define wxBITMAP_TYPE_XPM_DATA 10
#define wxBITMAP_TYPE_TIF 11
#define wxBITMAP_TYPE_TIF_RESOURCE 12
#define wxBITMAP_TYPE_GIF 13
#define wxBITMAP_TYPE_GIF_RESOURCE 14
#define wxBITMAP_TYPE_PNG 15
#define wxBITMAP_TYPE_PNG_RESOURCE 16
#define wxBITMAP_TYPE_JPEG 17
#define wxBITMAP_TYPE_JPEG_RESOURCE 18
#define wxBITMAP_TYPE_ANY 50
#define wxBITMAP_TYPE_RESOURCE wxBITMAP_TYPE_BMP_RESOURCE
class WXDLLEXPORT wxBitmap;
class WXDLLEXPORT wxCursor;
class WXDLLEXPORT wxIcon;
class WXDLLEXPORT wxColour;
class WXDLLEXPORT wxString;
// ---------------------------------------------------------------------------
// Management of pens, brushes and fonts
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxPenList : public wxList
{
DECLARE_DYNAMIC_CLASS(wxPenList)
public:
inline wxPenList()
{ }
wxPenList() { }
~wxPenList();
void AddPen(wxPen *pen);
void RemovePen(wxPen *pen);
wxPen *FindOrCreatePen(const wxColour& colour, int width, int style);
@@ -210,10 +277,11 @@ class WXDLLEXPORT wxPenList: public wxList
class WXDLLEXPORT wxBrushList : public wxList
{
DECLARE_DYNAMIC_CLASS(wxBrushList)
public:
inline wxBrushList()
{ }
wxBrushList() { }
~wxBrushList();
void AddBrush(wxBrush *brush);
void RemoveBrush(wxBrush *brush);
wxBrush *FindOrCreateBrush(const wxColour& colour, int style);
@@ -224,22 +292,26 @@ WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
class WXDLLEXPORT wxFontList : public wxList
{
DECLARE_DYNAMIC_CLASS(wxFontList)
public:
inline wxFontList()
{ }
wxFontList() { }
~wxFontList();
void AddFont(wxFont *font);
void RemoveFont(wxFont *font);
wxFont *FindOrCreateFont(int pointSize, int family, int style, int weight,
bool underline = FALSE, const wxString& face = wxEmptyString);
bool underline = FALSE,
const wxString& face = wxEmptyString);
};
class WXDLLEXPORT wxColourDatabase : public wxList
{
DECLARE_CLASS(wxColourDatabase)
public:
wxColourDatabase(int type);
~wxColourDatabase() ;
// Not const because it may add a name to the database
wxColour *FindColour(const wxString& colour) ;
wxString FindName(const wxColour& colour) const;
@@ -249,6 +321,7 @@ class WXDLLEXPORT wxColourDatabase: public wxList
class WXDLLEXPORT wxBitmapList : public wxList
{
DECLARE_DYNAMIC_CLASS(wxBitmapList)
public:
wxBitmapList();
~wxBitmapList();
@@ -257,6 +330,21 @@ class WXDLLEXPORT wxBitmapList: public wxList
void RemoveBitmap(wxBitmap *bitmap);
};
class WXDLLEXPORT wxResourceCache: public wxList
{
public:
wxResourceCache() { }
wxResourceCache(const unsigned int keyType) : wxList(keyType) { }
~wxResourceCache();
private:
DECLARE_DYNAMIC_CLASS(wxResourceCache)
};
// ---------------------------------------------------------------------------
// global variables
// ---------------------------------------------------------------------------
// Lists of GDI objects
WXDLLEXPORT_DATA(extern wxPenList*) wxThePenList;
WXDLLEXPORT_DATA(extern wxBrushList*) wxTheBrushList;
@@ -315,58 +403,38 @@ WXDLLEXPORT_DATA(extern wxCursor*) wxHOURGLASS_CURSOR;
WXDLLEXPORT_DATA(extern wxCursor*) wxCROSS_CURSOR;
WXDLLEXPORT_DATA(extern wxColourDatabase*) wxTheColourDatabase;
WXDLLEXPORT_DATA(extern const wxChar*) wxPanelNameStr;
WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
// The list of objects which should be deleted
WXDLLEXPORT_DATA(extern wxList) wxPendingDelete;
// ---------------------------------------------------------------------------
// global functions
// ---------------------------------------------------------------------------
// resource management
extern void WXDLLEXPORT wxInitializeStockObjects();
extern void WXDLLEXPORT wxInitializeStockLists();
extern void WXDLLEXPORT wxDeleteStockObjects();
extern void WXDLLEXPORT wxDeleteStockLists();
// is the display colour (or monochrome)?
extern bool WXDLLEXPORT wxColourDisplay();
// Returns depth of screen
extern int WXDLLEXPORT wxDisplayDepth();
#define wxGetDisplayDepth wxDisplayDepth
// get the diaplay size
extern void WXDLLEXPORT wxDisplaySize(int *width, int *height);
extern wxSize WXDLLEXPORT wxGetDisplaySize();
// set global cursor
extern void WXDLLEXPORT wxSetCursor(const wxCursor& cursor);
// Useful macro for creating icons portably
#ifdef __WXMSW__
// Load from a resource
# define wxICON(X) wxIcon("" #X "")
#elif defined(__WXGTK__)
// Initialize from an included XPM
# define wxICON(X) wxIcon( (const char**) X##_xpm )
#elif defined(__WXMOTIF__)
// Initialize from an included XPM
# define wxICON(X) wxIcon( X##_xpm )
#else
// This will usually mean something on any platform
# define wxICON(X) wxIcon("" #X "")
#endif
/*
Example:
wxIcon *icon = new wxICON(mondrian);
expands into:
wxIcon *icon = new wxIcon("mondrian"); // On wxMSW
wxIcon *icon = new wxIcon(mondrian_xpm); // On wxGTK
*/
class WXDLLEXPORT wxResourceCache: public wxList
{
public:
wxResourceCache() { }
wxResourceCache(const unsigned int keyType) : wxList(keyType) { }
~wxResourceCache();
private:
DECLARE_DYNAMIC_CLASS(wxResourceCache)
};
#endif
// _WX_GDICMNH__

16
include/wx/generic/listctrl.h
View File

@@ -611,9 +611,9 @@ class WXDLLEXPORT wxListCtrl: public wxControl
// We have to hand down a few functions
void SetBackgroundColour( const wxColour &colour );
void SetForegroundColour( const wxColour &colour );
void SetFont( const wxFont &font );
bool SetBackgroundColour( const wxColour &colour );
bool SetForegroundColour( const wxColour &colour );
bool SetFont( const wxFont &font );
#if wxUSE_DRAG_AND_DROP
void SetDropTarget( wxDropTarget *dropTarget )
@@ -622,14 +622,12 @@ class WXDLLEXPORT wxListCtrl: public wxControl
{ return m_mainWin->GetDropTarget(); }
#endif
void SetCursor( const wxCursor &cursor )
{ if (m_mainWin) m_mainWin->wxWindow::SetCursor( cursor); }
bool SetCursor( const wxCursor &cursor )
{ return m_mainWin ? m_mainWin->wxWindow::SetCursor(cursor) : FALSE; }
wxColour GetBackgroundColour() const
{ if (m_mainWin) return m_mainWin->GetBackgroundColour();
else return wxColour(); }
{ return m_mainWin ? m_mainWin->GetBackgroundColour() : wxColour(); }
wxColour GetForegroundColour() const
{ if (m_mainWin) return m_mainWin->GetForegroundColour();
else return wxColour(); }
{ return m_mainWin ? m_mainWin->GetForegroundColour() : wxColour(); }
bool PopupMenu( wxMenu *menu, int x, int y )
{ return m_mainWin->PopupMenu( menu, x, y ); }
void SetFocus()

2
include/wx/generic/tabg.h
View File

@@ -120,7 +120,7 @@ public:
wxString GetTabText(int id) const;
// Layout tabs (optional, e.g. if resizing window)
void Layout(void);
void LayoutTabs();
// Draw all tabs
virtual void Draw(wxDC& dc);

2
include/wx/gtk/bmpbuttn.h
View File

@@ -72,7 +72,7 @@ public:
void SetBitmapLabel( const wxBitmap& bitmap );
void SetBitmapSelected( const wxBitmap& bitmap );
virtual void Enable(const bool);
virtual bool Enable(const bool);
// implementation

2
include/wx/gtk/button.h
View File

@@ -59,7 +59,7 @@ class wxButton: public wxControl
const wxString& name = wxButtonNameStr);
void SetDefault();
void SetLabel( const wxString &label );
void Enable( bool enable );
bool Enable( bool enable );
// implementation

2
include/wx/gtk/checkbox.h
View File

@@ -63,7 +63,7 @@ public:
bool GetValue() const;
void SetLabel( const wxString& label );
void Enable( bool enable );
bool Enable( bool enable );
// implementation
void ApplyWidgetStyle();

5
include/wx/gtk/dialog.h
View File

@@ -87,6 +87,9 @@ public:
virtual void Maximize() { }
virtual void Restore() { }
void SetReturnCode(int returnCode) { m_returnCode = returnCode; }
int GetReturnCode() const { return m_returnCode; }
// implementation
virtual void GtkOnSize( int x, int y, int width, int height );
@@ -105,6 +108,8 @@ protected:
int sizeFlags = wxSIZE_AUTO);
private:
int m_returnCode;
DECLARE_EVENT_TABLE()
};

4
include/wx/gtk/font.h
View File

@@ -58,8 +58,8 @@ public:
wxFont( const wxFont& font );
~wxFont();
wxFont& operator = ( const wxFont& font );
bool operator == ( const wxFont& font );
bool operator != ( const wxFont& font );
bool operator == ( const wxFont& font ) const;
bool operator != ( const wxFont& font ) const;
bool Ok() const;
int GetPointSize() const;

2
include/wx/gtk/radiobox.h
View File

@@ -70,7 +70,7 @@ class wxRadioBox: public wxControl
void SetLabel( int item, wxBitmap *bitmap );
wxString GetLabel( int item ) const;
bool Show( bool show );
void Enable( bool enable );
bool Enable( bool enable );
void Enable( int item, bool enable );
void Show( int item, bool show );
virtual wxString GetStringSelection(void) const;

2
include/wx/gtk/radiobut.h
View File

@@ -60,7 +60,7 @@ class wxRadioButton: public wxControl
virtual void SetLabel(const wxString& label);
virtual void SetValue(bool val);
virtual bool GetValue(void) const;
void Enable( bool enable );
bool Enable( bool enable );
// implementation

6
include/wx/gtk/textctrl.h
View File

@@ -143,9 +143,9 @@ class wxTextCtrl: public wxControl
wxTextCtrl& operator<<(const char c);
#endif
void SetFont( const wxFont &font );
void SetForegroundColour(const wxColour &colour);
void SetBackgroundColour(const wxColour &colour);
bool SetFont( const wxFont &font );
bool SetForegroundColour(const wxColour &colour);
bool SetBackgroundColour(const wxColour &colour);
// implementation

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

@@ -15,94 +15,17 @@
#pragma interface
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/event.h"
#include "wx/validate.h"
#include "wx/cursor.h"
#include "wx/font.h"
#include "wx/region.h"
#include "wx/accel.h"
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const wxChar *wxFrameNameStr;
extern wxWindowList wxTopLevelWindows;
//-----------------------------------------------------------------------------
// global function
//-----------------------------------------------------------------------------
extern wxWindow* wxGetActiveWindow();
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxLayoutConstraints;
class wxSizer;
class wxDC;
class wxClientData;
class wxVoidClientData;
class wxWindow;
#if wxUSE_WX_RESOURCES
class wxResourceTable;
class wxItemResource;
#endif
#if wxUSE_DRAG_AND_DROP
class wxDropTarget;
#endif
class wxToolTip;
//-----------------------------------------------------------------------------
// callback definition for inserting a window (internal)
//-----------------------------------------------------------------------------
typedef void (*wxInsertChildFunction)( wxWindow*, wxWindow* );
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const wxChar *wxPanelNameStr;
extern const wxSize wxDefaultSize;
extern const wxPoint wxDefaultPosition;
//-----------------------------------------------------------------------------
// wxClientData
//-----------------------------------------------------------------------------
class wxClientData
{
public:
wxClientData() { }
virtual ~wxClientData() { }
};
//-----------------------------------------------------------------------------
// wxStringClientData
//-----------------------------------------------------------------------------
class wxStringClientData : public wxClientData
{
public:
wxStringClientData() { }
wxStringClientData( wxString &data ) { m_data = data; }
void SetData( wxString &data ) { m_data = data; }
wxString GetData() const { return m_data; }
private:
wxString m_data;
};
//-----------------------------------------------------------------------------
// wxWindow
//-----------------------------------------------------------------------------
class wxWindow : public wxEvtHandler
class wxWindow : public wxWindowBase
{
DECLARE_DYNAMIC_CLASS(wxWindow)
@@ -110,300 +33,111 @@ public:
// creating the window
// -------------------
wxWindow();
wxWindow(wxWindow *parent, wxWindowID id,
wxWindow(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
bool Create(wxWindow *parent, wxWindowID id,
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
virtual ~wxWindow();
#if wxUSE_WX_RESOURCES
virtual bool LoadFromResource(wxWindow *parent,
const wxString& resourceName,
const wxResourceTable *table = (const wxResourceTable *) NULL);
virtual wxControl *CreateItem(const wxItemResource* childResource,
const wxItemResource* parentResource,
const wxResourceTable *table = (const wxResourceTable *) NULL);
#endif // wxUSE_WX_RESOURCES
// closing the window
// ------------------
bool Close( bool force = FALSE );
// implement base class (pure) virtual methods
// -------------------------------------------
virtual bool Destroy();
virtual bool DestroyChildren();
bool IsBeingDeleted();
// moving/resizing
// ---------------
// set the window size and/or position
void SetSize( int x, int y, int width, int height,
int sizeFlags = wxSIZE_AUTO )
{ DoSetSize(x, y, width, height, sizeFlags); }
void SetSize( int width, int height )
{ DoSetSize( -1, -1, width, height, wxSIZE_USE_EXISTING ); }
void SetSize( const wxSize& size )
{ SetSize( size.x, size.y); }
void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO)
{ DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); }
void Move( int x, int y )
{ DoSetSize( x, y, -1, -1, wxSIZE_USE_EXISTING ); }
void Move(const wxPoint& pt)
{ Move(pt.x, pt.y); }
// client size is the size of area available for subwindows
void SetClientSize( int width, int height )
{ DoSetClientSize(width, height); }
void SetClientSize( const wxSize& size )
{ DoSetClientSize(size.x, size.y); }
void SetClientSize(const wxRect& rect)
{ SetClientSize( rect.width, rect.height ); }
// get the window position and/or size
virtual void GetPosition( int *x, int *y ) const;
wxPoint GetPosition() const
{
int w, h;
GetPosition(& w, & h);
return wxPoint(w, h);
}
virtual void GetSize( int *width, int *height ) const;
wxSize GetSize() const
{
int w, h;
GetSize(& w, & h);
return wxSize(w, h);
}
wxRect GetRect() const
{
int x, y, w, h;
GetPosition(& x, & y);
GetSize(& w, & h);
return wxRect(x, y, w, h);
}
virtual void GetClientSize( int *width, int *height ) const;
wxSize GetClientSize() const
{
int w, h;
GetClientSize(& w, & h);
return wxSize(w, h);
}
// position with respect to the the parent window
virtual void Centre( int direction = wxHORIZONTAL );
void Center(int direction = wxHORIZONTAL) { Centre(direction); }
virtual void Fit();
// set min/max size of the window
virtual void SetSizeHints( int minW, int minH,
int maxW = -1, int maxH = -1,
int incW = -1, int incH = -1 );
// Dialog units translations. Implemented in wincmn.cpp.
// -----------------------------------------------------
wxPoint ConvertPixelsToDialog( const wxPoint& pt );
wxPoint ConvertDialogToPixels( const wxPoint& pt );
wxSize ConvertPixelsToDialog( const wxSize& sz )
{
wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));
return wxSize(pt.x, pt.y);
}
wxSize ConvertDialogToPixels( const wxSize& sz )
{
wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));
return wxSize(pt.x, pt.y);
}
void OnSize( wxSizeEvent &event );
// window state
// ------------
virtual bool Show( bool show );
virtual void Enable( bool enable );
virtual void MakeModal( bool modal );
virtual bool IsEnabled() const { return m_isEnabled; }
inline bool Enabled() const { return IsEnabled(); }
virtual void SetFocus();
static wxWindow *FindFocus();
void SetReturnCode( int retCode );
int GetReturnCode();
// parent/children relations
// -------------------------
virtual void AddChild( wxWindow *child );
wxList& GetChildren() { return m_children; }
virtual void RemoveChild( wxWindow *child );
wxWindow *GetParent() const
{ return m_parent; }
wxWindow *GetGrandParent() const
{ return (m_parent ? m_parent->m_parent : (wxWindow*)NULL); }
void SetParent( wxWindow *parent )
{ m_parent = parent; }
virtual wxWindow *ReParent( wxWindow *newParent );
// event handler stuff
// -------------------
wxEvtHandler *GetEventHandler() const;
void SetEventHandler( wxEvtHandler *handler );
void PushEventHandler( wxEvtHandler *handler );
wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
// validators and client data
// --------------------------
virtual void SetValidator( const wxValidator &validator );
virtual wxValidator *GetValidator();
virtual void SetClientObject( wxClientData *data );
virtual wxClientData *GetClientObject();
virtual void SetClientData( void *data );
virtual void *GetClientData();
// accelerators
// ------------
virtual void SetAcceleratorTable( const wxAcceleratorTable& accel );
virtual wxAcceleratorTable *GetAcceleratorTable() { return &m_acceleratorTable; }
void SetId( wxWindowID id );
wxWindowID GetId() const;
void SetCursor( const wxCursor &cursor );
virtual void PrepareDC( wxDC &dc );
void WarpPointer(int x, int y);
#if wxUSE_TOOLTIPS
void SetToolTip( const wxString &tip );
virtual void SetToolTip( wxToolTip *tip );
wxToolTip* GetToolTip() const { return m_toolTip; }
#endif // wxUSE_TOOLTIPS
virtual void Refresh( bool eraseBackground = TRUE, const wxRect *rect = (const wxRect *) NULL );
virtual void Clear();
virtual wxRegion GetUpdateRegion() const;
virtual bool IsExposed( int x, int y ) const;
virtual bool IsExposed( int x, int y, int w, int h ) const;
virtual bool IsExposed( const wxPoint& pt ) const;
virtual bool IsExposed( const wxRect& rect ) const;
// colours
// -------
virtual wxColour GetBackgroundColour() const;
virtual void SetBackgroundColour( const wxColour &colour );
virtual wxColour GetForegroundColour() const;
virtual void SetForegroundColour( const wxColour &colour );
// fonts
// -----
virtual int GetCharHeight() const;
virtual int GetCharWidth() const;
virtual void GetTextExtent( const wxString& string, int *x, int *y,
int *descent = (int *) NULL,
int *externalLeading = (int *) NULL,
const wxFont *theFont = (const wxFont *) NULL, bool use16 = FALSE) const;
virtual void SetFont( const wxFont &font );
virtual wxFont& GetFont() { return m_font; }
// For backward compatibility
virtual void SetButtonFont(const wxFont& font) { SetFont(font); }
virtual void SetLabelFont(const wxFont& font) { SetFont(font); }
virtual wxFont& GetLabelFont() { return GetFont(); };
virtual wxFont& GetButtonFont() { return GetFont(); };
virtual void SetWindowStyleFlag( long flag );
virtual long GetWindowStyleFlag() const;
virtual void CaptureMouse();
virtual void ReleaseMouse();
virtual void SetTitle( const wxString &title );
virtual wxString GetTitle() const;
virtual void SetName( const wxString &name );
virtual wxString GetName() const;
virtual wxString GetLabel() const;
void OnSysColourChanged( wxSysColourChangedEvent &WXUNUSED(event) ) { }
void OnKeyDown( wxKeyEvent &event );
virtual bool IsShown() const;
virtual void Raise();
virtual void Lower();
virtual bool IsRetained();
virtual wxWindow *FindWindow( long id );
virtual wxWindow *FindWindow( const wxString& name );
virtual bool Show( bool show = TRUE );
virtual bool Enable( bool enable = TRUE );
void AllowDoubleClick( bool WXUNUSED(allow) ) { }
void SetDoubleClick( bool WXUNUSED(allow) ) { }
virtual bool IsRetained() const;
virtual void ClientToScreen( int *x, int *y );
virtual void ScreenToClient( int *x, int *y );
virtual void SetFocus();
virtual bool AcceptsFocus() const;
virtual bool Validate();
virtual bool TransferDataToWindow();
virtual bool TransferDataFromWindow();
void OnInitDialog( wxInitDialogEvent &event );
virtual void InitDialog();
virtual bool Reparent( wxWindow *newParent );
virtual void WarpPointer(int x, int y);
virtual void CaptureMouse();
virtual void ReleaseMouse();
virtual void Refresh( bool eraseBackground = TRUE,
const wxRect *rect = (const wxRect *) NULL );
virtual void Clear();
virtual bool SetBackgroundColour( const wxColour &colour );
virtual bool SetForegroundColour( const wxColour &colour );
virtual bool SetCursor( const wxCursor &cursor );
virtual bool SetFont( const wxFont &font );
virtual int GetCharHeight() const;
virtual int GetCharWidth() const;
virtual void GetTextExtent(const wxString& string,
int *x, int *y,
int *descent = (int *) NULL,
int *externalLeading = (int *) NULL,
const wxFont *theFont = (const wxFont *) NULL)
const;
virtual void ClientToScreen( int *x, int *y ) const;
virtual void ScreenToClient( int *x, int *y ) const;
virtual bool PopupMenu( wxMenu *menu, int x, int y );
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget );
virtual wxDropTarget *GetDropTarget() const;
#endif
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;
virtual void ScrollWindow( int dx, int dy, const wxRect* rect = (wxRect *) NULL );
virtual void ScrollWindow( int dx, int dy,
const wxRect* rect = (wxRect *) NULL );
virtual bool AcceptsFocus() const;
void UpdateWindowUI();
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget );
#endif // wxUSE_DRAG_AND_DROP
// implementation
// --------------
bool HasVMT();
// wxWindows callbacks
void OnKeyDown( wxKeyEvent &event );
// simple accessors
bool HasVMT() const { return m_hasVMT; }
int GetX() const { return m_x; }
int GetY() const { return m_y; }
int GetWidth() const { return m_width; }
int GetHeight() const { return m_height; }
GtkWidget *GetWxWindow() const { return m_wxwindow; }
GtkWidget *GetWidget() const { return GetHandle(); }
GtkAdjustment *GetHAdjust() const { return m_hAdjust; }
GtkAdjustment *GetVAdjust() const { return m_vAdjust; }
float GetOldHorizontalPos() const { return m_oldHorizontalPos; }
float GetOldVerticalPos() const { return m_oldVerticalPos; }
void SetOldHorizontalPos(float fpos) { m_oldHorizontalPos = fpos; }
void SetOldVerticalPos(float fpos) { m_oldVerticalPos = fpos; }
bool IsSizeSet() const { return m_sizeSet; }
// also sets the global flag
void SetScrolling(bool scroll);
bool HasScrolling() const { return m_hasScrolling; }
bool IsScrolling() const { return m_isScrolling; }
bool IsStaticBox() const { return m_isStaticBox; }
/* I don't want users to override what's done in idle so everything that
has to be done in idle time in order for wxGTK to work is done in
@@ -418,6 +152,9 @@ public:
const wxSize &size, long style, const wxString &name );
void PostCreation();
void InsertChild(wxWindow *child) { (*m_insertCallback)(this, child); }
void DoAddChild(wxWindow *child) { AddChild(child); InsertChild(child); }
/* the methods below are required because many native widgets
are composed of several subwidgets and setting a style for
the widget means setting it for all subwidgets as well.
@@ -437,107 +174,57 @@ public:
virtual void ApplyToolTip( GtkTooltips *tips, const wxChar *tip );
#endif // wxUSE_TOOLTIPS
/* private member variables */
// called from GTK signales handlers
void UpdateSize() { m_sizeSet = FALSE; }
void InternalSetPosition(int x, int y) { m_x = x; m_y = y; }
void InternalSetSize(int w, int h)
{ m_width = w; m_height = h; UpdateSize(); }
wxWindow *m_parent;
wxList m_children;
protected:
// position and size of the window
int m_x, m_y;
int m_width, m_height;
int m_minWidth,m_minHeight;
int m_maxWidth,m_maxHeight;
int m_retCode;
wxEvtHandler *m_eventHandler;
wxValidator *m_windowValidator;
#if wxUSE_DRAG_AND_DROP
wxDropTarget *m_dropTarget;
#endif
wxWindowID m_windowId;
wxCursor m_cursor;
wxFont m_font;
wxColour m_backgroundColour;
wxColour m_foregroundColour;
wxRegion m_updateRegion;
long m_windowStyle;
bool m_isShown;
bool m_isEnabled;
wxString m_windowName;
wxAcceleratorTable m_acceleratorTable;
wxClientData *m_clientObject;
void *m_clientData;
#if wxUSE_TOOLTIPS
wxToolTip *m_toolTip;
#endif // wxUSE_TOOLTIPS
GtkWidget *m_widget;
// see the docs in src/gtk/window.cpp
GtkWidget *m_wxwindow;
// scrolling stuff
GtkAdjustment *m_hAdjust,*m_vAdjust;
float m_oldHorizontalPos;
float m_oldVerticalPos;
bool m_needParent; /* ! wxFrame, wxDialog, wxNotebookPage ? */
bool m_hasScrolling;
bool m_isScrolling;
bool m_hasVMT;
bool m_sizeSet;
bool m_resizing;
float m_oldHorizontalPos,
m_oldVerticalPos;
GdkGC *m_scrollGC;
// extra (wxGTK-specific) flags
bool m_needParent:1; /* ! wxFrame, wxDialog, wxNotebookPage ? */
bool m_hasScrolling:1;
bool m_isScrolling:1;
bool m_hasVMT:1;
bool m_sizeSet:1;
bool m_resizing:1;
bool m_isStaticBox:1; /* faster than IS_KIND_OF */
bool m_isFrame:1; /* faster than IS_KIND_OF */
bool m_acceptsFocus:1; /* ! wxStaticBox etc. */
GtkStyle *m_widgetStyle;
bool m_isStaticBox; /* faster than IS_KIND_OF */
bool m_isFrame; /* faster than IS_KIND_OF */
bool m_acceptsFocus; /* ! wxStaticBox etc. */
wxInsertChildFunction m_insertCallback;
public:
wxLayoutConstraints *m_constraints;
wxList *m_constraintsInvolvedIn;
wxSizer *m_windowSizer;
wxWindow *m_sizerParent;
bool m_autoLayout;
wxLayoutConstraints *GetConstraints() const;
void SetConstraints( wxLayoutConstraints *constraints );
void SetAutoLayout( bool autoLayout );
bool GetAutoLayout() const;
bool Layout();
void SetSizer( wxSizer *sizer );
wxSizer *GetSizer() const;
void SetSizerParent( wxWindow *win );
wxWindow *GetSizerParent() const;
void UnsetConstraints(wxLayoutConstraints *c);
inline wxList *GetConstraintsInvolvedIn() const ;
void AddConstraintReference(wxWindow *otherWin);
void RemoveConstraintReference(wxWindow *otherWin);
void DeleteRelatedConstraints();
virtual void ResetConstraints();
virtual void SetConstraintSizes(bool recurse = TRUE);
virtual bool LayoutPhase1(int *noChanges);
virtual bool LayoutPhase2(int *noChanges);
virtual bool DoPhase(int);
virtual void TransformSizerToActual(int *x, int *y) const ;
virtual void SizerSetSize(int x, int y, int w, int h);
virtual void SizerMove(int x, int y);
virtual void SetSizeConstraint(int x, int y, int w, int h);
virtual void MoveConstraint(int x, int y);
virtual void GetSizeConstraint(int *w, int *h) const ;
virtual void GetClientSizeConstraint(int *w, int *h) const ;
virtual void GetPositionConstraint(int *x, int *y) const ;
protected:
// common part of all ctors
void Init();
// this is the virtual function to be overriden in any derived class which
// wants to change how SetSize() or Move() works - it is called by all
// versions of these functions in the base class
// implement the base class pure virtuals
virtual void DoGetPosition( int *x, int *y ) const;
virtual void DoGetSize( int *width, int *height ) const;
virtual void DoGetClientSize( int *width, int *height ) const;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
// same as DoSetSize() for the client size
virtual void DoSetClientSize(int width, int height);
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip );
#endif // wxUSE_TOOLTIPS
// common part of all ctors (can't be virtual because called from ctor)
void Init();
private:
DECLARE_EVENT_TABLE()
};

2
include/wx/gtk1/bmpbuttn.h
View File

@@ -72,7 +72,7 @@ public:
void SetBitmapLabel( const wxBitmap& bitmap );
void SetBitmapSelected( const wxBitmap& bitmap );
virtual void Enable(const bool);
virtual bool Enable(const bool);
// implementation

2
include/wx/gtk1/button.h
View File

@@ -59,7 +59,7 @@ class wxButton: public wxControl
const wxString& name = wxButtonNameStr);
void SetDefault();
void SetLabel( const wxString &label );
void Enable( bool enable );
bool Enable( bool enable );
// implementation

2
include/wx/gtk1/checkbox.h
View File

@@ -63,7 +63,7 @@ public:
bool GetValue() const;
void SetLabel( const wxString& label );
void Enable( bool enable );
bool Enable( bool enable );
// implementation
void ApplyWidgetStyle();

5
include/wx/gtk1/dialog.h
View File

@@ -87,6 +87,9 @@ public:
virtual void Maximize() { }
virtual void Restore() { }
void SetReturnCode(int returnCode) { m_returnCode = returnCode; }
int GetReturnCode() const { return m_returnCode; }
// implementation
virtual void GtkOnSize( int x, int y, int width, int height );
@@ -105,6 +108,8 @@ protected:
int sizeFlags = wxSIZE_AUTO);
private:
int m_returnCode;
DECLARE_EVENT_TABLE()
};

4
include/wx/gtk1/font.h
View File

@@ -58,8 +58,8 @@ public:
wxFont( const wxFont& font );
~wxFont();
wxFont& operator = ( const wxFont& font );
bool operator == ( const wxFont& font );
bool operator != ( const wxFont& font );
bool operator == ( const wxFont& font ) const;
bool operator != ( const wxFont& font ) const;
bool Ok() const;
int GetPointSize() const;

2
include/wx/gtk1/radiobox.h
View File

@@ -70,7 +70,7 @@ class wxRadioBox: public wxControl
void SetLabel( int item, wxBitmap *bitmap );
wxString GetLabel( int item ) const;
bool Show( bool show );
void Enable( bool enable );
bool Enable( bool enable );
void Enable( int item, bool enable );
void Show( int item, bool show );
virtual wxString GetStringSelection(void) const;

2
include/wx/gtk1/radiobut.h
View File

@@ -60,7 +60,7 @@ class wxRadioButton: public wxControl
virtual void SetLabel(const wxString& label);
virtual void SetValue(bool val);
virtual bool GetValue(void) const;
void Enable( bool enable );
bool Enable( bool enable );
// implementation

6
include/wx/gtk1/textctrl.h
View File

@@ -143,9 +143,9 @@ class wxTextCtrl: public wxControl
wxTextCtrl& operator<<(const char c);
#endif
void SetFont( const wxFont &font );
void SetForegroundColour(const wxColour &colour);
void SetBackgroundColour(const wxColour &colour);
bool SetFont( const wxFont &font );
bool SetForegroundColour(const wxColour &colour);
bool SetBackgroundColour(const wxColour &colour);
// implementation

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

@@ -15,94 +15,17 @@
#pragma interface
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/event.h"
#include "wx/validate.h"
#include "wx/cursor.h"
#include "wx/font.h"
#include "wx/region.h"
#include "wx/accel.h"
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const wxChar *wxFrameNameStr;
extern wxWindowList wxTopLevelWindows;
//-----------------------------------------------------------------------------
// global function
//-----------------------------------------------------------------------------
extern wxWindow* wxGetActiveWindow();
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxLayoutConstraints;
class wxSizer;
class wxDC;
class wxClientData;
class wxVoidClientData;
class wxWindow;
#if wxUSE_WX_RESOURCES
class wxResourceTable;
class wxItemResource;
#endif
#if wxUSE_DRAG_AND_DROP
class wxDropTarget;
#endif
class wxToolTip;
//-----------------------------------------------------------------------------
// callback definition for inserting a window (internal)
//-----------------------------------------------------------------------------
typedef void (*wxInsertChildFunction)( wxWindow*, wxWindow* );
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const wxChar *wxPanelNameStr;
extern const wxSize wxDefaultSize;
extern const wxPoint wxDefaultPosition;
//-----------------------------------------------------------------------------
// wxClientData
//-----------------------------------------------------------------------------
class wxClientData
{
public:
wxClientData() { }
virtual ~wxClientData() { }
};
//-----------------------------------------------------------------------------
// wxStringClientData
//-----------------------------------------------------------------------------
class wxStringClientData : public wxClientData
{
public:
wxStringClientData() { }
wxStringClientData( wxString &data ) { m_data = data; }
void SetData( wxString &data ) { m_data = data; }
wxString GetData() const { return m_data; }
private:
wxString m_data;
};
//-----------------------------------------------------------------------------
// wxWindow
//-----------------------------------------------------------------------------
class wxWindow : public wxEvtHandler
class wxWindow : public wxWindowBase
{
DECLARE_DYNAMIC_CLASS(wxWindow)
@@ -110,300 +33,111 @@ public:
// creating the window
// -------------------
wxWindow();
wxWindow(wxWindow *parent, wxWindowID id,
wxWindow(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
bool Create(wxWindow *parent, wxWindowID id,
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
virtual ~wxWindow();
#if wxUSE_WX_RESOURCES
virtual bool LoadFromResource(wxWindow *parent,
const wxString& resourceName,
const wxResourceTable *table = (const wxResourceTable *) NULL);
virtual wxControl *CreateItem(const wxItemResource* childResource,
const wxItemResource* parentResource,
const wxResourceTable *table = (const wxResourceTable *) NULL);
#endif // wxUSE_WX_RESOURCES
// closing the window
// ------------------
bool Close( bool force = FALSE );
// implement base class (pure) virtual methods
// -------------------------------------------
virtual bool Destroy();
virtual bool DestroyChildren();
bool IsBeingDeleted();
// moving/resizing
// ---------------
// set the window size and/or position
void SetSize( int x, int y, int width, int height,
int sizeFlags = wxSIZE_AUTO )
{ DoSetSize(x, y, width, height, sizeFlags); }
void SetSize( int width, int height )
{ DoSetSize( -1, -1, width, height, wxSIZE_USE_EXISTING ); }
void SetSize( const wxSize& size )
{ SetSize( size.x, size.y); }
void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO)
{ DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); }
void Move( int x, int y )
{ DoSetSize( x, y, -1, -1, wxSIZE_USE_EXISTING ); }
void Move(const wxPoint& pt)
{ Move(pt.x, pt.y); }
// client size is the size of area available for subwindows
void SetClientSize( int width, int height )
{ DoSetClientSize(width, height); }
void SetClientSize( const wxSize& size )
{ DoSetClientSize(size.x, size.y); }
void SetClientSize(const wxRect& rect)
{ SetClientSize( rect.width, rect.height ); }
// get the window position and/or size
virtual void GetPosition( int *x, int *y ) const;
wxPoint GetPosition() const
{
int w, h;
GetPosition(& w, & h);
return wxPoint(w, h);
}
virtual void GetSize( int *width, int *height ) const;
wxSize GetSize() const
{
int w, h;
GetSize(& w, & h);
return wxSize(w, h);
}
wxRect GetRect() const
{
int x, y, w, h;
GetPosition(& x, & y);
GetSize(& w, & h);
return wxRect(x, y, w, h);
}
virtual void GetClientSize( int *width, int *height ) const;
wxSize GetClientSize() const
{
int w, h;
GetClientSize(& w, & h);
return wxSize(w, h);
}
// position with respect to the the parent window
virtual void Centre( int direction = wxHORIZONTAL );
void Center(int direction = wxHORIZONTAL) { Centre(direction); }
virtual void Fit();
// set min/max size of the window
virtual void SetSizeHints( int minW, int minH,
int maxW = -1, int maxH = -1,
int incW = -1, int incH = -1 );
// Dialog units translations. Implemented in wincmn.cpp.
// -----------------------------------------------------
wxPoint ConvertPixelsToDialog( const wxPoint& pt );
wxPoint ConvertDialogToPixels( const wxPoint& pt );
wxSize ConvertPixelsToDialog( const wxSize& sz )
{
wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));
return wxSize(pt.x, pt.y);
}
wxSize ConvertDialogToPixels( const wxSize& sz )
{
wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));
return wxSize(pt.x, pt.y);
}
void OnSize( wxSizeEvent &event );
// window state
// ------------
virtual bool Show( bool show );
virtual void Enable( bool enable );
virtual void MakeModal( bool modal );
virtual bool IsEnabled() const { return m_isEnabled; }
inline bool Enabled() const { return IsEnabled(); }
virtual void SetFocus();
static wxWindow *FindFocus();
void SetReturnCode( int retCode );
int GetReturnCode();
// parent/children relations
// -------------------------
virtual void AddChild( wxWindow *child );
wxList& GetChildren() { return m_children; }
virtual void RemoveChild( wxWindow *child );
wxWindow *GetParent() const
{ return m_parent; }
wxWindow *GetGrandParent() const
{ return (m_parent ? m_parent->m_parent : (wxWindow*)NULL); }
void SetParent( wxWindow *parent )
{ m_parent = parent; }
virtual wxWindow *ReParent( wxWindow *newParent );
// event handler stuff
// -------------------
wxEvtHandler *GetEventHandler() const;
void SetEventHandler( wxEvtHandler *handler );
void PushEventHandler( wxEvtHandler *handler );
wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
// validators and client data
// --------------------------
virtual void SetValidator( const wxValidator &validator );
virtual wxValidator *GetValidator();
virtual void SetClientObject( wxClientData *data );
virtual wxClientData *GetClientObject();
virtual void SetClientData( void *data );
virtual void *GetClientData();
// accelerators
// ------------
virtual void SetAcceleratorTable( const wxAcceleratorTable& accel );
virtual wxAcceleratorTable *GetAcceleratorTable() { return &m_acceleratorTable; }
void SetId( wxWindowID id );
wxWindowID GetId() const;
void SetCursor( const wxCursor &cursor );
virtual void PrepareDC( wxDC &dc );
void WarpPointer(int x, int y);
#if wxUSE_TOOLTIPS
void SetToolTip( const wxString &tip );
virtual void SetToolTip( wxToolTip *tip );
wxToolTip* GetToolTip() const { return m_toolTip; }
#endif // wxUSE_TOOLTIPS
virtual void Refresh( bool eraseBackground = TRUE, const wxRect *rect = (const wxRect *) NULL );
virtual void Clear();
virtual wxRegion GetUpdateRegion() const;
virtual bool IsExposed( int x, int y ) const;
virtual bool IsExposed( int x, int y, int w, int h ) const;
virtual bool IsExposed( const wxPoint& pt ) const;
virtual bool IsExposed( const wxRect& rect ) const;
// colours
// -------
virtual wxColour GetBackgroundColour() const;
virtual void SetBackgroundColour( const wxColour &colour );
virtual wxColour GetForegroundColour() const;
virtual void SetForegroundColour( const wxColour &colour );
// fonts
// -----
virtual int GetCharHeight() const;
virtual int GetCharWidth() const;
virtual void GetTextExtent( const wxString& string, int *x, int *y,
int *descent = (int *) NULL,
int *externalLeading = (int *) NULL,
const wxFont *theFont = (const wxFont *) NULL, bool use16 = FALSE) const;
virtual void SetFont( const wxFont &font );
virtual wxFont& GetFont() { return m_font; }
// For backward compatibility
virtual void SetButtonFont(const wxFont& font) { SetFont(font); }
virtual void SetLabelFont(const wxFont& font) { SetFont(font); }
virtual wxFont& GetLabelFont() { return GetFont(); };
virtual wxFont& GetButtonFont() { return GetFont(); };
virtual void SetWindowStyleFlag( long flag );
virtual long GetWindowStyleFlag() const;
virtual void CaptureMouse();
virtual void ReleaseMouse();
virtual void SetTitle( const wxString &title );
virtual wxString GetTitle() const;
virtual void SetName( const wxString &name );
virtual wxString GetName() const;
virtual wxString GetLabel() const;
void OnSysColourChanged( wxSysColourChangedEvent &WXUNUSED(event) ) { }
void OnKeyDown( wxKeyEvent &event );
virtual bool IsShown() const;
virtual void Raise();
virtual void Lower();
virtual bool IsRetained();
virtual wxWindow *FindWindow( long id );
virtual wxWindow *FindWindow( const wxString& name );
virtual bool Show( bool show = TRUE );
virtual bool Enable( bool enable = TRUE );
void AllowDoubleClick( bool WXUNUSED(allow) ) { }
void SetDoubleClick( bool WXUNUSED(allow) ) { }
virtual bool IsRetained() const;
virtual void ClientToScreen( int *x, int *y );
virtual void ScreenToClient( int *x, int *y );
virtual void SetFocus();
virtual bool AcceptsFocus() const;
virtual bool Validate();
virtual bool TransferDataToWindow();
virtual bool TransferDataFromWindow();
void OnInitDialog( wxInitDialogEvent &event );
virtual void InitDialog();
virtual bool Reparent( wxWindow *newParent );
virtual void WarpPointer(int x, int y);
virtual void CaptureMouse();
virtual void ReleaseMouse();
virtual void Refresh( bool eraseBackground = TRUE,
const wxRect *rect = (const wxRect *) NULL );
virtual void Clear();
virtual bool SetBackgroundColour( const wxColour &colour );
virtual bool SetForegroundColour( const wxColour &colour );
virtual bool SetCursor( const wxCursor &cursor );
virtual bool SetFont( const wxFont &font );
virtual int GetCharHeight() const;
virtual int GetCharWidth() const;
virtual void GetTextExtent(const wxString& string,
int *x, int *y,
int *descent = (int *) NULL,
int *externalLeading = (int *) NULL,
const wxFont *theFont = (const wxFont *) NULL)
const;
virtual void ClientToScreen( int *x, int *y ) const;
virtual void ScreenToClient( int *x, int *y ) const;
virtual bool PopupMenu( wxMenu *menu, int x, int y );
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget );
virtual wxDropTarget *GetDropTarget() const;
#endif
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;
virtual void ScrollWindow( int dx, int dy, const wxRect* rect = (wxRect *) NULL );
virtual void ScrollWindow( int dx, int dy,
const wxRect* rect = (wxRect *) NULL );
virtual bool AcceptsFocus() const;
void UpdateWindowUI();
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget );
#endif // wxUSE_DRAG_AND_DROP
// implementation
// --------------
bool HasVMT();
// wxWindows callbacks
void OnKeyDown( wxKeyEvent &event );
// simple accessors
bool HasVMT() const { return m_hasVMT; }
int GetX() const { return m_x; }
int GetY() const { return m_y; }
int GetWidth() const { return m_width; }
int GetHeight() const { return m_height; }
GtkWidget *GetWxWindow() const { return m_wxwindow; }
GtkWidget *GetWidget() const { return GetHandle(); }
GtkAdjustment *GetHAdjust() const { return m_hAdjust; }
GtkAdjustment *GetVAdjust() const { return m_vAdjust; }
float GetOldHorizontalPos() const { return m_oldHorizontalPos; }
float GetOldVerticalPos() const { return m_oldVerticalPos; }
void SetOldHorizontalPos(float fpos) { m_oldHorizontalPos = fpos; }
void SetOldVerticalPos(float fpos) { m_oldVerticalPos = fpos; }
bool IsSizeSet() const { return m_sizeSet; }
// also sets the global flag
void SetScrolling(bool scroll);
bool HasScrolling() const { return m_hasScrolling; }
bool IsScrolling() const { return m_isScrolling; }
bool IsStaticBox() const { return m_isStaticBox; }
/* I don't want users to override what's done in idle so everything that
has to be done in idle time in order for wxGTK to work is done in
@@ -418,6 +152,9 @@ public:
const wxSize &size, long style, const wxString &name );
void PostCreation();
void InsertChild(wxWindow *child) { (*m_insertCallback)(this, child); }
void DoAddChild(wxWindow *child) { AddChild(child); InsertChild(child); }
/* the methods below are required because many native widgets
are composed of several subwidgets and setting a style for
the widget means setting it for all subwidgets as well.
@@ -437,107 +174,57 @@ public:
virtual void ApplyToolTip( GtkTooltips *tips, const wxChar *tip );
#endif // wxUSE_TOOLTIPS
/* private member variables */
// called from GTK signales handlers
void UpdateSize() { m_sizeSet = FALSE; }
void InternalSetPosition(int x, int y) { m_x = x; m_y = y; }
void InternalSetSize(int w, int h)
{ m_width = w; m_height = h; UpdateSize(); }
wxWindow *m_parent;
wxList m_children;
protected:
// position and size of the window
int m_x, m_y;
int m_width, m_height;
int m_minWidth,m_minHeight;
int m_maxWidth,m_maxHeight;
int m_retCode;
wxEvtHandler *m_eventHandler;
wxValidator *m_windowValidator;
#if wxUSE_DRAG_AND_DROP
wxDropTarget *m_dropTarget;
#endif
wxWindowID m_windowId;
wxCursor m_cursor;
wxFont m_font;
wxColour m_backgroundColour;
wxColour m_foregroundColour;
wxRegion m_updateRegion;
long m_windowStyle;
bool m_isShown;
bool m_isEnabled;
wxString m_windowName;
wxAcceleratorTable m_acceleratorTable;
wxClientData *m_clientObject;
void *m_clientData;
#if wxUSE_TOOLTIPS
wxToolTip *m_toolTip;
#endif // wxUSE_TOOLTIPS
GtkWidget *m_widget;
// see the docs in src/gtk/window.cpp
GtkWidget *m_wxwindow;
// scrolling stuff
GtkAdjustment *m_hAdjust,*m_vAdjust;
float m_oldHorizontalPos;
float m_oldVerticalPos;
bool m_needParent; /* ! wxFrame, wxDialog, wxNotebookPage ? */
bool m_hasScrolling;
bool m_isScrolling;
bool m_hasVMT;
bool m_sizeSet;
bool m_resizing;
float m_oldHorizontalPos,
m_oldVerticalPos;
GdkGC *m_scrollGC;
// extra (wxGTK-specific) flags
bool m_needParent:1; /* ! wxFrame, wxDialog, wxNotebookPage ? */
bool m_hasScrolling:1;
bool m_isScrolling:1;
bool m_hasVMT:1;
bool m_sizeSet:1;
bool m_resizing:1;
bool m_isStaticBox:1; /* faster than IS_KIND_OF */
bool m_isFrame:1; /* faster than IS_KIND_OF */
bool m_acceptsFocus:1; /* ! wxStaticBox etc. */
GtkStyle *m_widgetStyle;
bool m_isStaticBox; /* faster than IS_KIND_OF */
bool m_isFrame; /* faster than IS_KIND_OF */
bool m_acceptsFocus; /* ! wxStaticBox etc. */
wxInsertChildFunction m_insertCallback;
public:
wxLayoutConstraints *m_constraints;
wxList *m_constraintsInvolvedIn;
wxSizer *m_windowSizer;
wxWindow *m_sizerParent;
bool m_autoLayout;
wxLayoutConstraints *GetConstraints() const;
void SetConstraints( wxLayoutConstraints *constraints );
void SetAutoLayout( bool autoLayout );
bool GetAutoLayout() const;
bool Layout();
void SetSizer( wxSizer *sizer );
wxSizer *GetSizer() const;
void SetSizerParent( wxWindow *win );
wxWindow *GetSizerParent() const;
void UnsetConstraints(wxLayoutConstraints *c);
inline wxList *GetConstraintsInvolvedIn() const ;
void AddConstraintReference(wxWindow *otherWin);
void RemoveConstraintReference(wxWindow *otherWin);
void DeleteRelatedConstraints();
virtual void ResetConstraints();
virtual void SetConstraintSizes(bool recurse = TRUE);
virtual bool LayoutPhase1(int *noChanges);
virtual bool LayoutPhase2(int *noChanges);
virtual bool DoPhase(int);
virtual void TransformSizerToActual(int *x, int *y) const ;
virtual void SizerSetSize(int x, int y, int w, int h);
virtual void SizerMove(int x, int y);
virtual void SetSizeConstraint(int x, int y, int w, int h);
virtual void MoveConstraint(int x, int y);
virtual void GetSizeConstraint(int *w, int *h) const ;
virtual void GetClientSizeConstraint(int *w, int *h) const ;
virtual void GetPositionConstraint(int *x, int *y) const ;
protected:
// common part of all ctors
void Init();
// this is the virtual function to be overriden in any derived class which
// wants to change how SetSize() or Move() works - it is called by all
// versions of these functions in the base class
// implement the base class pure virtuals
virtual void DoGetPosition( int *x, int *y ) const;
virtual void DoGetSize( int *width, int *height ) const;
virtual void DoGetClientSize( int *width, int *height ) const;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
// same as DoSetSize() for the client size
virtual void DoSetClientSize(int width, int height);
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip );
#endif // wxUSE_TOOLTIPS
// common part of all ctors (can't be virtual because called from ctor)
void Init();
private:
DECLARE_EVENT_TABLE()
};

149
include/wx/layout.h
View File

@@ -12,14 +12,16 @@
#ifndef _WX_LAYOUTH__
#define _WX_LAYOUTH__
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma interface "layout.h"
#endif
#include "wx/defs.h"
class WXDLLEXPORT wxWindow;
// X stupidly defines these in X.h
#ifdef Above
#undef Above
@@ -28,11 +30,28 @@ class WXDLLEXPORT wxWindow;
#undef Below
#endif
// ----------------------------------------------------------------------------
// forward declrations
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxWindowBase;
class WXDLLEXPORT wxLayoutConstraints;
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
#define wxLAYOUT_DEFAULT_MARGIN 0
enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY };
enum wxRelationship { wxUnconstrained = 0,
enum wxEdge
{
wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY
};
enum wxRelationship
{
wxUnconstrained = 0,
wxAsIs,
wxPercentOf,
wxAbove,
@@ -40,9 +59,26 @@ enum wxRelationship { wxUnconstrained = 0,
wxLeftOf,
wxRightOf,
wxSameAs,
wxAbsolute };
wxAbsolute
};
enum wxSizerBehaviour
{
wxSizerShrink,
wxSizerExpand,
wxSizerNone
};
#define wxTYPE_SIZER 90
// =============================================================================
// classes
// =============================================================================
// ----------------------------------------------------------------------------
// wxIndividualLayoutConstraint: a constraint on window position
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxLayoutConstraints;
class WXDLLEXPORT wxIndividualLayoutConstraint : public wxObject
{
DECLARE_DYNAMIC_CLASS(wxIndividualLayoutConstraint)
@@ -52,7 +88,7 @@ class WXDLLEXPORT wxIndividualLayoutConstraint: public wxObject
friend class wxIndividualLayoutConstraint_Serialize;
// 'This' window is the parent or sibling of otherWin
wxWindow *otherWin;
wxWindowBase *otherWin;
wxEdge myEdge;
wxRelationship relationship;
@@ -66,23 +102,23 @@ class WXDLLEXPORT wxIndividualLayoutConstraint: public wxObject
wxIndividualLayoutConstraint();
~wxIndividualLayoutConstraint();
void Set(wxRelationship rel, wxWindow *otherW, wxEdge otherE, int val = 0, int marg = wxLAYOUT_DEFAULT_MARGIN);
void Set(wxRelationship rel, wxWindowBase *otherW, wxEdge otherE, int val = 0, int marg = wxLAYOUT_DEFAULT_MARGIN);
//
// Sibling relationships
//
void LeftOf(wxWindow *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
void RightOf(wxWindow *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
void Above(wxWindow *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
void Below(wxWindow *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
void LeftOf(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
void RightOf(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
void Above(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
void Below(wxWindowBase *sibling, int marg = wxLAYOUT_DEFAULT_MARGIN);
//
// 'Same edge' alignment
//
void SameAs(wxWindow *otherW, wxEdge edge, int marg = wxLAYOUT_DEFAULT_MARGIN);
void SameAs(wxWindowBase *otherW, wxEdge edge, int marg = wxLAYOUT_DEFAULT_MARGIN);
// The edge is a percentage of the other window's edge
void PercentOf(wxWindow *otherW, wxEdge wh, int per);
void PercentOf(wxWindowBase *otherW, wxEdge wh, int per);
//
// Edge has absolute value
@@ -92,41 +128,45 @@ class WXDLLEXPORT wxIndividualLayoutConstraint: public wxObject
//
// Dimension is unconstrained
//
inline void Unconstrained() { relationship = wxUnconstrained; }
void Unconstrained() { relationship = wxUnconstrained; }
//
// Dimension is 'as is' (use current size settings)
//
inline void AsIs() { relationship = wxAsIs; }
void AsIs() { relationship = wxAsIs; }
//
// Accessors
//
inline wxWindow *GetOtherWindow() { return otherWin; }
inline wxEdge GetMyEdge() const { return myEdge; }
inline void SetEdge(wxEdge which) { myEdge = which; }
inline void SetValue(int v) { value = v; }
inline int GetMargin() { return margin; }
inline void SetMargin(int m) { margin = m; }
inline int GetValue() const { return value; }
inline int GetPercent() const { return percent; }
inline int GetOtherEdge() const { return otherEdge; }
inline bool GetDone() const { return done; }
inline void SetDone(bool d) { done = d; }
inline wxRelationship GetRelationship() { return relationship; }
inline void SetRelationship(wxRelationship r) { relationship = r; }
wxWindowBase *GetOtherWindow() { return otherWin; }
wxEdge GetMyEdge() const { return myEdge; }
void SetEdge(wxEdge which) { myEdge = which; }
void SetValue(int v) { value = v; }
int GetMargin() { return margin; }
void SetMargin(int m) { margin = m; }
int GetValue() const { return value; }
int GetPercent() const { return percent; }
int GetOtherEdge() const { return otherEdge; }
bool GetDone() const { return done; }
void SetDone(bool d) { done = d; }
wxRelationship GetRelationship() { return relationship; }
void SetRelationship(wxRelationship r) { relationship = r; }
// Reset constraint if it mentions otherWin
bool ResetIfWin(wxWindow *otherW);
bool ResetIfWin(wxWindowBase *otherW);
// Try to satisfy constraint
bool SatisfyConstraint(wxLayoutConstraints *constraints, wxWindow *win);
bool SatisfyConstraint(wxLayoutConstraints *constraints, wxWindowBase *win);
// Get the value of this edge or dimension, or if this
// is not determinable, -1.
int GetEdge(wxEdge which, wxWindow *thisWin, wxWindow *other) const;
int GetEdge(wxEdge which, wxWindowBase *thisWin, wxWindowBase *other) const;
};
// ----------------------------------------------------------------------------
// wxLayoutConstraints: the complete set of constraints for a window
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxLayoutConstraints : public wxObject
{
DECLARE_DYNAMIC_CLASS(wxLayoutConstraints)
@@ -147,7 +187,7 @@ class WXDLLEXPORT wxLayoutConstraints: public wxObject
wxLayoutConstraints();
~wxLayoutConstraints();
bool SatisfyConstraints(wxWindow *win, int *noChanges);
bool SatisfyConstraints(wxWindowBase *win, int *noChanges);
bool AreSatisfied() const
{
return left.GetDone() && top.GetDone() && right.GetDone() &&
@@ -155,7 +195,9 @@ class WXDLLEXPORT wxLayoutConstraints: public wxObject
}
};
bool WXDLLEXPORT wxOldDoLayout(wxWindow *win);
// ----------------------------------------------------------------------------
// sizers
// ----------------------------------------------------------------------------
/*
@@ -203,15 +245,6 @@ to the top of the hierarchy and call Layout() again.
*/
enum wxSizerBehaviour
{
wxSizerShrink,
wxSizerExpand,
wxSizerNone
};
#define wxTYPE_SIZER 90
class WXDLLEXPORT wxSizer : public wxWindow
{
DECLARE_DYNAMIC_CLASS(wxSizer)
@@ -227,10 +260,10 @@ protected:
public:
wxSizer();
wxSizer(wxWindow *parent, wxSizerBehaviour behav = wxSizerNone);
wxSizer(wxWindowBase *parent, wxSizerBehaviour behav = wxSizerNone);
~wxSizer();
bool Create(wxWindow *parent, wxSizerBehaviour behav = wxSizerNone);
bool Create(wxWindowBase *parent, wxSizerBehaviour behav = wxSizerNone);
virtual void GetSize(int *w, int *h) const;
@@ -245,8 +278,8 @@ public:
int GetBorderX() { return borderX ; }
int GetBorderY() { return borderY ; }
virtual void AddSizerChild(wxWindow *child);
virtual void RemoveSizerChild(wxWindow *child);
virtual void AddSizerChild(wxWindowBase *child);
virtual void RemoveSizerChild(wxWindowBase *child);
virtual void SetBehaviour(wxSizerBehaviour b) { sizerBehaviour = b; }
virtual wxSizerBehaviour GetBehaviour() { return sizerBehaviour; }
@@ -276,11 +309,11 @@ protected:
public:
// rowOrCol = TRUE to be laid out in rows, otherwise in columns.
wxRowColSizer();
wxRowColSizer(wxWindow *parent, bool rowOrCol = wxSIZER_ROWS,
wxRowColSizer(wxWindowBase *parent, bool rowOrCol = wxSIZER_ROWS,
int rowsOrColSize = 20, wxSizerBehaviour = wxSizerShrink);
~wxRowColSizer();
bool Create(wxWindow *parent, bool rowOrCol = wxSIZER_ROWS,
bool Create(wxWindowBase *parent, bool rowOrCol = wxSIZER_ROWS,
int rowsOrColSize = 20, wxSizerBehaviour = wxSizerShrink);
virtual void SetRowOrCol(bool rc) { rowOrCol = rc; }
@@ -300,13 +333,21 @@ DECLARE_DYNAMIC_CLASS(wxSpacingSizer)
public:
wxSpacingSizer();
wxSpacingSizer(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing);
wxSpacingSizer(wxWindow *parent);
wxSpacingSizer(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int spacing);
wxSpacingSizer(wxWindowBase *parent);
~wxSpacingSizer();
bool Create(wxWindow *parent, wxRelationship rel, wxWindow *other, int sp);
bool Create(wxWindow *parent);
bool Create(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int sp);
bool Create(wxWindowBase *parent);
};
// ----------------------------------------------------------------------------
// global functions
// ----------------------------------------------------------------------------
#if WXWIN_COMPATIBILITY
extern bool WXDLLEXPORT wxOldDoLayout(wxWindowBase *win);
#endif // WXWIN_COMPATIBILITY
#endif
// _WX_LAYOUTH__

32
include/wx/list.h
View File

@@ -142,7 +142,7 @@ public:
virtual ~wxNodeBase();
// @@ no check is done that the list is really keyed on strings
// FIXME no check is done that the list is really keyed on strings
const wxChar *GetKeyString() const { return m_key.string; }
long GetKeyInteger() const { return m_key.integer; }
@@ -339,8 +339,16 @@ private:
// 2. We redefine all non-type-safe wxList functions with type-safe versions
// which don't take any space (everything is inline), but bring compile
// time error checking.
//
// 3. The macro which is usually used (WX_DECLARE_LIST) is defined in terms of
// a more generic WX_DECLARE_LIST_2 macro which, in turn, uses the most
// generic WX_DECLARE_LIST_3 one. The last macro adds a sometimes
// interesting capability to store polymorphic objects in the list and is
// particularly useful with, for example, "wxWindow *" list where the
// wxWindowBase pointers are put into the list, but wxWindow pointers are
// retrieved from it.
#define WX_DECLARE_LIST_2(T, name, nodetype) \
#define WX_DECLARE_LIST_3(T, Tbase, name, nodetype) \
typedef int (*wxSortFuncFor_##name)(const T *, const T *); \
\
class WXDLLEXPORT nodetype : public wxNodeBase \
@@ -390,11 +398,11 @@ private:
return node ? (T*)(node->GetData()) : (T*)NULL; \
} \
\
nodetype *Append(T *object) \
nodetype *Append(Tbase *object) \
{ return (nodetype *)wxListBase::Append(object); } \
nodetype *Insert(T *object) \
nodetype *Insert(Tbase *object) \
{ return (nodetype *)Insert((nodetype*)NULL, object); } \
nodetype *Insert(nodetype *prev, T *object) \
nodetype *Insert(nodetype *prev, Tbase *object) \
{ return (nodetype *)wxListBase::Insert(prev, object); } \
\
nodetype *Append(long key, void *object) \
@@ -406,16 +414,16 @@ private:
{ return (nodetype *)wxListBase::DetachNode(node); } \
bool DeleteNode(nodetype *node) \
{ return wxListBase::DeleteNode(node); } \
bool DeleteObject(T *object) \
bool DeleteObject(Tbase *object) \
{ return wxListBase::DeleteObject(object); } \
\
nodetype *Find(T *object) const \
nodetype *Find(Tbase *object) const \
{ return (nodetype *)wxListBase::Find(object); } \
\
virtual nodetype *Find(const wxListKey& key) const \
{ return (nodetype *)wxListBase::Find(key); } \
\
int IndexOf( T *object ) const \
int IndexOf(Tbase *object) const \
{ return wxListBase::IndexOf(object); } \
\
void Sort(wxSortFuncFor_##name func) \
@@ -432,6 +440,9 @@ private:
} \
}
#define WX_DECLARE_LIST_2(elementtype, listname, nodename) \
WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename)
#define WX_DECLARE_LIST(elementtype, listname) \
typedef elementtype _WX_LIST_ITEM_TYPE_##listname; \
WX_DECLARE_LIST_2(elementtype, listname, wx##listname##Node)
@@ -445,12 +456,9 @@ private:
// =============================================================================
// ----------------------------------------------------------------------------
// commonly used string classes
// commonly used list classes
// ----------------------------------------------------------------------------
class wxWindow;
WX_DECLARE_LIST(wxWindow, wxWindowList);
#ifdef wxLIST_COMPATIBILITY
// -----------------------------------------------------------------------------

2
include/wx/tbarbase.h
View File

@@ -158,7 +158,7 @@ class WXDLLEXPORT wxToolBarBase : public wxControl
#endif
// Lay the tools out
virtual void Layout(void);
virtual void LayoutTools();
// Add all the buttons: required for Win95.
virtual bool CreateTools(void) { return TRUE; }

4
include/wx/tbarsmpl.h
View File

@@ -62,10 +62,10 @@ class WXDLLEXPORT wxToolBarSimple : public wxToolBarBase
virtual void SpringUpButton(int index);
void Layout(void);
virtual void LayoutTools();
// The post-tool-addition call
bool Realize() { Layout(); return TRUE; };
virtual bool Realize() { LayoutTools(); return TRUE; };
protected:
int m_currentRowsOrColumns;

12
include/wx/validate.h
View File

@@ -18,7 +18,7 @@
#include "wx/event.h"
class WXDLLEXPORT wxWindow;
class WXDLLEXPORT wxWindowBase;
/*
A validator has up to three purposes:
@@ -36,7 +36,7 @@ class WXDLLEXPORT wxValidator : public wxEvtHandler
{
public:
wxValidator();
~wxValidator();
virtual ~wxValidator();
// Make a clone of this validator (or return NULL) - currently necessary
// if you're passing a reference to a validator.
@@ -49,7 +49,7 @@ public:
// Called when the value in the window must be validated.
// This function can pop up an error message.
virtual bool Validate(wxWindow *WXUNUSED(parent)) { return FALSE; };
virtual bool Validate(wxWindowBase *WXUNUSED(parent)) { return FALSE; };
// Called to transfer data to the window
virtual bool TransferToWindow() { return FALSE; }
@@ -58,8 +58,8 @@ public:
virtual bool TransferFromWindow() { return FALSE; };
// accessors
wxWindow *GetWindow() const { return m_validatorWindow; }
void SetWindow(wxWindow *win) { m_validatorWindow = win; }
wxWindowBase *GetWindow() const { return m_validatorWindow; }
void SetWindow(wxWindowBase *win) { m_validatorWindow = win; }
// validators beep by default if invalid key is pressed, these functions
// allow to change it
@@ -67,7 +67,7 @@ public:
static void SetBellOnError(bool doIt = TRUE) { ms_isSilent = doIt; }
protected:
wxWindow *m_validatorWindow;
wxWindowBase *m_validatorWindow;
private:
static bool ms_isSilent;

743
include/wx/window.h
View File

@@ -1,6 +1,731 @@
///////////////////////////////////////////////////////////////////////////////
// Name: window.h
// Purpose: wxWindowBase class - the interface of wxWindowBase
// Author: Vadim Zeitlin
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) wxWindows team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WINDOW_H_BASE_
#define _WX_WINDOW_H_BASE_
// ----------------------------------------------------------------------------
// headers which we must include here
// ----------------------------------------------------------------------------
#include "wx/event.h" // the base class
#include "wx/list.h" // defines wxWindowList
#include "wx/cursor.h" // we have member variables of these classes
#include "wx/font.h" // so we can't do without them
#include "wx/colour.h"
#include "wx/region.h"
#include "wx/accel.h"
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxClientData;
class WXDLLEXPORT wxControl;
class WXDLLEXPORT wxCursor;
class WXDLLEXPORT wxDc;
class WXDLLEXPORT wxDropTarget;
class WXDLLEXPORT wxItemResource;
class WXDLLEXPORT wxLayoutConstraints;
class WXDLLEXPORT wxResourceTable;
class WXDLLEXPORT wxSizer;
class WXDLLEXPORT wxToolTip;
class WXDLLEXPORT wxValidator;
class WXDLLEXPORT wxWindowBase;
class WXDLLEXPORT wxWindow;
// ----------------------------------------------------------------------------
// (pseudo)template list classes
// ----------------------------------------------------------------------------
WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode);
// ----------------------------------------------------------------------------
// global variables
// ----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern wxWindowList) wxTopLevelWindows;
// ----------------------------------------------------------------------------
// helper classes used by [SG]etClientObject/Data
//
// TODO move into a separate header?
// ----------------------------------------------------------------------------
class wxClientData
{
public:
wxClientData() { }
virtual ~wxClientData() { }
};
class wxStringClientData : public wxClientData
{
public:
wxStringClientData() { }
wxStringClientData( const wxString &data ) : m_data(data) { }
void SetData( const wxString &data ) { m_data = data; }
const wxString& GetData() const { return m_data; }
private:
wxString m_data;
};
// ----------------------------------------------------------------------------
// wxWindowBase is the base class for all GUI controls/widgets, this is the public
// interface of this class.
//
// Event handler: windows have themselves as their event handlers by default,
// but their event handlers could be set to another object entirely. This
// separation can reduce the amount of derivation required, and allow
// alteration of a window's functionality (e.g. by a resource editor that
// temporarily switches event handlers).
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxWindowBase : public wxEvtHandler
{
DECLARE_ABSTRACT_CLASS(wxWindowBase);
public:
// creating the window
// -------------------
// default ctor
wxWindowBase() { InitBase(); }
// pseudo ctor (can't be virtual, called from ctor)
bool CreateBase(wxWindowBase *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
virtual ~wxWindowBase();
#if wxUSE_WX_RESOURCES
// these functions are implemented in resource.cpp and resourc2.cpp
virtual bool LoadFromResource(wxWindow *parent,
const wxString& resourceName,
const wxResourceTable *table = (const wxResourceTable *) NULL);
virtual wxControl *CreateItem(const wxItemResource* childResource,
const wxItemResource* parentResource,
const wxResourceTable *table = (const wxResourceTable *) NULL);
#endif // wxUSE_WX_RESOURCES
// deleting the window
// -------------------
// ask the window to close itself, return TRUE if the event handler
// honoured our request
bool Close( bool force = FALSE );
// the following functions delete the C++ objects (the window itself
// or its children) as well as the GUI windows and normally should
// never be used directly
// delete window unconditionally (dangerous!), returns TRUE if ok
virtual bool Destroy();
// delete all children of this window, returns TRUE if ok
bool DestroyChildren();
// is the window being deleted?
bool IsBeingDeleted() const { return m_isBeingDeleted; }
// window attributes
// -----------------
// the title (or label, see below) of the window: the text which the
// window shows
virtual void SetTitle( const wxString & WXUNUSED(title) ) { }
virtual wxString GetTitle() const { return ""; }
// label is just the same as the title (but for, e.g., buttons it
// makes more sense to speak about labels)
wxString GetLabel() const { return GetTitle(); }
// the window name is used for ressource setting in X, it is not the
// same as the window title/label
virtual void SetName( const wxString &name ) { m_windowName = name; }
virtual wxString GetName() const { return m_windowName; }
// window id uniquely identifies the window among its siblings unless
// it is -1 which means "don't care"
void SetId( wxWindowID id ) { m_windowId = id; }
wxWindowID GetId() const { return m_windowId; }
// generate a control id for the controls which were not given one by
// user
static int NewControlId() { return ++ms_lastControlId; }
// moving/resizing
// ---------------
// set the window size and/or position
void SetSize( int x, int y, int width, int height,
int sizeFlags = wxSIZE_AUTO )
{ DoSetSize(x, y, width, height, sizeFlags); }
void SetSize( int width, int height )
{ DoSetSize( -1, -1, width, height, wxSIZE_USE_EXISTING ); }
void SetSize( const wxSize& size )
{ SetSize( size.x, size.y); }
void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO)
{ DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); }
void Move( int x, int y )
{ DoSetSize( x, y, -1, -1, wxSIZE_USE_EXISTING ); }
void Move(const wxPoint& pt)
{ Move(pt.x, pt.y); }
// Z-order
virtual void Raise() = 0;
virtual void Lower() = 0;
// client size is the size of area available for subwindows
void SetClientSize( int width, int height )
{ DoSetClientSize(width, height); }
void SetClientSize( const wxSize& size )
{ DoSetClientSize(size.x, size.y); }
void SetClientSize(const wxRect& rect)
{ SetClientSize( rect.width, rect.height ); }
// get the window position and/or size (pointers may be NULL)
void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); }
wxPoint GetPosition() const
{
int w, h;
DoGetPosition(&w, &h);
return wxPoint(w, h);
}
void GetSize( int *w, int *h ) const { DoGetSize(w, h); }
wxSize GetSize() const
{
int w, h;
DoGetSize(& w, & h);
return wxSize(w, h);
}
wxRect GetRect() const
{
int x, y, w, h;
GetPosition(& x, & y);
GetSize(& w, & h);
return wxRect(x, y, w, h);
}
void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); }
wxSize GetClientSize() const
{
int w, h;
DoGetClientSize(& w, & h);
return wxSize(w, h);
}
// centre with respect to the the parent window
void Centre( int direction = wxHORIZONTAL );
void Center( int direction = wxHORIZONTAL ) { Centre(direction); }
// set window size to wrap around its children
virtual void Fit();
// set min/max size of the window
virtual void SetSizeHints( int minW, int minH,
int maxW = -1, int maxH = -1,
int incW = -1, int incH = -1 );
// window state
// ------------
// returns TRUE if window was shown/hidden, FALSE if the nothing was
// done (window was already shown/hidden)
virtual bool Show( bool show = TRUE );
bool Hide() { return Show(FALSE); }
// returns TRUE if window was enabled/disabled, FALSE if nothing done
virtual bool Enable( bool enable = TRUE );
bool Disable() { return Enable(FALSE); }
bool IsShown() const { return m_isShown; }
bool IsEnabled() const { return m_isEnabled; }
// get/set window style (setting style won't update the window and so
// is only useful for internal usage)
virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; }
virtual long GetWindowStyleFlag() const { return m_windowStyle; }
// just some (somewhat shorter) synonims
void SetWindowStyle( long style ) { SetWindowStyleFlag(style); }
long GetWindowStyle() const { return GetWindowStyleFlag(); }
bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; }
virtual bool IsRetained() const
{ return (m_windowStyle & wxRETAINED) != 0; }
// make the window modal (all other windows unresponsive)
virtual void MakeModal(bool modal = TRUE);
// focus handling
// --------------
// set focus to this window
virtual void SetFocus() = 0;
// return the window which currently has the focus or NULL
static wxWindow *FindFocus() /* = 0: implement in derived classes */;
// can this window have focus?
virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
// parent/children relations
// -------------------------
// get the list of children
const wxWindowList& GetChildren() const { return m_children; }
wxWindowList& GetChildren() { return m_children; }
// get the parent or the parent of the parent
wxWindow *GetParent() const { return m_parent; }
inline wxWindow *GetGrandParent() const;
// is this window a top level one?
bool IsTopLevel() const { return m_parent != 0; }
// it doesn't really change parent, use ReParent() instead
void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; }
// change the real parent of this window, return TRUE if the parent
// was changed, FALSE otherwise (error or newParent == oldParent)
virtual bool Reparent( wxWindowBase *newParent );
// find window among the descendants of this one either by id or by
// name (return NULL if not found)
wxWindow *FindWindow( long id );
wxWindow *FindWindow( const wxString& name );
// implementation mostly
virtual void AddChild( wxWindowBase *child );
virtual void RemoveChild( wxWindowBase *child );
// event handler stuff
// -------------------
// get the current event handler
wxEvtHandler *GetEventHandler() const { return m_eventHandler; }
// replace the event handler (allows to completely subclass the
// window)
void SetEventHandler( wxEvtHandler *handler ) { m_eventHandler = handler; }
// push/pop event handler: allows to chain a custom event handler to
// alreasy existing ones
void PushEventHandler( wxEvtHandler *handler );
wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
// validators and client data
// --------------------------
// a window may have an associated validator which is used to control
// user input
virtual void SetValidator( const wxValidator &validator );
virtual wxValidator *GetValidator() { return m_windowValidator; }
// each window may have associated client data: either a pointer to
// wxClientData object in which case it is managed by the window (i.e.
// it will delete the data when it's destroyed) or an untyped pointer
// which won't be deleted by the window
virtual void SetClientObject( wxClientData *data )
{
if ( m_clientObject )
delete m_clientObject;
m_clientObject = data;
}
virtual wxClientData *GetClientObject() const { return m_clientObject; }
virtual void SetClientData( void *data ) { m_clientData = data; }
virtual void *GetClientData() const { return m_clientData; }
// dialog oriented functions
// -------------------------
// validate the correctness of input, return TRUE if ok
virtual bool Validate();
// transfer data between internal and GUI representations
virtual bool TransferDataToWindow();
virtual bool TransferDataFromWindow();
virtual void InitDialog();
// accelerators
// ------------
virtual void SetAcceleratorTable( const wxAcceleratorTable& accel )
{ m_acceleratorTable = accel; }
wxAcceleratorTable *GetAcceleratorTable()
{ return &m_acceleratorTable; }
// dialog units translations
// -------------------------
wxPoint ConvertPixelsToDialog( const wxPoint& pt );
wxPoint ConvertDialogToPixels( const wxPoint& pt );
wxSize ConvertPixelsToDialog( const wxSize& sz )
{
wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y)));
return wxSize(pt.x, pt.y);
}
wxSize ConvertDialogToPixels( const wxSize& sz )
{
wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y)));
return wxSize(pt.x, pt.y);
}
// mouse functions
// ---------------
// move the mouse to the specified position
virtual void WarpPointer(int x, int y) = 0;
// start or end mouse capture
virtual void CaptureMouse() = 0;
virtual void ReleaseMouse() = 0;
// painting the window
// -------------------
// mark the specified rectangle (or the whole window) as "dirty" so it
// will be repainted
virtual void Refresh( bool eraseBackground = TRUE,
const wxRect *rect = (const wxRect *) NULL ) = 0;
// clear the window entirely
virtual void Clear() = 0;
// adjust DC for drawing on this window
virtual void PrepareDC( wxDC &dc ) { }
// the update region of the window contains the areas which must be
// repainted by the program
const wxRegion& GetUpdateRegion() const { return m_updateRegion; }
wxRegion& GetUpdateRegion() { return m_updateRegion; }
// these functions verify whether the given point/rectangle belongs to
// (or at least intersects with) the update region
bool IsExposed( int x, int y ) const;
bool IsExposed( int x, int y, int w, int h ) const;
bool IsExposed( const wxPoint& pt ) const
{ return IsExposed(pt.x, pt.y); }
bool IsExposed( const wxRect& rect ) const
{ return IsExposed(rect.x, rect.y, rect.width, rect.height); }
// colours, fonts and cursors
// --------------------------
// set/retrieve the window colours (system defaults are used by
// default): Set functions return TRUE if colour was changed
virtual bool SetBackgroundColour( const wxColour &colour );
virtual bool SetForegroundColour( const wxColour &colour );
wxColour GetBackgroundColour() const { return m_backgroundColour; }
wxColour GetForegroundColour() const { return m_foregroundColour; }
// set/retrieve the cursor for this window (SetCursor() returns TRUE
// if the cursor was really changed)
virtual bool SetCursor( const wxCursor &cursor );
const wxCursor& GetCursor() const { return m_cursor; }
wxCursor& GetCursor() { return m_cursor; }
// set/retrieve the font for the window (SetFont() returns TRUE if the
// font really changed)
virtual bool SetFont( const wxFont &font ) = 0;
const wxFont& GetFont() const { return m_font; }
wxFont& GetFont() { return m_font; }
// get the (average) character size for the current font
virtual int GetCharHeight() const = 0;
virtual int GetCharWidth() const = 0;
// get the width/height/... of the text using current or specified
// font
virtual void GetTextExtent(const wxString& string,
int *x, int *y,
int *descent = (int *) NULL,
int *externalLeading = (int *) NULL,
const wxFont *theFont = (const wxFont *) NULL)
const = 0;
// translate to/from screen/client coordinates (pointers may be NULL)
virtual void ClientToScreen( int *x, int *y ) const = 0;
virtual void ScreenToClient( int *x, int *y ) const = 0;
// misc
// ----
void UpdateWindowUI();
virtual bool PopupMenu( wxMenu *menu, int x, int y ) = 0;
// scrollbars
// ----------
// configure the window scrollbars
virtual void SetScrollbar( int orient,
int pos,
int thumbVisible,
int range,
bool refresh = TRUE ) = 0;
virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE ) = 0;
virtual int GetScrollPos( int orient ) const = 0;
virtual int GetScrollThumb( int orient ) const = 0;
virtual int GetScrollRange( int orient ) const = 0;
// scroll window to the specified position
virtual void ScrollWindow( int dx, int dy,
const wxRect* rect = (wxRect *) NULL ) = 0;
// tooltips
// --------
#if wxUSE_TOOLTIPS
// the easiest way to set a tooltip for a window is to use this method
void SetToolTip( const wxString &tip );
// attach a tooltip to the window
void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); }
// get the associated tooltip or NULL if none
wxToolTip* GetToolTip() const { return m_tooltip; }
#endif // wxUSE_TOOLTIPS
// drag and drop
// -------------
#if wxUSE_DRAG_AND_DROP
// set/retrieve the drop target associated with this window (may be
// NULL; it's owned by the window and will be deleted by it)
virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0;
virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; }
#endif // wxUSE_DRAG_AND_DROP
// constraints and sizers
// ----------------------
#if wxUSE_CONSTRAINTS
// set the constraints for this window or retrieve them (may be NULL)
void SetConstraints( wxLayoutConstraints *constraints );
wxLayoutConstraints *GetConstraints() const { return m_constraints; }
// when using constraints, it makes sense to update children positions
// automatically whenever the window is resized - this is done if
// autoLayout is on
void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; }
bool GetAutoLayout() const { return m_autoLayout; }
// do layout the window and its children
virtual bool Layout();
// implementation only
void UnsetConstraints(wxLayoutConstraints *c);
wxWindowList *GetConstraintsInvolvedIn() const
{ return m_constraintsInvolvedIn; }
void AddConstraintReference(wxWindowBase *otherWin);
void RemoveConstraintReference(wxWindowBase *otherWin);
void DeleteRelatedConstraints();
void ResetConstraints();
// these methods may be overriden for special layout algorithms
virtual void SetConstraintSizes(bool recurse = TRUE);
virtual bool LayoutPhase1(int *noChanges);
virtual bool LayoutPhase2(int *noChanges);
virtual bool DoPhase(int);
// these methods are virtual but normally won't be overridden
virtual void TransformSizerToActual(int *x, int *y) const ;
virtual void SetSizeConstraint(int x, int y, int w, int h);
virtual void MoveConstraint(int x, int y);
virtual void GetSizeConstraint(int *w, int *h) const ;
virtual void GetClientSizeConstraint(int *w, int *h) const ;
virtual void GetPositionConstraint(int *x, int *y) const ;
// sizers
// TODO: what are they and how do they work??
void SetSizer( wxSizer *sizer );
wxSizer *GetSizer() const { return m_windowSizer; }
void SetSizerParent( wxWindowBase *win ) { m_sizerParent = win; }
wxWindowBase *GetSizerParent() const { return m_sizerParent; }
virtual void SizerSetSize(int x, int y, int w, int h);
virtual void SizerMove(int x, int y);
#endif // wxUSE_CONSTRAINTS
// backward compatibility
// ----------------------
#if WXWIN_COMPATIBILITY
bool Enabled() const { return IsEnabled(); }
void SetButtonFont(const wxFont& font) { SetFont(font); }
void SetLabelFont(const wxFont& font) { SetFont(font); }
wxFont& GetLabelFont() { return GetFont(); };
wxFont& GetButtonFont() { return GetFont(); };
#endif // WXWIN_COMPATIBILITY
// implementation
// --------------
// event handlers
void OnSysColourChanged( wxSysColourChangedEvent& event );
void OnInitDialog( wxInitDialogEvent &event );
// accessors
WXWidget GetHandle() const { return m_widget; }
protected:
// the window handle (for the underlying windowing system) and the window
// id - a number which uniquely identifies a window among its siblings
// unless it is -1
WXWidget m_widget;
wxWindowID m_windowId;
// the parent window of this window (or NULL) and the list of the children
// of this window
wxWindow *m_parent;
wxWindowList m_children;
// the minimal allowed size for the window (no minimal size if variable(s)
// contain(s) -1)
int m_minWidth, m_minHeight, m_maxWidth, m_maxHeight;
// event handler for this window: usually is just 'this' but may be
// changed with SetEventHandler()
wxEvtHandler *m_eventHandler;
// associated validator or NULL if none
wxValidator *m_windowValidator;
#if wxUSE_DRAG_AND_DROP
wxDropTarget *m_dropTarget;
#endif // wxUSE_DRAG_AND_DROP
// visual window attributes
wxCursor m_cursor;
wxFont m_font;
wxColour m_backgroundColour, m_foregroundColour;
// the region which should be repainted in response to paint event
wxRegion m_updateRegion;
// the accelerator table for the window which translates key strokes into
// command events
wxAcceleratorTable m_acceleratorTable;
// user data associated with the window: either an object which will be
// deleted by the window when it's deleted or some raw pointer which we do
// nothing with
wxClientData *m_clientObject;
void *m_clientData;
// the tooltip for this window (may be NULL)
#if wxUSE_TOOLTIPS
wxToolTip *m_tooltip;
#endif // wxUSE_TOOLTIPS
// constraints and sizers
#if wxUSE_CONSTRAINTS
// the constraints for this window or NULL
wxLayoutConstraints *m_constraints;
// constraints this window is involved in
wxWindowList *m_constraintsInvolvedIn;
// top level and the parent sizers
// TODO what's this and how does it work?)
wxSizer *m_windowSizer;
wxWindowBase *m_sizerParent;
// Layout() window automatically when its size changes?
bool m_autoLayout:1;
#endif // wxUSE_CONSTRAINTS
// window state
bool m_isShown:1;
bool m_isEnabled:1;
bool m_isBeingDeleted:1;
// window attributes
long m_windowStyle;
wxString m_windowName;
protected:
// common part of all ctors: it is not virtual because it is called from
// ctor
void InitBase();
// get the default size for the new window if no explicit size given
// FIXME why 20 and not 30, 10 or ...?
static int WidthDefault(int w) { return w == -1 ? 20 : w; }
static int HeightDefault(int h) { return h == -1 ? 20 : h; }
// more pure virtual functions
// ---------------------------
// NB: we must have DoSomething() function when Something() is an overloaded
// method: indeed, we can't just have "virtual Something()" in case when
// the function is overloaded because then we'd have to make virtual all
// the variants (otherwise only the virtual function may be called on a
// pointer to derived class according to C++ rules) which is, in
// general, absolutely not needed. So instead we implement all
// overloaded Something()s in terms of DoSomething() which will be the
// only one to be virtual.
// retrieve the position/size of the window
virtual void DoGetPosition( int *x, int *y ) const = 0;
virtual void DoGetSize( int *width, int *height ) const = 0;
virtual void DoGetClientSize( int *width, int *height ) const = 0;
// this is the virtual function to be overriden in any derived class which
// wants to change how SetSize() or Move() works - it is called by all
// versions of these functions in the base class
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) = 0;
// same as DoSetSize() for the client size
virtual void DoSetClientSize(int width, int height) = 0;
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip );
#endif // wxUSE_TOOLTIPS
private:
// contains the last id generated by NewControlId
static int ms_lastControlId;
DECLARE_EVENT_TABLE()
};
// ----------------------------------------------------------------------------
// now include the declaration of wxWindow class
// ----------------------------------------------------------------------------
#if defined(__WXMSW__)
#include "wx/msw/window.h"
#elif defined(__WXMOTIF__)
@@ -11,9 +736,23 @@
#include "wx/qt/window.h"
#elif defined(__WXMAC__)
#include "wx/mac/window.h"
#elif defined(__WXSTUBS__)
#include "wx/stubs/window.h"
#endif
// ----------------------------------------------------------------------------
// inline functions which couldn't be declared in the class body because of
// forward dependencies
// ----------------------------------------------------------------------------
wxWindow *wxWindowBase::GetGrandParent() const
{
return m_parent ? m_parent->GetParent() : (wxWindow *)NULL;
}
// ----------------------------------------------------------------------------
// global function
// ----------------------------------------------------------------------------
extern wxWindow* WXDLLEXPORT wxGetActiveWindow();
#endif
// _WX_WINDOW_H_BASE_

194
src/common/layout.cpp
View File

@@ -9,6 +9,13 @@
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// =============================================================================
// declarations
// =============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "layout.h"
#endif
@@ -27,7 +34,7 @@
#include "wx/utils.h"
#include "wx/dialog.h"
#include "wx/msgdlg.h"
#include <wx/intl.h>
#include "wx/intl.h"
#endif
#include "wx/layout.h"
@@ -64,7 +71,7 @@ TODO:
*/
// Find margin sizes if a sizer, or zero otherwise
int wxSizerMarginX(wxWindow *win)
int wxSizerMarginX(wxWindowBase *win)
{
if ( win->IsKindOf(CLASSINFO(wxSizer)) )
{
@@ -75,7 +82,7 @@ int wxSizerMarginX(wxWindow *win)
return 0;
}
int wxSizerMarginY(wxWindow *win)
int wxSizerMarginY(wxWindowBase *win)
{
if ( win->IsKindOf(CLASSINFO(wxSizer)) )
{
@@ -89,40 +96,65 @@ int wxSizerMarginY(wxWindow *win)
wxIndividualLayoutConstraint::wxIndividualLayoutConstraint()
{
myEdge = wxTop; relationship = wxUnconstrained; margin = 0; value = 0; percent = 0; otherEdge = wxTop;
done = FALSE; otherWin = (wxWindow *) NULL;
myEdge = wxTop;
relationship = wxUnconstrained;
margin = 0;
value = 0;
percent = 0;
otherEdge = wxTop;
done = FALSE;
otherWin = (wxWindowBase *) NULL;
}
wxIndividualLayoutConstraint::~wxIndividualLayoutConstraint()
{
}
void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindow *otherW, wxEdge otherE, int val, int marg)
void wxIndividualLayoutConstraint::Set(wxRelationship rel, wxWindowBase *otherW, wxEdge otherE, int val, int marg)
{
relationship = rel; otherWin = otherW; otherEdge = otherE; value = val; margin = marg;
relationship = rel;
otherWin = otherW;
otherEdge = otherE;
value = val;
margin = marg;
}
void wxIndividualLayoutConstraint::LeftOf(wxWindow *sibling, int marg)
{ Set(wxLeftOf, sibling, wxLeft, 0, marg); }
void wxIndividualLayoutConstraint::LeftOf(wxWindowBase *sibling, int marg)
{
Set(wxLeftOf, sibling, wxLeft, 0, marg);
}
void wxIndividualLayoutConstraint::RightOf(wxWindow *sibling, int marg)
{ Set(wxRightOf, sibling, wxRight, 0, marg); }
void wxIndividualLayoutConstraint::RightOf(wxWindowBase *sibling, int marg)
{
Set(wxRightOf, sibling, wxRight, 0, marg);
}
void wxIndividualLayoutConstraint::Above(wxWindow *sibling, int marg)
{ Set(wxAbove, sibling, wxTop, 0, marg); }
void wxIndividualLayoutConstraint::Above(wxWindowBase *sibling, int marg)
{
Set(wxAbove, sibling, wxTop, 0, marg);
}
void wxIndividualLayoutConstraint::Below(wxWindow *sibling, int marg)
{ Set(wxBelow, sibling, wxBottom, 0, marg); }
void wxIndividualLayoutConstraint::Below(wxWindowBase *sibling, int marg)
{
Set(wxBelow, sibling, wxBottom, 0, marg);
}
//
// 'Same edge' alignment
//
void wxIndividualLayoutConstraint::SameAs(wxWindow *otherW, wxEdge edge, int marg)
{ Set(wxPercentOf, otherW, edge, 0, marg); percent = 100; }
void wxIndividualLayoutConstraint::SameAs(wxWindowBase *otherW, wxEdge edge, int marg)
{
Set(wxPercentOf, otherW, edge, 0, marg);
percent = 100;
}
// The edge is a percentage of the other window's edge
void wxIndividualLayoutConstraint::PercentOf(wxWindow *otherW, wxEdge wh, int per)
{ otherWin = otherW; relationship = wxPercentOf; percent = per;
void wxIndividualLayoutConstraint::PercentOf(wxWindowBase *otherW, wxEdge wh, int per)
{
otherWin = otherW;
relationship = wxPercentOf;
percent = per;
otherEdge = wh;
}
@@ -130,15 +162,22 @@ void wxIndividualLayoutConstraint::PercentOf(wxWindow *otherW, wxEdge wh, int pe
// Edge has absolute value
//
void wxIndividualLayoutConstraint::Absolute(int val)
{ value = val; relationship = wxAbsolute; }
{
value = val; relationship = wxAbsolute;
}
// Reset constraint if it mentions otherWin
bool wxIndividualLayoutConstraint::ResetIfWin(wxWindow *otherW)
bool wxIndividualLayoutConstraint::ResetIfWin(wxWindowBase *otherW)
{
if (otherW == otherWin)
{
myEdge = wxTop; relationship = wxAsIs; margin = 0; value = 0; percent = 0; otherEdge = wxTop;
otherWin = (wxWindow *) NULL;
myEdge = wxTop;
relationship = wxAsIs;
margin = 0;
value = 0;
percent = 0;
otherEdge = wxTop;
otherWin = (wxWindowBase *) NULL;
return TRUE;
}
else
@@ -146,7 +185,7 @@ bool wxIndividualLayoutConstraint::ResetIfWin(wxWindow *otherW)
}
// Try to satisfy constraint
bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constraints, wxWindow *win)
bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constraints, wxWindowBase *win)
{
if (relationship == wxAbsolute)
{
@@ -162,9 +201,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
{
case wxLeftOf:
{
// We can know this edge if: otherWin is win's parent,
// or otherWin has a satisfied constraint, or
// otherWin has no constraint.
// We can know this edge if: otherWin is win's
// parent, or otherWin has a satisfied constraint,
// or otherWin has no constraint.
int edgePos = GetEdge(otherEdge, win, otherWin);
if (edgePos != -1)
{
@@ -202,7 +241,8 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
case wxUnconstrained:
{
// We know the left-hand edge position if we know
// the right-hand edge and we know the width; OR if we know the centre and the width.
// the right-hand edge and we know the width; OR if
// we know the centre and the width.
if (constraints->right.GetDone() && constraints->width.GetDone())
{
value = (constraints->right.GetValue() - constraints->width.GetValue() + margin);
@@ -236,9 +276,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
{
case wxLeftOf:
{
// We can know this edge if: otherWin is win's parent,
// or otherWin has a satisfied constraint, or
// otherWin has no constraint.
// We can know this edge if: otherWin is win's
// parent, or otherWin has a satisfied constraint,
// or otherWin has no constraint.
int edgePos = GetEdge(otherEdge, win, otherWin);
if (edgePos != -1)
{
@@ -275,8 +315,8 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
}
case wxUnconstrained:
{
// We know the right-hand edge position if we know
// the left-hand edge and we know the width, OR if we know the
// We know the right-hand edge position if we know the
// left-hand edge and we know the width, OR if we know the
// centre edge and the width.
if (constraints->left.GetDone() && constraints->width.GetDone())
{
@@ -314,9 +354,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
{
case wxAbove:
{
// We can know this edge if: otherWin is win's parent,
// or otherWin has a satisfied constraint, or
// otherWin has no constraint.
// We can know this edge if: otherWin is win's
// parent, or otherWin has a satisfied constraint,
// or otherWin has no constraint.
int edgePos = GetEdge(otherEdge, win, otherWin);
if (edgePos != -1)
{
@@ -353,9 +393,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
}
case wxUnconstrained:
{
// We know the top edge position if we know
// the bottom edge and we know the height; OR if we know the centre
// edge and the height.
// We know the top edge position if we know the bottom edge
// and we know the height; OR if we know the centre edge and
// the height.
if (constraints->bottom.GetDone() && constraints->height.GetDone())
{
value = (constraints->bottom.GetValue() - constraints->height.GetValue() + margin);
@@ -428,9 +468,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
}
case wxUnconstrained:
{
// We know the bottom edge position if we know
// the top edge and we know the height; OR if we know the
// centre edge and the height.
// We know the bottom edge position if we know the top edge
// and we know the height; OR if we know the centre edge and
// the height.
if (constraints->top.GetDone() && constraints->height.GetDone())
{
value = (constraints->top.GetValue() + constraints->height.GetValue() - margin);
@@ -467,9 +507,9 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
{
case wxLeftOf:
{
// We can know this edge if: otherWin is win's parent,
// or otherWin has a satisfied constraint, or
// otherWin has no constraint.
// We can know this edge if: otherWin is win's parent, or
// otherWin has a satisfied constraint, or otherWin has no
// constraint.
int edgePos = GetEdge(otherEdge, win, otherWin);
if (edgePos != -1)
{
@@ -536,8 +576,8 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
case wxAbove:
{
// We can know this edge if: otherWin is win's parent,
// or otherWin has a satisfied constraint, or
// otherWin has no constraint.
// or otherWin has a satisfied constraint, or otherWin
// has no constraint.
int edgePos = GetEdge(otherEdge, win, otherWin);
if (edgePos != -1)
{
@@ -719,17 +759,15 @@ bool wxIndividualLayoutConstraint::SatisfyConstraint(wxLayoutConstraints *constr
return FALSE;
}
// Get the value of this edge or dimension, or if this
// is not determinable, -1.
// Get the value of this edge or dimension, or if this is not determinable, -1.
int wxIndividualLayoutConstraint::GetEdge(wxEdge which,
wxWindow *thisWin,
wxWindow *other) const
wxWindowBase *thisWin,
wxWindowBase *other) const
{
// If the edge or dimension belongs to the parent, then we
// know the dimension is obtainable immediately.
// E.g. a wxExpandSizer may contain a button (but the button's
// true parent is a panel, not the sizer)
if (other->GetChildren().Member(thisWin))
// If the edge or dimension belongs to the parent, then we know the
// dimension is obtainable immediately. E.g. a wxExpandSizer may contain a
// button (but the button's true parent is a panel, not the sizer)
if (other->GetChildren().Find(thisWin))
{
switch (which)
{
@@ -959,7 +997,7 @@ wxLayoutConstraints::~wxLayoutConstraints()
{
}
bool wxLayoutConstraints::SatisfyConstraints(wxWindow *win, int *nChanges)
bool wxLayoutConstraints::SatisfyConstraints(wxWindowBase *win, int *nChanges)
{
int noChanges = 0;
@@ -1042,7 +1080,8 @@ bool wxLayoutConstraints::SatisfyConstraints(wxWindow *win, int *nChanges)
*/
bool wxOldDoLayout(wxWindow *win)
#if WXWIN_COMPATIBILITY
bool wxOldDoLayout(wxWindowBase *win)
{
// Make sure this isn't called recursively from below
static wxList doneSoFar;
@@ -1055,7 +1094,7 @@ bool wxOldDoLayout(wxWindow *win)
wxNode *node = win->GetChildren().First();
while (node)
{
wxWindow *child = (wxWindow *)node->Data();
wxWindowBase *child = (wxWindowBase *)node->Data();
wxLayoutConstraints *constr = child->GetConstraints();
if (constr)
{
@@ -1080,7 +1119,7 @@ bool wxOldDoLayout(wxWindow *win)
wxNode *node = win->GetChildren().First();
while (node)
{
wxWindow *child = (wxWindow *)node->Data();
wxWindowBase *child = (wxWindowBase *)node->Data();
wxLayoutConstraints *constr = child->GetConstraints();
if (constr)
{
@@ -1097,7 +1136,7 @@ bool wxOldDoLayout(wxWindow *win)
// failed, so we can print a specific diagnostic message.
if (noFailures > 0)
{
wxDebugMsg(_("wxWindow::Layout() failed.\n"));
wxDebugMsg(_("wxWindowBase::Layout() failed.\n"));
}
*/
// Now set the sizes and positions of the children, and
@@ -1105,7 +1144,7 @@ bool wxOldDoLayout(wxWindow *win)
node = win->GetChildren().First();
while (node)
{
wxWindow *child = (wxWindow *)node->Data();
wxWindowBase *child = (wxWindowBase *)node->Data();
wxLayoutConstraints *constr = child->GetConstraints();
if (constr && constr->left.GetDone() && constr->right.GetDone() &&
constr->width.GetDone() && constr->height.GetDone())
@@ -1135,6 +1174,7 @@ bool wxOldDoLayout(wxWindow *win)
return TRUE;
}
#endif // WXWIN_COMPATIBILITY
wxSizer::wxSizer()
{
@@ -1147,12 +1187,12 @@ wxSizer::wxSizer()
sizerHeight = 0;
}
wxSizer::wxSizer(wxWindow *parent, wxSizerBehaviour behav)
wxSizer::wxSizer(wxWindowBase *parent, wxSizerBehaviour behav)
{
Create(parent, behav);
}
bool wxSizer::Create(wxWindow *parent, wxSizerBehaviour behav)
bool wxSizer::Create(wxWindowBase *parent, wxSizerBehaviour behav)
{
sizerBehaviour = behav;
borderX = 2;
@@ -1205,11 +1245,11 @@ wxSizer::~wxSizer()
while (node)
{
wxNode *next = node->Next();
wxWindow *win = (wxWindow *)node->Data();
wxWindowBase *win = (wxWindowBase *)node->Data();
if (!win->IsKindOf(CLASSINFO(wxSizer)))
{
delete node;
win->SetSizerParent((wxWindow *) NULL);
win->SetSizerParent((wxWindowBase *) NULL);
}
else
{
@@ -1222,7 +1262,7 @@ wxSizer::~wxSizer()
if (m_sizerParent) // && !m_sizerParent->IsKindOf(CLASSINFO(wxSizer)))
{
m_sizerParent->SetSizer((wxSizer *) NULL);
m_sizerParent = (wxWindow *) NULL;
m_sizerParent = (wxWindowBase *) NULL;
}
}
@@ -1244,7 +1284,7 @@ void wxSizer::SetBorder(int x, int y)
}
void wxSizer::AddSizerChild(wxWindow *child)
void wxSizer::AddSizerChild(wxWindowBase *child)
{
child->SetSizerParent(this);
GetChildren().Append(child);
@@ -1268,7 +1308,7 @@ void wxSizer::AddSizerChild(wxWindow *child)
}
}
void wxSizer::RemoveSizerChild(wxWindow *child)
void wxSizer::RemoveSizerChild(wxWindowBase *child)
{
GetChildren().DeleteObject(child);
}
@@ -1368,7 +1408,7 @@ bool wxSizer::LayoutPhase1(int *noChanges)
while (node)
{
int x, y, width, height;
wxWindow *win = (wxWindow *)node->Data();
wxWindowBase *win = (wxWindowBase *)node->Data();
win->GetSizeConstraint(&width, &height);
win->GetPositionConstraint(&x, &y);
if ((x+width) > maxX)
@@ -1481,12 +1521,12 @@ wxRowColSizer::wxRowColSizer()
ySpacing = 2;
}
wxRowColSizer::wxRowColSizer(wxWindow *parent, bool rc, int n, wxSizerBehaviour behav)
wxRowColSizer::wxRowColSizer(wxWindowBase *parent, bool rc, int n, wxSizerBehaviour behav)
{
Create(parent, rc, n, behav);
}
bool wxRowColSizer::Create(wxWindow *parent, bool rc, int n, wxSizerBehaviour behav)
bool wxRowColSizer::Create(wxWindowBase *parent, bool rc, int n, wxSizerBehaviour behav)
{
wxSizer::Create(parent, behav);
@@ -1561,7 +1601,7 @@ bool wxRowColSizer::LayoutPhase1(int *noChanges)
wxNode *node = GetChildren().First();
while (node)
{
wxWindow *win = (wxWindow *)node->Data();
wxWindowBase *win = (wxWindowBase *)node->Data();
int childWidth, childHeight;
if (win->GetConstraints() &&
win->GetConstraints()->width.GetDone() &&
@@ -1661,23 +1701,23 @@ wxSpacingSizer::wxSpacingSizer()
{
}
wxSpacingSizer::wxSpacingSizer(wxWindow *parent)
wxSpacingSizer::wxSpacingSizer(wxWindowBase *parent)
{
Create(parent);
}
wxSpacingSizer::wxSpacingSizer(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing)
wxSpacingSizer::wxSpacingSizer(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int spacing)
{
Create(parent, rel, other, spacing);
}
bool wxSpacingSizer::Create(wxWindow *parent)
bool wxSpacingSizer::Create(wxWindowBase *parent)
{
wxSizer::Create(parent);
return TRUE;
}
bool wxSpacingSizer::Create(wxWindow *parent, wxRelationship rel, wxWindow *other, int spacing)
bool wxSpacingSizer::Create(wxWindowBase *parent, wxRelationship rel, wxWindowBase *other, int spacing)
{
wxLayoutConstraints *c = new wxLayoutConstraints;

7
src/common/list.cpp
View File

@@ -37,13 +37,6 @@
#include "wx/utils.h" // for copystring() (beurk...)
#endif
// -----------------------------------------------------------------------------
// implementation of standard lists
// -----------------------------------------------------------------------------
#include "wx/listimpl.cpp"
WX_DEFINE_LIST(wxWindowList);
// =============================================================================
// implementation
// =============================================================================

6
src/common/resource.cpp
View File

@@ -2846,7 +2846,7 @@ bool wxResourceParseString(char *s, wxResourceTable *table)
* resource loading facility
*/
bool wxWindow::LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table)
bool wxWindowBase::LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table)
{
if (!table)
table = wxDefaultResourceTable;
@@ -2885,7 +2885,7 @@ bool wxWindow::LoadFromResource(wxWindow *parent, const wxString& resourceName,
}
else
{
if (!this->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle, name))
if (!((wxWindow *)this)->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle, name))
return FALSE;
}
@@ -2932,7 +2932,7 @@ bool wxWindow::LoadFromResource(wxWindow *parent, const wxString& resourceName,
return TRUE;
}
wxControl *wxWindow::CreateItem(const wxItemResource *resource, const wxItemResource* parentResource, const wxResourceTable *table)
wxControl *wxWindowBase::CreateItem(const wxItemResource *resource, const wxItemResource* parentResource, const wxResourceTable *table)
{
if (!table)
table = wxDefaultResourceTable;

2
src/common/tbarbase.cpp
View File

@@ -398,7 +398,7 @@ void wxToolBarBase::Command(wxCommandEvent& WXUNUSED(event))
{
}
void wxToolBarBase::Layout()
void wxToolBarBase::LayoutTools()
{
}

2
src/common/tbarsmpl.cpp
View File

@@ -364,7 +364,7 @@ void wxToolBarSimple::SpringUpButton(int index)
}
}
void wxToolBarSimple::Layout(void)
void wxToolBarSimple::LayoutTools(void)
{
m_currentRowsOrColumns = 0;
m_lastX = m_xMargin;

2
src/common/utilscmn.cpp
View File

@@ -459,7 +459,7 @@ wxFindWindowByLabel1 (const wxString& title, wxWindow * parent)
if (parent)
{
for ( wxNode * node = parent->GetChildren().GetFirst();
for ( wxWindowList::Node * node = parent->GetChildren().GetFirst();
node;
node = node->GetNext() )
{

2
src/common/valtext.cpp
View File

@@ -129,7 +129,7 @@ bool wxTextValidator::Validate(wxWindow *parent)
wxTextCtrl *control = (wxTextCtrl *) m_validatorWindow ;
// If window is disabled, simply return
if ( !control->Enabled() )
if ( !control->IsEnabled() )
return TRUE;
wxString val(control->GetValue());

1132
src/common/wincmn.cpp
View File

File diff suppressed because it is too large Load Diff

31
src/generic/listctrl.cpp
View File

@@ -2330,7 +2330,7 @@ bool wxListCtrl::Create( wxWindow *parent, wxWindowID id,
m_mainWin = new wxListMainWindow( this, -1, wxPoint(0,0), size, s );
if (GetWindowStyleFlag() & wxLC_REPORT)
if (HasFlag(wxLC_REPORT))
m_headerWin = new wxListHeaderWindow( this, -1, m_mainWin, wxPoint(0,0), wxSize(size.x,23), wxTAB_TRAVERSAL );
else
m_headerWin = (wxListHeaderWindow *) NULL;
@@ -2349,7 +2349,7 @@ void wxListCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )
void wxListCtrl::SetSingleStyle( long style, bool add )
{
long flag = GetWindowStyleFlag();
long flag = GetWindowStyle();
if (add)
{
@@ -2382,7 +2382,7 @@ void wxListCtrl::SetWindowStyleFlag( long flag )
if (flag & wxLC_REPORT)
{
if (!(GetWindowStyleFlag() & wxLC_REPORT))
if (!HasFlag(wxLC_REPORT))
{
// m_mainWin->SetSize( 0, 24, width, height-24 );
if (!m_headerWin)
@@ -2398,7 +2398,7 @@ void wxListCtrl::SetWindowStyleFlag( long flag )
}
else
{
if (GetWindowStyleFlag() & wxLC_REPORT)
if (HasFlag(wxLC_REPORT))
{
// m_mainWin->SetSize( 0, 0, width, height );
m_headerWin->Show( FALSE );
@@ -2769,7 +2769,7 @@ void wxListCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
int w = 0;
int h = 0;
if (GetWindowStyleFlag() & wxLC_REPORT)
if (HasFlag(wxLC_REPORT))
{
m_headerWin->GetPosition( &x, &y );
m_headerWin->GetSize( &w, &h );
@@ -2795,9 +2795,10 @@ void wxListCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
m_mainWin->Refresh();
}
void wxListCtrl::SetBackgroundColour( const wxColour &colour )
bool wxListCtrl::SetBackgroundColour( const wxColour &colour )
{
wxWindow::SetBackgroundColour( colour );
if ( !wxWindow::SetBackgroundColour( colour ) )
return FALSE;
if (m_mainWin)
{
@@ -2809,11 +2810,14 @@ void wxListCtrl::SetBackgroundColour( const wxColour &colour )
{
m_headerWin->SetBackgroundColour( colour );
}
return TRUE;
}
void wxListCtrl::SetForegroundColour( const wxColour &colour )
bool wxListCtrl::SetForegroundColour( const wxColour &colour )
{
wxWindow::SetForegroundColour( colour );
if ( !wxWindow::SetForegroundColour( colour ) )
return FALSE;
if (m_mainWin)
{
@@ -2825,11 +2829,14 @@ void wxListCtrl::SetForegroundColour( const wxColour &colour )
{
m_headerWin->SetForegroundColour( colour );
}
return TRUE;
}
void wxListCtrl::SetFont( const wxFont &font )
bool wxListCtrl::SetFont( const wxFont &font )
{
wxWindow::SetFont( font );
if ( !wxWindow::SetFont( font ) )
return FALSE;
if (m_mainWin)
{
@@ -2841,5 +2848,7 @@ void wxListCtrl::SetFont( const wxFont &font )
{
m_headerWin->SetFont( font );
}
return TRUE;
}

16
src/generic/panelg.cpp
View File

@@ -109,24 +109,24 @@ void wxPanel::OnNavigationKey( wxNavigationKeyEvent& event )
return;
}
wxNode *start_node = GetChildren().Find( winFocus );
wxWindowList::Node *start_node = GetChildren().Find( winFocus );
if (!start_node)
start_node = GetChildren().First();
start_node = GetChildren().GetFirst();
wxNode *node = event.GetDirection() ? start_node->Next()
: start_node->Previous();
wxWindowList::Node *node = event.GetDirection() ? start_node->GetNext()
: start_node->GetPrevious();
while (node != start_node)
{
if (!node)
{
node = event.GetDirection() ? GetChildren().First()
: GetChildren().Last();
node = event.GetDirection() ? GetChildren().GetFirst()
: GetChildren().GetLast();
continue;
}
wxWindow *child = (wxWindow *)node->Data();
wxWindow *child = node->GetData();
if (child->AcceptsFocus())
{
@@ -135,7 +135,7 @@ void wxPanel::OnNavigationKey( wxNavigationKeyEvent& event )
return;
}
node = event.GetDirection() ? node->Next() : node->Previous();
node = event.GetDirection() ? node->GetNext() : node->GetPrevious();
}
// we cycled through all of our children and none of them wanted to accept

4
src/generic/tabg.cpp
View File

@@ -623,7 +623,7 @@ bool wxTabView::RemoveTab(int id)
m_noTabs --;
// The layout has changed
Layout();
LayoutTabs();
return TRUE;
}
tabNode = tabNode->Next();
@@ -703,7 +703,7 @@ void wxTabView::ClearTabs(bool deleteTabs)
// Layout tabs (optional, e.g. if resizing window)
void wxTabView::Layout(void)
void wxTabView::LayoutTabs(void)
{
// Make a list of the tab controls, deleting the wxTabLayers.
wxList controls;

12
src/gtk/app.cpp
View File

@@ -45,7 +45,6 @@
wxApp *wxTheApp = (wxApp *) NULL;
wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
extern wxList wxPendingDelete;
#if wxUSE_THREADS
extern wxList *wxPendingEvents;
extern wxCriticalSection *wxPendingEventsLocker;
@@ -287,11 +286,12 @@ bool wxApp::OnInitGui()
int gg = (g << 3) | (g >> 2);
int bb = (b << 3) | (b >> 2);
int index = -1;
GdkColor *colors = cmap->colors;
if(colors)
{
int max = 3 * 65536;
int index = -1;
for (int i = 0; i < cmap->size; i++)
{
@@ -299,9 +299,13 @@ bool wxApp::OnInitGui()
int gdiff = ((gg << 8) - colors[i].green);
int bdiff = ((bb << 8) - colors[i].blue);
int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
if (sum < max) { index = i; max = sum; }
if (sum < max)
{
index = i; max = sum;
}
}
}
m_colorCube[ (r*1024) + (g*32) + b ] = index;
}
}
@@ -448,7 +452,7 @@ void wxApp::DeletePendingObjects()
delete obj;
if (wxPendingDelete.Member(obj))
if (wxPendingDelete.Find(obj))
delete node;
node = wxPendingDelete.First();

9
src/gtk/bmpbuttn.cpp
View File

@@ -166,7 +166,7 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->InsertChild( this );
PostCreation();
@@ -278,11 +278,14 @@ void wxBitmapButton::SetBitmapSelected( const wxBitmap& bitmap )
SetBitmap();
}
void wxBitmapButton::Enable( const bool enable )
bool wxBitmapButton::Enable( bool enable )
{
wxWindow::Enable(enable);
if ( !wxWindow::Enable(enable) )
return FALSE;
SetBitmap();
return TRUE;
}
void wxBitmapButton::HasFocus()

13
src/gtk/button.cpp
View File

@@ -96,9 +96,7 @@ bool wxButton::Create( wxWindow *parent, wxWindowID id, const wxString &label,
gtk_signal_connect( GTK_OBJECT(m_widget), "clicked",
GTK_SIGNAL_FUNC(gtk_button_clicked_callback), (gpointer*)this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -128,13 +126,14 @@ void wxButton::SetLabel( const wxString &label )
gtk_label_set( GTK_LABEL( GTK_BUTTON(m_widget)->child ), GetLabel().mbc_str() );
}
void wxButton::Enable( bool enable )
bool wxButton::Enable( bool enable )
{
wxCHECK_RET( m_widget != NULL, _T("invalid button") );
wxControl::Enable( enable );
if ( !wxControl::Enable( enable ) )
return FALSE;
gtk_widget_set_sensitive( GTK_BUTTON(m_widget)->child, enable );
return TRUE;
}
void wxButton::ApplyWidgetStyle()

13
src/gtk/checkbox.cpp
View File

@@ -124,9 +124,7 @@ bool wxCheckBox::Create(wxWindow *parent,
GTK_SIGNAL_FUNC(gtk_checkbox_clicked_callback),
(gpointer *)this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -169,13 +167,14 @@ void wxCheckBox::SetLabel( const wxString& label )
gtk_label_set( GTK_LABEL(m_widgetLabel), GetLabel().mbc_str() );
}
void wxCheckBox::Enable( bool enable )
bool wxCheckBox::Enable( bool enable )
{
wxCHECK_RET( m_widgetLabel != NULL, _T("invalid checkbox") );
wxControl::Enable( enable );
if ( !wxControl::Enable( enable ) )
return FALSE;
gtk_widget_set_sensitive( m_widgetLabel, enable );
return TRUE;
}
void wxCheckBox::ApplyWidgetStyle()

4
src/gtk/choice.cpp
View File

@@ -99,9 +99,7 @@ bool wxChoice::Create( wxWindow *parent, wxWindowID id,
}
gtk_option_menu_set_menu( GTK_OPTION_MENU(m_widget), menu );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

6
src/gtk/combobox.cpp
View File

@@ -134,9 +134,7 @@ bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
gtk_widget_show( list_item );
}
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -582,7 +580,7 @@ void wxComboBox::OnChar( wxKeyEvent &event )
void wxComboBox::OnSize( wxSizeEvent &event )
{
wxControl::OnSize( event );
event.Skip();
return;

11
src/gtk/dcclient.cpp
View File

@@ -110,8 +110,9 @@ wxWindowDC::wxWindowDC( wxWindow *window )
if (!window) return;
GtkWidget *widget = window->m_wxwindow;
if (!widget) return;
GtkWidget *widget = window->GetWxWindow();
if (!widget)
return;
m_window = widget->window;
@@ -126,10 +127,10 @@ wxWindowDC::wxWindowDC( wxWindow *window )
/* still not realized ? */
if (!m_window) return;
if (window->m_wxwindow)
m_cmap = gtk_widget_get_colormap( window->m_wxwindow );
if (window->GetWxWindow())
m_cmap = gtk_widget_get_colormap( window->GetWxWindow() );
else
m_cmap = gtk_widget_get_colormap( window->m_widget );
m_cmap = gtk_widget_get_colormap( window->GetHandle() );
m_isMemDC = FALSE;

34
src/gtk/dialog.cpp
View File

@@ -69,11 +69,9 @@ static void gtk_dialog_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation
printf( ".\n" );
*/
if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
if ((win->GetWidth() != alloc->width) || (win->GetHeight() != alloc->height))
{
win->m_sizeSet = FALSE;
win->m_width = alloc->width;
win->m_height = alloc->height;
win->InternalSetSize( alloc->width, alloc->height );
}
}
@@ -87,10 +85,9 @@ static gint gtk_dialog_configure_callback( GtkWidget *WXUNUSED(widget), GdkEvent
if (!win->HasVMT()) return FALSE;
win->m_x = event->x;
win->m_y = event->y;
win->InternalSetPosition(event->x, event->y);
wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
wxMoveEvent mevent( wxPoint(win->GetX(),win->GetY()), win->GetId() );
mevent.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( mevent );
@@ -129,43 +126,43 @@ gtk_dialog_map_callback( GtkWidget *widget, wxDialog *win )
{
/* I haven''t been able to set the position of
the dialog before it is shown, so I do it here */
gtk_widget_set_uposition( widget, win->m_x, win->m_y );
gtk_widget_set_uposition( widget, win->GetX(), win->GetY() );
/* all this is for Motif Window Manager "hints" and is supposed to be
recognized by other WM as well. not tested. */
long decor = (long) GDK_DECOR_BORDER;
long func = (long) GDK_FUNC_MOVE ;
if ((win->m_windowStyle & wxCAPTION) != 0)
if ((win->GetWindowStyle() & wxCAPTION) != 0)
decor |= GDK_DECOR_TITLE;
if ((win->m_windowStyle & wxSYSTEM_MENU) != 0)
if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
{
decor |= GDK_DECOR_MENU;
func |= GDK_FUNC_CLOSE;
}
if ((win->m_windowStyle & wxMINIMIZE_BOX) != 0)
if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
{
func |= GDK_FUNC_MINIMIZE;
decor |= GDK_DECOR_MINIMIZE;
}
if ((win->m_windowStyle & wxMAXIMIZE_BOX) != 0)
if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
{
decor |= GDK_DECOR_MAXIMIZE;
func |= GDK_FUNC_MAXIMIZE;
}
if ((win->m_windowStyle & wxRESIZE_BORDER) != 0)
if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
{
func |= GDK_FUNC_RESIZE;
decor |= GDK_DECOR_RESIZEH;
}
gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
gdk_window_set_decorations( win->GetHandle()->window, (GdkWMDecoration)decor);
gdk_window_set_functions( win->GetHandle()->window, (GdkWMFunction)func);
/* GTK's shrinking/growing policy */
if ((win->m_windowStyle & wxRESIZE_BORDER) == 0)
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 0, 0, 1);
else
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 1, 1, 1);
return FALSE;
}
@@ -186,6 +183,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxDialog,wxPanel)
void wxDialog::Init()
{
m_returnCode = 0;
m_sizeSet = FALSE;
m_modalShowing = FALSE;
}

12
src/gtk/dnd.cpp
View File

@@ -702,8 +702,8 @@ wxDropSource::wxDropSource( wxWindow *win, const wxIcon &go, const wxIcon &stop
m_waiting = TRUE;
m_window = win;
m_widget = win->m_widget;
if (win->m_wxwindow) m_widget = win->m_wxwindow;
m_widget = win->GetWidget();
if (win->GetWxWindow()) m_widget = win->GetWxWindow();
m_data = (wxDataBroker*) NULL;
m_retValue = wxDragCancel;
@@ -722,8 +722,8 @@ wxDropSource::wxDropSource( wxDataObject *data, wxWindow *win, const wxIcon &go,
m_waiting = TRUE;
m_window = win;
m_widget = win->m_widget;
if (win->m_wxwindow) m_widget = win->m_wxwindow;
m_widget = win->GetWidget();
if (win->GetWxWindow()) m_widget = win->GetWxWindow();
m_retValue = wxDragCancel;
if (data)
@@ -748,8 +748,8 @@ wxDropSource::wxDropSource( wxDataObject *data, wxWindow *win, const wxIcon &go,
wxDropSource::wxDropSource( wxDataBroker *data, wxWindow *win )
{
m_window = win;
m_widget = win->m_widget;
if (win->m_wxwindow) m_widget = win->m_wxwindow;
m_widget = win->GetWidget();
if (win->GetWxWindow()) m_widget = win->GetWxWindow();
m_retValue = wxDragCancel;
m_data = data;

2
src/gtk/filedlg.cpp
View File

@@ -57,7 +57,7 @@ void gtk_filedialog_ok_callback( GtkWidget *WXUNUSED(widget), wxFileDialog *dial
int style = dialog->GetStyle();
GtkFileSelection *filedlg = GTK_FILE_SELECTION(dialog->m_widget);
GtkFileSelection *filedlg = GTK_FILE_SELECTION(dialog->GetHandle());
char *filename = gtk_file_selection_get_filename(filedlg);
if ( (style & wxSAVE) && ( style & wxOVERWRITE_PROMPT ) )

4
src/gtk/font.cpp
View File

@@ -159,12 +159,12 @@ wxFont& wxFont::operator = ( const wxFont& font )
return *this;
}
bool wxFont::operator == ( const wxFont& font )
bool wxFont::operator == ( const wxFont& font ) const
{
return m_refData == font.m_refData;
}
bool wxFont::operator != ( const wxFont& font )
bool wxFont::operator != ( const wxFont& font ) const
{
return m_refData != font.m_refData;
}

132
src/gtk/frame.cpp
View File

@@ -73,11 +73,9 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
printf( ".\n" );
*/
if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
if ((win->GetWidth() != alloc->width) || (win->GetHeight() != alloc->height))
{
win->m_sizeSet = FALSE;
win->m_width = alloc->width;
win->m_height = alloc->height;
win->InternalSetSize( alloc->width, alloc->height );
}
}
@@ -112,7 +110,7 @@ static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
if (!win->HasVMT()) return;
win->m_menuBarDetached = FALSE;
win->m_sizeSet = FALSE;
win->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -126,7 +124,7 @@ static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
if (!win->HasVMT()) return;
win->m_menuBarDetached = TRUE;
win->m_sizeSet = FALSE;
win->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -140,7 +138,7 @@ static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
if (!win->HasVMT()) return;
win->m_toolBarDetached = FALSE;
win->m_sizeSet = FALSE;
win->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -154,7 +152,7 @@ static void gtk_toolbar_detached_callback( GtkWidget *widget, GtkWidget *WXUNUSE
if (!win->HasVMT()) return;
win->m_toolBarDetached = TRUE;
win->m_sizeSet = FALSE;
win->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -167,10 +165,9 @@ static gint gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventC
if (!win->HasVMT()) return FALSE;
win->m_x = event->x;
win->m_y = event->y;
win->InternalSetPosition(event->x, event->y);
wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
wxMoveEvent mevent( wxPoint(win->GetX(),win->GetY()), win->GetId() );
mevent.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( mevent );
@@ -194,38 +191,38 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
long decor = (long) GDK_DECOR_BORDER;
long func = (long) GDK_FUNC_MOVE;
if ((win->m_windowStyle & wxCAPTION) != 0)
if ((win->GetWindowStyle() & wxCAPTION) != 0)
decor |= GDK_DECOR_TITLE;
if ((win->m_windowStyle & wxSYSTEM_MENU) != 0)
if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
{
decor |= GDK_DECOR_MENU;
func |= GDK_FUNC_CLOSE;
}
if ((win->m_windowStyle & wxMINIMIZE_BOX) != 0)
if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
{
func |= GDK_FUNC_MINIMIZE;
decor |= GDK_DECOR_MINIMIZE;
}
if ((win->m_windowStyle & wxMAXIMIZE_BOX) != 0)
if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
{
func |= GDK_FUNC_MAXIMIZE;
decor |= GDK_DECOR_MAXIMIZE;
}
if ((win->m_windowStyle & wxRESIZE_BORDER) != 0)
if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
{
func |= GDK_FUNC_RESIZE;
decor |= GDK_DECOR_RESIZEH;
}
gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
gdk_window_set_decorations( win->GetHandle()->window, (GdkWMDecoration)decor);
gdk_window_set_functions( win->GetHandle()->window, (GdkWMFunction)func);
/* GTK's shrinking/growing policy */
if ((win->m_windowStyle & wxRESIZE_BORDER) == 0)
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 0, 0, 1);
else
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 1, 1, 1);
/* reset the icon */
if (win->m_icon != wxNullIcon)
@@ -237,17 +234,17 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
/* we set the focus to the child that accepts the focus. this
doesn't really have to be done in "realize" but why not? */
wxNode *node = win->m_children.First();
wxWindowList::Node *node = win->GetChildren().GetFirst();
while (node)
{
wxWindow *child = (wxWindow*) node->Data();
wxWindow *child = node->GetData();
if (child->AcceptsFocus())
{
child->SetFocus();
break;
}
node = node->Next();
node = node->GetNext();
}
return FALSE;
@@ -272,23 +269,23 @@ static void wxInsertChildInFrame( wxWindow* parent, wxWindow* child )
/* these are outside the client area */
wxFrame* frame = (wxFrame*) parent;
gtk_myfixed_put( GTK_MYFIXED(frame->m_mainWidget),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
child->m_width,
child->m_height );
GTK_WIDGET(child->GetHandle()),
child->GetX(),
child->GetY(),
child->GetWidth(),
child->GetHeight() );
/* we connect to these events for recalculating the client area
space when the toolbar is floating */
if (wxIS_KIND_OF(child,wxToolBar))
{
wxToolBar *toolBar = (wxToolBar*) child;
if (toolBar->m_windowStyle & wxTB_DOCKABLE)
if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
{
gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",
gtk_signal_connect( GTK_OBJECT(toolBar->GetHandle()), "child_attached",
GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );
gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",
gtk_signal_connect( GTK_OBJECT(toolBar->GetHandle()), "child_detached",
GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );
}
}
@@ -296,16 +293,16 @@ static void wxInsertChildInFrame( wxWindow* parent, wxWindow* child )
else
{
/* these are inside the client area */
gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
child->m_width,
child->m_height );
gtk_myfixed_put( GTK_MYFIXED(parent->GetWxWindow()),
GTK_WIDGET(child->GetHandle()),
child->GetX(),
child->GetY(),
child->GetWidth(),
child->GetHeight() );
}
/* resize on OnInternalIdle */
parent->m_sizeSet = FALSE;
parent->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -671,12 +668,10 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
int ww = m_width - 2*m_miniEdge;
int hh = wxMENU_HEIGHT;
if (m_menuBarDetached) hh = wxPLACE_HOLDER;
m_frameMenuBar->m_x = xx;
m_frameMenuBar->m_y = yy;
m_frameMenuBar->m_width = ww;
m_frameMenuBar->m_height = hh;
m_frameMenuBar->InternalSetPosition(xx, yy);
m_frameMenuBar->InternalSetSize(ww, hh);
gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
m_frameMenuBar->m_widget,
m_frameMenuBar->GetHandle(),
xx, yy, ww, hh );
client_area_y_offset += hh;
}
@@ -693,14 +688,17 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
yy += wxPLACE_HOLDER;
}
int ww = m_width - 2*m_miniEdge;
int hh = m_frameToolBar->m_height;
if (m_toolBarDetached) hh = wxPLACE_HOLDER;
m_frameToolBar->m_x = xx;
m_frameToolBar->m_y = yy;
/* m_frameToolBar->m_height = hh; don't change the toolbar's height */
m_frameToolBar->m_width = ww;
int hh = m_frameToolBar->GetHeight();
// VZ: according to earlier comments in this file, the tbar height
// shouldn't be changed, so I comment out the next line
// (09.05.99)
//if (m_toolBarDetached) hh = wxPLACE_HOLDER;
m_frameToolBar->InternalSetPosition(xx, yy);
m_frameToolBar->InternalSetSize(ww, hh);
gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
m_frameToolBar->m_widget,
m_frameToolBar->GetHandle(),
xx, yy, ww, hh );
client_area_y_offset += hh;
}
@@ -725,12 +723,10 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
int ww = m_width - 2*m_miniEdge;
int hh = wxSTATUS_HEIGHT;
m_frameStatusBar->m_x = xx;
m_frameStatusBar->m_y = yy;
m_frameStatusBar->m_width = ww;
m_frameStatusBar->m_height = hh;
m_frameStatusBar->InternalSetPosition(xx, yy);
m_frameStatusBar->InternalSetSize(ww, hh);
gtk_myfixed_set_size( GTK_MYFIXED(m_wxwindow),
m_frameStatusBar->m_widget,
m_frameStatusBar->GetHandle(),
xx, yy, ww, hh );
}
@@ -747,7 +743,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
/* send size event to status bar */
if (m_frameStatusBar)
{
wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
wxSizeEvent event2( wxSize(m_frameStatusBar->GetWidth(),m_frameStatusBar->GetHeight()), m_frameStatusBar->GetId() );
event2.SetEventObject( m_frameStatusBar );
m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
}
@@ -812,7 +808,7 @@ static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
#if (GTK_MINOR_VERSION > 0)
/* support for native hot keys */
gtk_accel_group_attach( menu->m_accel, GTK_OBJECT(win->m_widget));
gtk_accel_group_attach( menu->m_accel, GTK_OBJECT(win->GetHandle()));
#endif
wxNode *node = menu->GetItems().First();
@@ -847,22 +843,22 @@ void wxFrame::SetMenuBar( wxMenuBar *menuBar )
node = node->Next();
}
if (m_frameMenuBar->m_parent != this)
if (m_frameMenuBar->GetParent() != this)
{
m_frameMenuBar->m_parent = this;
m_frameMenuBar->SetParent(this);
gtk_myfixed_put( GTK_MYFIXED(m_mainWidget),
m_frameMenuBar->m_widget,
m_frameMenuBar->m_x,
m_frameMenuBar->m_y,
m_frameMenuBar->m_width,
m_frameMenuBar->m_height );
m_frameMenuBar->GetHandle(),
m_frameMenuBar->GetX(),
m_frameMenuBar->GetY(),
m_frameMenuBar->GetWidth(),
m_frameMenuBar->GetHeight() );
if (menuBar->m_windowStyle & wxMB_DOCKABLE)
if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
{
gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
gtk_signal_connect( GTK_OBJECT(menuBar->GetHandle()), "child_attached",
GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
gtk_signal_connect( GTK_OBJECT(menuBar->GetHandle()), "child_detached",
GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
}
}

4
src/gtk/gauge.cpp
View File

@@ -37,9 +37,7 @@ bool wxGauge::Create( wxWindow *parent, wxWindowID id, int range,
m_widget = gtk_progress_bar_new();
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

11
src/gtk/listbox.cpp
View File

@@ -282,9 +282,7 @@ bool wxListBox::Create( wxWindow *parent, wxWindowID id,
gtk_widget_show( list_item );
}
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -419,7 +417,7 @@ void wxListBox::AppendCommon( const wxString &item )
gtk_signal_connect( GTK_OBJECT(list_item), "select",
GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
if (GetWindowStyleFlag() & wxLB_MULTIPLE)
if (HasFlag(wxLB_MULTIPLE))
gtk_signal_connect( GTK_OBJECT(list_item), "deselect",
GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
@@ -454,7 +452,7 @@ void wxListBox::AppendCommon( const wxString &item )
#endif
#if wxUSE_TOOLTIPS
if (m_toolTip) m_toolTip->Apply( this );
if (m_tooltip) m_tooltip->Apply( this );
#endif
}
}
@@ -858,10 +856,13 @@ void wxListBox::ApplyWidgetStyle()
if (m_backgroundColour.Ok())
{
GdkWindow *window = GTK_WIDGET(m_list)->window;
if ( window )
{
m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
}
GList *child = m_list->children;
while (child)

62
src/gtk/mdi.cpp
View File

@@ -90,14 +90,12 @@ void wxMDIParentFrame::GtkOnSize( int x, int y, int width, int height )
wxMenuBar *menu_bar = child_frame->m_menuBar;
if (!menu_bar) return;
if (!menu_bar->m_widget) return;
if (!menu_bar->GetHandle()) return;
menu_bar->m_x = 0;
menu_bar->m_y = 0;
menu_bar->m_width = m_width;
menu_bar->m_height = wxMENU_HEIGHT;
menu_bar->InternalSetPosition(0, 0);
menu_bar->InternalSetSize(m_width, wxMENU_HEIGHT);
gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
menu_bar->m_widget,
menu_bar->GetHandle(),
0, 0, m_width, wxMENU_HEIGHT );
}
@@ -110,7 +108,7 @@ void wxMDIParentFrame::OnInternalIdle()
if (m_justInserted)
{
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->GetHandle());
gtk_notebook_set_page( notebook, g_list_length( notebook->children ) - 1 );
m_justInserted = FALSE;
@@ -122,7 +120,7 @@ void wxMDIParentFrame::OnInternalIdle()
wxMDIChildFrame *active_child_frame = GetActiveChild();
bool visible_child_menu = FALSE;
wxNode *node = m_clientWindow->m_children.First();
wxNode *node = m_clientWindow->GetChildren().First();
while (node)
{
wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
@@ -130,11 +128,11 @@ void wxMDIParentFrame::OnInternalIdle()
{
if (child_frame == active_child_frame)
{
gtk_widget_show( child_frame->m_menuBar->m_widget );
gtk_widget_show( child_frame->m_menuBar->GetHandle() );
visible_child_menu = TRUE;
}
else
gtk_widget_hide( child_frame->m_menuBar->m_widget );
gtk_widget_hide( child_frame->m_menuBar->GetHandle() );
}
node = node->Next();
}
@@ -152,7 +150,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
if (!m_clientWindow) return (wxMDIChildFrame*) NULL;
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->GetHandle());
if (!notebook) return (wxMDIChildFrame*) NULL;
#if (GTK_MINOR_VERSION > 0)
@@ -165,7 +163,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
if (!page) return (wxMDIChildFrame*) NULL;
wxNode *node = m_clientWindow->m_children.First();
wxNode *node = m_clientWindow->GetChildren().First();
while (node)
{
wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
@@ -191,13 +189,13 @@ wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
void wxMDIParentFrame::ActivateNext()
{
if (m_clientWindow)
gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->GetHandle()) );
}
void wxMDIParentFrame::ActivatePrevious()
{
if (m_clientWindow)
gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->GetHandle()) );
}
void wxMDIParentFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
@@ -279,9 +277,9 @@ void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
if (m_menuBar)
{
wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->m_parent;
wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();
if (m_menuBar->m_parent != this)
if (m_menuBar->GetParent() != this)
{
wxNode *node = m_menuBar->GetMenus().First();
while (node)
@@ -291,16 +289,16 @@ void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
node = node->Next();
}
m_menuBar->m_parent = mdi_frame;
m_menuBar->SetParent( mdi_frame );
}
/* the menu bar of the child window is shown in idle time as needed */
gtk_widget_hide( m_menuBar->m_widget );
gtk_widget_hide( m_menuBar->GetHandle() );
/* insert the invisible menu bar into the _parent_ mdi frame */
gtk_myfixed_put( GTK_MYFIXED(mdi_frame->m_mainWidget),
m_menuBar->m_widget,
0, 0, mdi_frame->m_width, wxMENU_HEIGHT );
m_menuBar->GetHandle(),
0, 0, mdi_frame->GetWidth(), wxMENU_HEIGHT );
}
}
@@ -325,11 +323,11 @@ static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
{
if (g_isIdle) wxapp_install_idle_handler();
if ((win->m_x == alloc->x) &&
(win->m_y == alloc->y) &&
(win->m_width == alloc->width) &&
(win->m_height == alloc->height) &&
(win->m_sizeSet))
if ((win->GetX() == alloc->x) &&
(win->GetY() == alloc->y) &&
(win->GetWidth() == alloc->width) &&
(win->GetHeight() == alloc->height) &&
(win->IsSizeSet()))
{
return;
}
@@ -349,16 +347,16 @@ static void wxInsertChildInMDI( wxMDIClientWindow* parent, wxMDIChildFrame* chil
GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
gtk_signal_connect( GTK_OBJECT(child->GetHandle()), "size_allocate",
GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
GtkNotebook *notebook = GTK_NOTEBOOK(parent->GetHandle());
gtk_notebook_append_page( notebook, child->m_widget, label_widget );
gtk_notebook_append_page( notebook, child->GetHandle(), label_widget );
child->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
wxMDIParentFrame *parent_frame = (wxMDIParentFrame*) parent->m_parent;
wxMDIParentFrame *parent_frame = (wxMDIParentFrame*) parent->GetParent();
parent_frame->m_justInserted = TRUE;
}
@@ -393,9 +391,7 @@ bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -404,5 +400,3 @@ bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
return TRUE;
}

37
src/gtk/minifram.cpp
View File

@@ -73,23 +73,23 @@ static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *g
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
0, 0,
win->m_width, win->m_height );
win->GetWidth(), win->GetHeight() );
if (!win->m_title.IsEmpty() &&
((win->m_windowStyle & wxCAPTION) ||
(win->m_windowStyle & wxTINY_CAPTION_HORIZ) ||
(win->m_windowStyle & wxTINY_CAPTION_VERT)))
((win->GetWindowStyle() & wxCAPTION) ||
(win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) ||
(win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
{
GdkGC *gc = gdk_gc_new( widget->window );
GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
int x = 2;
if (win->m_windowStyle & wxSYSTEM_MENU) x = 18;
if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 18;
gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
gdk_draw_rectangle( widget->window, gc, TRUE,
x,
3,
win->m_width - 4 - x,
win->GetWidth() - 4 - x,
font->ascent + font->descent+1 );
gdk_gc_set_foreground( gc, &widget->style->white );
@@ -117,23 +117,23 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
0, 0,
win->m_width, win->m_height );
win->GetWidth(), win->GetHeight() );
if (!win->m_title.IsEmpty() &&
((win->m_windowStyle & wxCAPTION) ||
(win->m_windowStyle & wxTINY_CAPTION_HORIZ) ||
(win->m_windowStyle & wxTINY_CAPTION_VERT)))
((win->GetWindowStyle() & wxCAPTION) ||
(win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) ||
(win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
{
GdkGC *gc = gdk_gc_new( widget->window );
GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
int x = 2;
if (win->m_windowStyle & wxSYSTEM_MENU) x = 17;
if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 17;
gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
gdk_draw_rectangle( widget->window, gc, TRUE,
x,
3,
win->m_width - 4 - x,
win->GetWidth() - 4 - x,
font->ascent + font->descent+1 );
gdk_gc_set_foreground( gc, &widget->style->white );
@@ -174,7 +174,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
win->m_diffX = (int)gdk_event->x;
win->m_diffY = (int)gdk_event->y;
DrawFrame( widget, 0, 0, win->m_width, win->m_height );
DrawFrame( widget, 0, 0, win->GetWidth(), win->GetHeight() );
win->m_oldX = 0;
win->m_oldY = 0;
@@ -202,16 +202,15 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
int x = (int)gdk_event->x;
int y = (int)gdk_event->y;
DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
gdk_pointer_ungrab ( GDK_CURRENT_TIME );
int org_x = 0;
int org_y = 0;
gdk_window_get_origin( widget->window, &org_x, &org_y );
x += org_x - win->m_diffX;
y += org_y - win->m_diffY;
win->m_x = x;
win->m_y = y;
gtk_widget_set_uposition( win->m_widget, x, y );
win->InternalSetPosition(x, y);
gtk_widget_set_uposition( win->GetWidget(), x, y );
return TRUE;
}
@@ -241,10 +240,10 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
gdk_event->state = state;
}
DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
win->m_oldX = (int)gdk_event->x - win->m_diffX;
win->m_oldY = (int)gdk_event->y - win->m_diffY;
DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
return TRUE;
}

18
src/gtk/notebook.cpp
View File

@@ -125,10 +125,10 @@ static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
{
if (g_isIdle) wxapp_install_idle_handler();
if ((win->m_x == alloc->x) &&
(win->m_y == alloc->y) &&
(win->m_width == alloc->width) &&
(win->m_height == alloc->height))
if ((win->GetX() == alloc->x) &&
(win->GetY() == alloc->y) &&
(win->GetWidth() == alloc->width) &&
(win->GetHeight() == alloc->height))
{
return;
}
@@ -188,16 +188,16 @@ static void wxInsertChildInNotebook( wxNotebook* parent, wxWindow* child )
page->m_box = gtk_hbox_new (FALSE, 0);
gtk_container_border_width(GTK_CONTAINER(page->m_box), 2);
GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
GtkNotebook *notebook = GTK_NOTEBOOK(parent->GetWidget());
page->m_client = child;
gtk_notebook_append_page( notebook, child->m_widget, page->m_box );
gtk_notebook_append_page( notebook, child->GetWidget(), page->m_box );
page->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
page->m_parent = notebook;
gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
gtk_signal_connect( GTK_OBJECT(child->GetWidget()), "size_allocate",
GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
wxASSERT_MSG( page->m_page, _T("Notebook page creation error") );
@@ -267,9 +267,7 @@ bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback),
(gpointer)this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this );

27
src/gtk/radiobox.cpp
View File

@@ -68,7 +68,7 @@ BEGIN_EVENT_TABLE(wxRadioBox, wxControl)
EVT_SIZE(wxRadioBox::OnSize)
END_EVENT_TABLE()
wxRadioBox::wxRadioBox(void)
wxRadioBox::wxRadioBox()
{
}
@@ -108,7 +108,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
gtk_signal_connect( GTK_OBJECT(m_radio), "clicked",
GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
gtk_myfixed_put( GTK_MYFIXED(m_parent->m_wxwindow),
gtk_myfixed_put( GTK_MYFIXED(m_parent->GetWxWindow()),
GTK_WIDGET(m_radio),
m_x+10, m_y+10+(i*24), 10, 10 );
}
@@ -120,9 +120,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
if (newSize.y == -1) newSize.y = ls.y;
SetSize( newSize.x, newSize.y );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -137,7 +135,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
return TRUE;
}
wxRadioBox::~wxRadioBox(void)
wxRadioBox::~wxRadioBox()
{
wxNode *node = m_boxes.First();
while (node)
@@ -150,9 +148,9 @@ wxRadioBox::~wxRadioBox(void)
void wxRadioBox::OnSize( wxSizeEvent &event )
{
wxControl::OnSize( event );
LayoutItems();
event.Skip();
}
wxSize wxRadioBox::LayoutItems()
@@ -181,7 +179,7 @@ wxSize wxRadioBox::LayoutItems()
int len = 22+gdk_string_measure( font, label->label );
if (len > max_len) max_len = len;
gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y );
gtk_myfixed_move( GTK_MYFIXED(m_parent->GetWxWindow()), button, m_x+x, m_y+y );
y += 20;
node = node->Next();
@@ -195,7 +193,7 @@ wxSize wxRadioBox::LayoutItems()
{
GtkWidget *button = GTK_WIDGET( node->Data() );
gtk_myfixed_resize( GTK_MYFIXED(m_parent->m_wxwindow), button, max_len, 20 );
gtk_myfixed_resize( GTK_MYFIXED(m_parent->GetWxWindow()), button, max_len, 20 );
node = node->Next();
if (!node) break;
@@ -231,7 +229,7 @@ wxSize wxRadioBox::LayoutItems()
{
GtkWidget *button = GTK_WIDGET( node->Data() );
gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y, max, 20 );
gtk_myfixed_set_size( GTK_MYFIXED(m_parent->GetWxWindow()), button, m_x+x, m_y+y, max, 20 );
x += max;
node = node->Next();
@@ -389,9 +387,10 @@ void wxRadioBox::SetLabel( int WXUNUSED(item), wxBitmap *WXUNUSED(bitmap) )
wxFAIL_MSG(_T("wxRadioBox::SetLabel not implemented."));
}
void wxRadioBox::Enable( bool enable )
bool wxRadioBox::Enable( bool enable )
{
wxControl::Enable( enable );
if ( !wxControl::Enable( enable ) )
return FALSE;
wxNode *node = m_boxes.First();
while (node)
@@ -402,6 +401,8 @@ void wxRadioBox::Enable( bool enable )
gtk_widget_set_sensitive( label, enable );
node = node->Next();
}
return TRUE;
}
void wxRadioBox::Enable( int item, bool enable )

13
src/gtk/radiobut.cpp
View File

@@ -91,9 +91,7 @@ bool wxRadioButton::Create( wxWindow *parent, wxWindowID id, const wxString& lab
gtk_signal_connect( GTK_OBJECT(m_widget), "clicked",
GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -138,13 +136,14 @@ bool wxRadioButton::GetValue(void) const
return GTK_TOGGLE_BUTTON(m_widget)->active;
}
void wxRadioButton::Enable( bool enable )
bool wxRadioButton::Enable( bool enable )
{
wxCHECK_RET( m_widget != NULL, _T("invalid radiobutton") );
wxControl::Enable( enable );
if ( !wxControl::Enable( enable ) )
return FALSE;
gtk_widget_set_sensitive( GTK_BUTTON(m_widget)->child, enable );
return TRUE;
}
void wxRadioButton::ApplyWidgetStyle()

13
src/gtk/scrolbar.cpp
View File

@@ -53,7 +53,7 @@ static void gtk_scrollbar_callback( GtkWidget *WXUNUSED(widget), wxScrollBar *wi
float line_step = win->m_adjust->step_increment;
float page_step = win->m_adjust->page_increment;
if (win->m_isScrolling)
if (win->IsScrolling())
{
command = wxEVT_SCROLL_THUMBTRACK;
}
@@ -70,8 +70,7 @@ static void gtk_scrollbar_callback( GtkWidget *WXUNUSED(widget), wxScrollBar *wi
int value = (int)(win->m_adjust->value+0.5);
int orient = wxHORIZONTAL;
if (win->GetWindowStyleFlag() & wxSB_VERTICAL == wxSB_VERTICAL) orient = wxVERTICAL;
int orient = win->HasFlag(wxSB_VERTICAL) ? wxVERTICAL : wxHORIZONTAL;
wxScrollEvent event( command, win->GetId(), value, orient );
event.SetEventObject( win );
@@ -94,7 +93,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
{
if (g_isIdle) wxapp_install_idle_handler();
win->m_isScrolling = TRUE;
win->SetScrolling(TRUE);
// g_blockEventsOnScroll = TRUE; doesn't work in DialogEd
return FALSE;
@@ -110,7 +109,7 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *WXUNUSED(widget),
{
if (g_isIdle) wxapp_install_idle_handler();
win->m_isScrolling = FALSE;
win->SetScrolling(FALSE);
// g_blockEventsOnScroll = FALSE;
gtk_signal_emit_by_name( GTK_OBJECT(win->m_adjust), "value_changed" );
@@ -163,9 +162,7 @@ bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
(GtkSignalFunc)gtk_scrollbar_button_release_callback,
(gpointer) this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk/slider.cpp
View File

@@ -144,9 +144,7 @@ bool wxSlider::Create(wxWindow *parent, wxWindowID id,
SetRange( minValue, maxValue );
SetValue( value );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk/spinbutt.cpp
View File

@@ -111,9 +111,7 @@ bool wxSpinButton::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, c
(GtkSignalFunc) gtk_spinbutt_callback,
(gpointer) this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk/statbmp.cpp
View File

@@ -60,9 +60,7 @@ bool wxStaticBitmap::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
m_widget = gtk_label_new( "Bitmap" );
}
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk/statbox.cpp
View File

@@ -45,9 +45,7 @@ bool wxStaticBox::Create( wxWindow *parent, wxWindowID id, const wxString &label
m_widget = gtk_frame_new(m_label.mbc_str());
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk/statline.cpp
View File

@@ -46,9 +46,7 @@ bool wxStaticLine::Create( wxWindow *parent, wxWindowID id,
else
m_widget = gtk_hseparator_new();
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk/stattext.cpp
View File

@@ -76,9 +76,7 @@ bool wxStaticText::Create(wxWindow *parent,
SetSize( newSize.x, newSize.y );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk/tbargtk.cpp
View File

@@ -209,9 +209,7 @@ bool wxToolBar::Create( wxWindow *parent, wxWindowID id,
m_xMargin = 0;
m_yMargin = 0;
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

42
src/gtk/textctrl.cpp
View File

@@ -46,11 +46,11 @@ gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
{
if (g_isIdle) wxapp_install_idle_handler();
if (!win->m_hasVMT) return;
if (!win->HasVMT()) return;
win->SetModified();
wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->m_windowId );
wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
event.SetString( win->GetValue() );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
@@ -67,7 +67,7 @@ gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
win->CalculateScrollbar();
if (!win->m_hasVMT) return;
if (!win->HasVMT()) return;
}
//-----------------------------------------------------------------------------
@@ -152,7 +152,6 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
/* ... and put into the upper left hand corner of the table */
m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
@@ -160,13 +159,11 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
/* always wrap words */
gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
/* put the horizontal scrollbar in the lower left hand corner */
if (bHasHScrollbar)
{
GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
GTK_WIDGET_UNSET_FLAGS( hscrollbar, GTK_CAN_FOCUS );
gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
GTK_FILL,
@@ -178,11 +175,9 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
gtk_text_set_line_wrap( GTK_TEXT(m_text), FALSE );
#endif
}
/* finally, put the vertical scrollbar in the upper right corner */
m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
GTK_FILL,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
@@ -200,9 +195,7 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
if (newSize.y == -1) newSize.y = 26;
SetSize( newSize.x, newSize.y );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -948,46 +941,53 @@ bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
return (window == GTK_ENTRY(m_text)->text_area);
}
void wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
bool wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
{
wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
// doesn't work
return FALSE;
}
void wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
bool wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
{
wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
// doesn't work
return FALSE;
}
void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
{
wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
wxControl::SetBackgroundColour( colour );
if (!m_widget->window) return;
if (!m_widget->window)
return FALSE;
wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
if (sysbg.Red() == colour.Red() &&
sysbg.Green() == colour.Green() &&
sysbg.Blue() == colour.Blue())
{
return;
return FALSE; // FIXME or TRUE?
}
if (!m_backgroundColour.Ok()) return;
if (!m_backgroundColour.Ok())
return FALSE;
if (m_windowStyle & wxTE_MULTILINE)
{
GdkWindow *window = GTK_TEXT(m_text)->text_area;
if (!window) return;
if (!window)
return FALSE;
m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
return TRUE;
}
void wxTextCtrl::ApplyWidgetStyle()

4
src/gtk/treectrl.cpp
View File

@@ -133,9 +133,7 @@ printf("5\n");
SetValidator(validator);
printf("Robert's new insertion code :-)\n");
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
printf("postcreate\n");
PostCreation();

1888
src/gtk/window.cpp
View File

File diff suppressed because it is too large Load Diff

12
src/gtk1/app.cpp
View File

@@ -45,7 +45,6 @@
wxApp *wxTheApp = (wxApp *) NULL;
wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
extern wxList wxPendingDelete;
#if wxUSE_THREADS
extern wxList *wxPendingEvents;
extern wxCriticalSection *wxPendingEventsLocker;
@@ -287,11 +286,12 @@ bool wxApp::OnInitGui()
int gg = (g << 3) | (g >> 2);
int bb = (b << 3) | (b >> 2);
int index = -1;
GdkColor *colors = cmap->colors;
if(colors)
{
int max = 3 * 65536;
int index = -1;
for (int i = 0; i < cmap->size; i++)
{
@@ -299,9 +299,13 @@ bool wxApp::OnInitGui()
int gdiff = ((gg << 8) - colors[i].green);
int bdiff = ((bb << 8) - colors[i].blue);
int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
if (sum < max) { index = i; max = sum; }
if (sum < max)
{
index = i; max = sum;
}
}
}
m_colorCube[ (r*1024) + (g*32) + b ] = index;
}
}
@@ -448,7 +452,7 @@ void wxApp::DeletePendingObjects()
delete obj;
if (wxPendingDelete.Member(obj))
if (wxPendingDelete.Find(obj))
delete node;
node = wxPendingDelete.First();

9
src/gtk1/bmpbuttn.cpp
View File

@@ -166,7 +166,7 @@ bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->InsertChild( this );
PostCreation();
@@ -278,11 +278,14 @@ void wxBitmapButton::SetBitmapSelected( const wxBitmap& bitmap )
SetBitmap();
}
void wxBitmapButton::Enable( const bool enable )
bool wxBitmapButton::Enable( bool enable )
{
wxWindow::Enable(enable);
if ( !wxWindow::Enable(enable) )
return FALSE;
SetBitmap();
return TRUE;
}
void wxBitmapButton::HasFocus()

13
src/gtk1/button.cpp
View File

@@ -96,9 +96,7 @@ bool wxButton::Create( wxWindow *parent, wxWindowID id, const wxString &label,
gtk_signal_connect( GTK_OBJECT(m_widget), "clicked",
GTK_SIGNAL_FUNC(gtk_button_clicked_callback), (gpointer*)this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -128,13 +126,14 @@ void wxButton::SetLabel( const wxString &label )
gtk_label_set( GTK_LABEL( GTK_BUTTON(m_widget)->child ), GetLabel().mbc_str() );
}
void wxButton::Enable( bool enable )
bool wxButton::Enable( bool enable )
{
wxCHECK_RET( m_widget != NULL, _T("invalid button") );
wxControl::Enable( enable );
if ( !wxControl::Enable( enable ) )
return FALSE;
gtk_widget_set_sensitive( GTK_BUTTON(m_widget)->child, enable );
return TRUE;
}
void wxButton::ApplyWidgetStyle()

13
src/gtk1/checkbox.cpp
View File

@@ -124,9 +124,7 @@ bool wxCheckBox::Create(wxWindow *parent,
GTK_SIGNAL_FUNC(gtk_checkbox_clicked_callback),
(gpointer *)this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -169,13 +167,14 @@ void wxCheckBox::SetLabel( const wxString& label )
gtk_label_set( GTK_LABEL(m_widgetLabel), GetLabel().mbc_str() );
}
void wxCheckBox::Enable( bool enable )
bool wxCheckBox::Enable( bool enable )
{
wxCHECK_RET( m_widgetLabel != NULL, _T("invalid checkbox") );
wxControl::Enable( enable );
if ( !wxControl::Enable( enable ) )
return FALSE;
gtk_widget_set_sensitive( m_widgetLabel, enable );
return TRUE;
}
void wxCheckBox::ApplyWidgetStyle()

4
src/gtk1/choice.cpp
View File

@@ -99,9 +99,7 @@ bool wxChoice::Create( wxWindow *parent, wxWindowID id,
}
gtk_option_menu_set_menu( GTK_OPTION_MENU(m_widget), menu );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

6
src/gtk1/combobox.cpp
View File

@@ -134,9 +134,7 @@ bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
gtk_widget_show( list_item );
}
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -582,7 +580,7 @@ void wxComboBox::OnChar( wxKeyEvent &event )
void wxComboBox::OnSize( wxSizeEvent &event )
{
wxControl::OnSize( event );
event.Skip();
return;

11
src/gtk1/dcclient.cpp
View File

@@ -110,8 +110,9 @@ wxWindowDC::wxWindowDC( wxWindow *window )
if (!window) return;
GtkWidget *widget = window->m_wxwindow;
if (!widget) return;
GtkWidget *widget = window->GetWxWindow();
if (!widget)
return;
m_window = widget->window;
@@ -126,10 +127,10 @@ wxWindowDC::wxWindowDC( wxWindow *window )
/* still not realized ? */
if (!m_window) return;
if (window->m_wxwindow)
m_cmap = gtk_widget_get_colormap( window->m_wxwindow );
if (window->GetWxWindow())
m_cmap = gtk_widget_get_colormap( window->GetWxWindow() );
else
m_cmap = gtk_widget_get_colormap( window->m_widget );
m_cmap = gtk_widget_get_colormap( window->GetHandle() );
m_isMemDC = FALSE;

34
src/gtk1/dialog.cpp
View File

@@ -69,11 +69,9 @@ static void gtk_dialog_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation
printf( ".\n" );
*/
if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
if ((win->GetWidth() != alloc->width) || (win->GetHeight() != alloc->height))
{
win->m_sizeSet = FALSE;
win->m_width = alloc->width;
win->m_height = alloc->height;
win->InternalSetSize( alloc->width, alloc->height );
}
}
@@ -87,10 +85,9 @@ static gint gtk_dialog_configure_callback( GtkWidget *WXUNUSED(widget), GdkEvent
if (!win->HasVMT()) return FALSE;
win->m_x = event->x;
win->m_y = event->y;
win->InternalSetPosition(event->x, event->y);
wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
wxMoveEvent mevent( wxPoint(win->GetX(),win->GetY()), win->GetId() );
mevent.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( mevent );
@@ -129,43 +126,43 @@ gtk_dialog_map_callback( GtkWidget *widget, wxDialog *win )
{
/* I haven''t been able to set the position of
the dialog before it is shown, so I do it here */
gtk_widget_set_uposition( widget, win->m_x, win->m_y );
gtk_widget_set_uposition( widget, win->GetX(), win->GetY() );
/* all this is for Motif Window Manager "hints" and is supposed to be
recognized by other WM as well. not tested. */
long decor = (long) GDK_DECOR_BORDER;
long func = (long) GDK_FUNC_MOVE ;
if ((win->m_windowStyle & wxCAPTION) != 0)
if ((win->GetWindowStyle() & wxCAPTION) != 0)
decor |= GDK_DECOR_TITLE;
if ((win->m_windowStyle & wxSYSTEM_MENU) != 0)
if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
{
decor |= GDK_DECOR_MENU;
func |= GDK_FUNC_CLOSE;
}
if ((win->m_windowStyle & wxMINIMIZE_BOX) != 0)
if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
{
func |= GDK_FUNC_MINIMIZE;
decor |= GDK_DECOR_MINIMIZE;
}
if ((win->m_windowStyle & wxMAXIMIZE_BOX) != 0)
if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
{
decor |= GDK_DECOR_MAXIMIZE;
func |= GDK_FUNC_MAXIMIZE;
}
if ((win->m_windowStyle & wxRESIZE_BORDER) != 0)
if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
{
func |= GDK_FUNC_RESIZE;
decor |= GDK_DECOR_RESIZEH;
}
gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
gdk_window_set_decorations( win->GetHandle()->window, (GdkWMDecoration)decor);
gdk_window_set_functions( win->GetHandle()->window, (GdkWMFunction)func);
/* GTK's shrinking/growing policy */
if ((win->m_windowStyle & wxRESIZE_BORDER) == 0)
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 0, 0, 1);
else
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 1, 1, 1);
return FALSE;
}
@@ -186,6 +183,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxDialog,wxPanel)
void wxDialog::Init()
{
m_returnCode = 0;
m_sizeSet = FALSE;
m_modalShowing = FALSE;
}

12
src/gtk1/dnd.cpp
View File

@@ -702,8 +702,8 @@ wxDropSource::wxDropSource( wxWindow *win, const wxIcon &go, const wxIcon &stop
m_waiting = TRUE;
m_window = win;
m_widget = win->m_widget;
if (win->m_wxwindow) m_widget = win->m_wxwindow;
m_widget = win->GetWidget();
if (win->GetWxWindow()) m_widget = win->GetWxWindow();
m_data = (wxDataBroker*) NULL;
m_retValue = wxDragCancel;
@@ -722,8 +722,8 @@ wxDropSource::wxDropSource( wxDataObject *data, wxWindow *win, const wxIcon &go,
m_waiting = TRUE;
m_window = win;
m_widget = win->m_widget;
if (win->m_wxwindow) m_widget = win->m_wxwindow;
m_widget = win->GetWidget();
if (win->GetWxWindow()) m_widget = win->GetWxWindow();
m_retValue = wxDragCancel;
if (data)
@@ -748,8 +748,8 @@ wxDropSource::wxDropSource( wxDataObject *data, wxWindow *win, const wxIcon &go,
wxDropSource::wxDropSource( wxDataBroker *data, wxWindow *win )
{
m_window = win;
m_widget = win->m_widget;
if (win->m_wxwindow) m_widget = win->m_wxwindow;
m_widget = win->GetWidget();
if (win->GetWxWindow()) m_widget = win->GetWxWindow();
m_retValue = wxDragCancel;
m_data = data;

2
src/gtk1/filedlg.cpp
View File

@@ -57,7 +57,7 @@ void gtk_filedialog_ok_callback( GtkWidget *WXUNUSED(widget), wxFileDialog *dial
int style = dialog->GetStyle();
GtkFileSelection *filedlg = GTK_FILE_SELECTION(dialog->m_widget);
GtkFileSelection *filedlg = GTK_FILE_SELECTION(dialog->GetHandle());
char *filename = gtk_file_selection_get_filename(filedlg);
if ( (style & wxSAVE) && ( style & wxOVERWRITE_PROMPT ) )

4
src/gtk1/font.cpp
View File

@@ -159,12 +159,12 @@ wxFont& wxFont::operator = ( const wxFont& font )
return *this;
}
bool wxFont::operator == ( const wxFont& font )
bool wxFont::operator == ( const wxFont& font ) const
{
return m_refData == font.m_refData;
}
bool wxFont::operator != ( const wxFont& font )
bool wxFont::operator != ( const wxFont& font ) const
{
return m_refData != font.m_refData;
}

132
src/gtk1/frame.cpp
View File

@@ -73,11 +73,9 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
printf( ".\n" );
*/
if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
if ((win->GetWidth() != alloc->width) || (win->GetHeight() != alloc->height))
{
win->m_sizeSet = FALSE;
win->m_width = alloc->width;
win->m_height = alloc->height;
win->InternalSetSize( alloc->width, alloc->height );
}
}
@@ -112,7 +110,7 @@ static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
if (!win->HasVMT()) return;
win->m_menuBarDetached = FALSE;
win->m_sizeSet = FALSE;
win->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -126,7 +124,7 @@ static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *
if (!win->HasVMT()) return;
win->m_menuBarDetached = TRUE;
win->m_sizeSet = FALSE;
win->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -140,7 +138,7 @@ static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidge
if (!win->HasVMT()) return;
win->m_toolBarDetached = FALSE;
win->m_sizeSet = FALSE;
win->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -154,7 +152,7 @@ static void gtk_toolbar_detached_callback( GtkWidget *widget, GtkWidget *WXUNUSE
if (!win->HasVMT()) return;
win->m_toolBarDetached = TRUE;
win->m_sizeSet = FALSE;
win->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -167,10 +165,9 @@ static gint gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventC
if (!win->HasVMT()) return FALSE;
win->m_x = event->x;
win->m_y = event->y;
win->InternalSetPosition(event->x, event->y);
wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
wxMoveEvent mevent( wxPoint(win->GetX(),win->GetY()), win->GetId() );
mevent.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( mevent );
@@ -194,38 +191,38 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
long decor = (long) GDK_DECOR_BORDER;
long func = (long) GDK_FUNC_MOVE;
if ((win->m_windowStyle & wxCAPTION) != 0)
if ((win->GetWindowStyle() & wxCAPTION) != 0)
decor |= GDK_DECOR_TITLE;
if ((win->m_windowStyle & wxSYSTEM_MENU) != 0)
if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
{
decor |= GDK_DECOR_MENU;
func |= GDK_FUNC_CLOSE;
}
if ((win->m_windowStyle & wxMINIMIZE_BOX) != 0)
if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
{
func |= GDK_FUNC_MINIMIZE;
decor |= GDK_DECOR_MINIMIZE;
}
if ((win->m_windowStyle & wxMAXIMIZE_BOX) != 0)
if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
{
func |= GDK_FUNC_MAXIMIZE;
decor |= GDK_DECOR_MAXIMIZE;
}
if ((win->m_windowStyle & wxRESIZE_BORDER) != 0)
if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
{
func |= GDK_FUNC_RESIZE;
decor |= GDK_DECOR_RESIZEH;
}
gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
gdk_window_set_decorations( win->GetHandle()->window, (GdkWMDecoration)decor);
gdk_window_set_functions( win->GetHandle()->window, (GdkWMFunction)func);
/* GTK's shrinking/growing policy */
if ((win->m_windowStyle & wxRESIZE_BORDER) == 0)
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 0, 0, 1);
else
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
gtk_window_set_policy(GTK_WINDOW(win->GetHandle()), 1, 1, 1);
/* reset the icon */
if (win->m_icon != wxNullIcon)
@@ -237,17 +234,17 @@ gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
/* we set the focus to the child that accepts the focus. this
doesn't really have to be done in "realize" but why not? */
wxNode *node = win->m_children.First();
wxWindowList::Node *node = win->GetChildren().GetFirst();
while (node)
{
wxWindow *child = (wxWindow*) node->Data();
wxWindow *child = node->GetData();
if (child->AcceptsFocus())
{
child->SetFocus();
break;
}
node = node->Next();
node = node->GetNext();
}
return FALSE;
@@ -272,23 +269,23 @@ static void wxInsertChildInFrame( wxWindow* parent, wxWindow* child )
/* these are outside the client area */
wxFrame* frame = (wxFrame*) parent;
gtk_myfixed_put( GTK_MYFIXED(frame->m_mainWidget),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
child->m_width,
child->m_height );
GTK_WIDGET(child->GetHandle()),
child->GetX(),
child->GetY(),
child->GetWidth(),
child->GetHeight() );
/* we connect to these events for recalculating the client area
space when the toolbar is floating */
if (wxIS_KIND_OF(child,wxToolBar))
{
wxToolBar *toolBar = (wxToolBar*) child;
if (toolBar->m_windowStyle & wxTB_DOCKABLE)
if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
{
gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",
gtk_signal_connect( GTK_OBJECT(toolBar->GetHandle()), "child_attached",
GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );
gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",
gtk_signal_connect( GTK_OBJECT(toolBar->GetHandle()), "child_detached",
GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );
}
}
@@ -296,16 +293,16 @@ static void wxInsertChildInFrame( wxWindow* parent, wxWindow* child )
else
{
/* these are inside the client area */
gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
GTK_WIDGET(child->m_widget),
child->m_x,
child->m_y,
child->m_width,
child->m_height );
gtk_myfixed_put( GTK_MYFIXED(parent->GetWxWindow()),
GTK_WIDGET(child->GetHandle()),
child->GetX(),
child->GetY(),
child->GetWidth(),
child->GetHeight() );
}
/* resize on OnInternalIdle */
parent->m_sizeSet = FALSE;
parent->UpdateSize();
}
//-----------------------------------------------------------------------------
@@ -671,12 +668,10 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
int ww = m_width - 2*m_miniEdge;
int hh = wxMENU_HEIGHT;
if (m_menuBarDetached) hh = wxPLACE_HOLDER;
m_frameMenuBar->m_x = xx;
m_frameMenuBar->m_y = yy;
m_frameMenuBar->m_width = ww;
m_frameMenuBar->m_height = hh;
m_frameMenuBar->InternalSetPosition(xx, yy);
m_frameMenuBar->InternalSetSize(ww, hh);
gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
m_frameMenuBar->m_widget,
m_frameMenuBar->GetHandle(),
xx, yy, ww, hh );
client_area_y_offset += hh;
}
@@ -693,14 +688,17 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
yy += wxPLACE_HOLDER;
}
int ww = m_width - 2*m_miniEdge;
int hh = m_frameToolBar->m_height;
if (m_toolBarDetached) hh = wxPLACE_HOLDER;
m_frameToolBar->m_x = xx;
m_frameToolBar->m_y = yy;
/* m_frameToolBar->m_height = hh; don't change the toolbar's height */
m_frameToolBar->m_width = ww;
int hh = m_frameToolBar->GetHeight();
// VZ: according to earlier comments in this file, the tbar height
// shouldn't be changed, so I comment out the next line
// (09.05.99)
//if (m_toolBarDetached) hh = wxPLACE_HOLDER;
m_frameToolBar->InternalSetPosition(xx, yy);
m_frameToolBar->InternalSetSize(ww, hh);
gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
m_frameToolBar->m_widget,
m_frameToolBar->GetHandle(),
xx, yy, ww, hh );
client_area_y_offset += hh;
}
@@ -725,12 +723,10 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
int ww = m_width - 2*m_miniEdge;
int hh = wxSTATUS_HEIGHT;
m_frameStatusBar->m_x = xx;
m_frameStatusBar->m_y = yy;
m_frameStatusBar->m_width = ww;
m_frameStatusBar->m_height = hh;
m_frameStatusBar->InternalSetPosition(xx, yy);
m_frameStatusBar->InternalSetSize(ww, hh);
gtk_myfixed_set_size( GTK_MYFIXED(m_wxwindow),
m_frameStatusBar->m_widget,
m_frameStatusBar->GetHandle(),
xx, yy, ww, hh );
}
@@ -747,7 +743,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height
/* send size event to status bar */
if (m_frameStatusBar)
{
wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
wxSizeEvent event2( wxSize(m_frameStatusBar->GetWidth(),m_frameStatusBar->GetHeight()), m_frameStatusBar->GetId() );
event2.SetEventObject( m_frameStatusBar );
m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
}
@@ -812,7 +808,7 @@ static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
#if (GTK_MINOR_VERSION > 0)
/* support for native hot keys */
gtk_accel_group_attach( menu->m_accel, GTK_OBJECT(win->m_widget));
gtk_accel_group_attach( menu->m_accel, GTK_OBJECT(win->GetHandle()));
#endif
wxNode *node = menu->GetItems().First();
@@ -847,22 +843,22 @@ void wxFrame::SetMenuBar( wxMenuBar *menuBar )
node = node->Next();
}
if (m_frameMenuBar->m_parent != this)
if (m_frameMenuBar->GetParent() != this)
{
m_frameMenuBar->m_parent = this;
m_frameMenuBar->SetParent(this);
gtk_myfixed_put( GTK_MYFIXED(m_mainWidget),
m_frameMenuBar->m_widget,
m_frameMenuBar->m_x,
m_frameMenuBar->m_y,
m_frameMenuBar->m_width,
m_frameMenuBar->m_height );
m_frameMenuBar->GetHandle(),
m_frameMenuBar->GetX(),
m_frameMenuBar->GetY(),
m_frameMenuBar->GetWidth(),
m_frameMenuBar->GetHeight() );
if (menuBar->m_windowStyle & wxMB_DOCKABLE)
if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
{
gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
gtk_signal_connect( GTK_OBJECT(menuBar->GetHandle()), "child_attached",
GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
gtk_signal_connect( GTK_OBJECT(menuBar->GetHandle()), "child_detached",
GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
}
}

4
src/gtk1/gauge.cpp
View File

@@ -37,9 +37,7 @@ bool wxGauge::Create( wxWindow *parent, wxWindowID id, int range,
m_widget = gtk_progress_bar_new();
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

11
src/gtk1/listbox.cpp
View File

@@ -282,9 +282,7 @@ bool wxListBox::Create( wxWindow *parent, wxWindowID id,
gtk_widget_show( list_item );
}
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -419,7 +417,7 @@ void wxListBox::AppendCommon( const wxString &item )
gtk_signal_connect( GTK_OBJECT(list_item), "select",
GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
if (GetWindowStyleFlag() & wxLB_MULTIPLE)
if (HasFlag(wxLB_MULTIPLE))
gtk_signal_connect( GTK_OBJECT(list_item), "deselect",
GTK_SIGNAL_FUNC(gtk_listitem_select_callback), (gpointer)this );
@@ -454,7 +452,7 @@ void wxListBox::AppendCommon( const wxString &item )
#endif
#if wxUSE_TOOLTIPS
if (m_toolTip) m_toolTip->Apply( this );
if (m_tooltip) m_tooltip->Apply( this );
#endif
}
}
@@ -858,10 +856,13 @@ void wxListBox::ApplyWidgetStyle()
if (m_backgroundColour.Ok())
{
GdkWindow *window = GTK_WIDGET(m_list)->window;
if ( window )
{
m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
}
GList *child = m_list->children;
while (child)

62
src/gtk1/mdi.cpp
View File

@@ -90,14 +90,12 @@ void wxMDIParentFrame::GtkOnSize( int x, int y, int width, int height )
wxMenuBar *menu_bar = child_frame->m_menuBar;
if (!menu_bar) return;
if (!menu_bar->m_widget) return;
if (!menu_bar->GetHandle()) return;
menu_bar->m_x = 0;
menu_bar->m_y = 0;
menu_bar->m_width = m_width;
menu_bar->m_height = wxMENU_HEIGHT;
menu_bar->InternalSetPosition(0, 0);
menu_bar->InternalSetSize(m_width, wxMENU_HEIGHT);
gtk_myfixed_set_size( GTK_MYFIXED(m_mainWidget),
menu_bar->m_widget,
menu_bar->GetHandle(),
0, 0, m_width, wxMENU_HEIGHT );
}
@@ -110,7 +108,7 @@ void wxMDIParentFrame::OnInternalIdle()
if (m_justInserted)
{
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->GetHandle());
gtk_notebook_set_page( notebook, g_list_length( notebook->children ) - 1 );
m_justInserted = FALSE;
@@ -122,7 +120,7 @@ void wxMDIParentFrame::OnInternalIdle()
wxMDIChildFrame *active_child_frame = GetActiveChild();
bool visible_child_menu = FALSE;
wxNode *node = m_clientWindow->m_children.First();
wxNode *node = m_clientWindow->GetChildren().First();
while (node)
{
wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
@@ -130,11 +128,11 @@ void wxMDIParentFrame::OnInternalIdle()
{
if (child_frame == active_child_frame)
{
gtk_widget_show( child_frame->m_menuBar->m_widget );
gtk_widget_show( child_frame->m_menuBar->GetHandle() );
visible_child_menu = TRUE;
}
else
gtk_widget_hide( child_frame->m_menuBar->m_widget );
gtk_widget_hide( child_frame->m_menuBar->GetHandle() );
}
node = node->Next();
}
@@ -152,7 +150,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
if (!m_clientWindow) return (wxMDIChildFrame*) NULL;
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->GetHandle());
if (!notebook) return (wxMDIChildFrame*) NULL;
#if (GTK_MINOR_VERSION > 0)
@@ -165,7 +163,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
if (!page) return (wxMDIChildFrame*) NULL;
wxNode *node = m_clientWindow->m_children.First();
wxNode *node = m_clientWindow->GetChildren().First();
while (node)
{
wxMDIChildFrame *child_frame = (wxMDIChildFrame *)node->Data();
@@ -191,13 +189,13 @@ wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
void wxMDIParentFrame::ActivateNext()
{
if (m_clientWindow)
gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->GetHandle()) );
}
void wxMDIParentFrame::ActivatePrevious()
{
if (m_clientWindow)
gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->GetHandle()) );
}
void wxMDIParentFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
@@ -279,9 +277,9 @@ void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
if (m_menuBar)
{
wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->m_parent;
wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();
if (m_menuBar->m_parent != this)
if (m_menuBar->GetParent() != this)
{
wxNode *node = m_menuBar->GetMenus().First();
while (node)
@@ -291,16 +289,16 @@ void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
node = node->Next();
}
m_menuBar->m_parent = mdi_frame;
m_menuBar->SetParent( mdi_frame );
}
/* the menu bar of the child window is shown in idle time as needed */
gtk_widget_hide( m_menuBar->m_widget );
gtk_widget_hide( m_menuBar->GetHandle() );
/* insert the invisible menu bar into the _parent_ mdi frame */
gtk_myfixed_put( GTK_MYFIXED(mdi_frame->m_mainWidget),
m_menuBar->m_widget,
0, 0, mdi_frame->m_width, wxMENU_HEIGHT );
m_menuBar->GetHandle(),
0, 0, mdi_frame->GetWidth(), wxMENU_HEIGHT );
}
}
@@ -325,11 +323,11 @@ static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
{
if (g_isIdle) wxapp_install_idle_handler();
if ((win->m_x == alloc->x) &&
(win->m_y == alloc->y) &&
(win->m_width == alloc->width) &&
(win->m_height == alloc->height) &&
(win->m_sizeSet))
if ((win->GetX() == alloc->x) &&
(win->GetY() == alloc->y) &&
(win->GetWidth() == alloc->width) &&
(win->GetHeight() == alloc->height) &&
(win->IsSizeSet()))
{
return;
}
@@ -349,16 +347,16 @@ static void wxInsertChildInMDI( wxMDIClientWindow* parent, wxMDIChildFrame* chil
GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
gtk_signal_connect( GTK_OBJECT(child->GetHandle()), "size_allocate",
GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
GtkNotebook *notebook = GTK_NOTEBOOK(parent->GetHandle());
gtk_notebook_append_page( notebook, child->m_widget, label_widget );
gtk_notebook_append_page( notebook, child->GetHandle(), label_widget );
child->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
wxMDIParentFrame *parent_frame = (wxMDIParentFrame*) parent->m_parent;
wxMDIParentFrame *parent_frame = (wxMDIParentFrame*) parent->GetParent();
parent_frame->m_justInserted = TRUE;
}
@@ -393,9 +391,7 @@ bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -404,5 +400,3 @@ bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
return TRUE;
}

37
src/gtk1/minifram.cpp
View File

@@ -73,23 +73,23 @@ static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *g
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
0, 0,
win->m_width, win->m_height );
win->GetWidth(), win->GetHeight() );
if (!win->m_title.IsEmpty() &&
((win->m_windowStyle & wxCAPTION) ||
(win->m_windowStyle & wxTINY_CAPTION_HORIZ) ||
(win->m_windowStyle & wxTINY_CAPTION_VERT)))
((win->GetWindowStyle() & wxCAPTION) ||
(win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) ||
(win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
{
GdkGC *gc = gdk_gc_new( widget->window );
GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
int x = 2;
if (win->m_windowStyle & wxSYSTEM_MENU) x = 18;
if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 18;
gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
gdk_draw_rectangle( widget->window, gc, TRUE,
x,
3,
win->m_width - 4 - x,
win->GetWidth() - 4 - x,
font->ascent + font->descent+1 );
gdk_gc_set_foreground( gc, &widget->style->white );
@@ -117,23 +117,23 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
0, 0,
win->m_width, win->m_height );
win->GetWidth(), win->GetHeight() );
if (!win->m_title.IsEmpty() &&
((win->m_windowStyle & wxCAPTION) ||
(win->m_windowStyle & wxTINY_CAPTION_HORIZ) ||
(win->m_windowStyle & wxTINY_CAPTION_VERT)))
((win->GetWindowStyle() & wxCAPTION) ||
(win->GetWindowStyle() & wxTINY_CAPTION_HORIZ) ||
(win->GetWindowStyle() & wxTINY_CAPTION_VERT)))
{
GdkGC *gc = gdk_gc_new( widget->window );
GdkFont *font = wxSMALL_FONT->GetInternalFont(1.0);
int x = 2;
if (win->m_windowStyle & wxSYSTEM_MENU) x = 17;
if (win->GetWindowStyle() & wxSYSTEM_MENU) x = 17;
gdk_gc_set_foreground( gc, &widget->style->bg[GTK_STATE_SELECTED] );
gdk_draw_rectangle( widget->window, gc, TRUE,
x,
3,
win->m_width - 4 - x,
win->GetWidth() - 4 - x,
font->ascent + font->descent+1 );
gdk_gc_set_foreground( gc, &widget->style->white );
@@ -174,7 +174,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton
win->m_diffX = (int)gdk_event->x;
win->m_diffY = (int)gdk_event->y;
DrawFrame( widget, 0, 0, win->m_width, win->m_height );
DrawFrame( widget, 0, 0, win->GetWidth(), win->GetHeight() );
win->m_oldX = 0;
win->m_oldY = 0;
@@ -202,16 +202,15 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto
int x = (int)gdk_event->x;
int y = (int)gdk_event->y;
DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
gdk_pointer_ungrab ( GDK_CURRENT_TIME );
int org_x = 0;
int org_y = 0;
gdk_window_get_origin( widget->window, &org_x, &org_y );
x += org_x - win->m_diffX;
y += org_y - win->m_diffY;
win->m_x = x;
win->m_y = y;
gtk_widget_set_uposition( win->m_widget, x, y );
win->InternalSetPosition(x, y);
gtk_widget_set_uposition( win->GetWidget(), x, y );
return TRUE;
}
@@ -241,10 +240,10 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion
gdk_event->state = state;
}
DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
win->m_oldX = (int)gdk_event->x - win->m_diffX;
win->m_oldY = (int)gdk_event->y - win->m_diffY;
DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
DrawFrame( widget, win->m_oldX, win->m_oldY, win->GetWidth(), win->GetHeight() );
return TRUE;
}

18
src/gtk1/notebook.cpp
View File

@@ -125,10 +125,10 @@ static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
{
if (g_isIdle) wxapp_install_idle_handler();
if ((win->m_x == alloc->x) &&
(win->m_y == alloc->y) &&
(win->m_width == alloc->width) &&
(win->m_height == alloc->height))
if ((win->GetX() == alloc->x) &&
(win->GetY() == alloc->y) &&
(win->GetWidth() == alloc->width) &&
(win->GetHeight() == alloc->height))
{
return;
}
@@ -188,16 +188,16 @@ static void wxInsertChildInNotebook( wxNotebook* parent, wxWindow* child )
page->m_box = gtk_hbox_new (FALSE, 0);
gtk_container_border_width(GTK_CONTAINER(page->m_box), 2);
GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
GtkNotebook *notebook = GTK_NOTEBOOK(parent->GetWidget());
page->m_client = child;
gtk_notebook_append_page( notebook, child->m_widget, page->m_box );
gtk_notebook_append_page( notebook, child->GetWidget(), page->m_box );
page->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
page->m_parent = notebook;
gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
gtk_signal_connect( GTK_OBJECT(child->GetWidget()), "size_allocate",
GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
wxASSERT_MSG( page->m_page, _T("Notebook page creation error") );
@@ -267,9 +267,7 @@ bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback),
(gpointer)this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this );

27
src/gtk1/radiobox.cpp
View File

@@ -68,7 +68,7 @@ BEGIN_EVENT_TABLE(wxRadioBox, wxControl)
EVT_SIZE(wxRadioBox::OnSize)
END_EVENT_TABLE()
wxRadioBox::wxRadioBox(void)
wxRadioBox::wxRadioBox()
{
}
@@ -108,7 +108,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
gtk_signal_connect( GTK_OBJECT(m_radio), "clicked",
GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
gtk_myfixed_put( GTK_MYFIXED(m_parent->m_wxwindow),
gtk_myfixed_put( GTK_MYFIXED(m_parent->GetWxWindow()),
GTK_WIDGET(m_radio),
m_x+10, m_y+10+(i*24), 10, 10 );
}
@@ -120,9 +120,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
if (newSize.y == -1) newSize.y = ls.y;
SetSize( newSize.x, newSize.y );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -137,7 +135,7 @@ bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
return TRUE;
}
wxRadioBox::~wxRadioBox(void)
wxRadioBox::~wxRadioBox()
{
wxNode *node = m_boxes.First();
while (node)
@@ -150,9 +148,9 @@ wxRadioBox::~wxRadioBox(void)
void wxRadioBox::OnSize( wxSizeEvent &event )
{
wxControl::OnSize( event );
LayoutItems();
event.Skip();
}
wxSize wxRadioBox::LayoutItems()
@@ -181,7 +179,7 @@ wxSize wxRadioBox::LayoutItems()
int len = 22+gdk_string_measure( font, label->label );
if (len > max_len) max_len = len;
gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y );
gtk_myfixed_move( GTK_MYFIXED(m_parent->GetWxWindow()), button, m_x+x, m_y+y );
y += 20;
node = node->Next();
@@ -195,7 +193,7 @@ wxSize wxRadioBox::LayoutItems()
{
GtkWidget *button = GTK_WIDGET( node->Data() );
gtk_myfixed_resize( GTK_MYFIXED(m_parent->m_wxwindow), button, max_len, 20 );
gtk_myfixed_resize( GTK_MYFIXED(m_parent->GetWxWindow()), button, max_len, 20 );
node = node->Next();
if (!node) break;
@@ -231,7 +229,7 @@ wxSize wxRadioBox::LayoutItems()
{
GtkWidget *button = GTK_WIDGET( node->Data() );
gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow), button, m_x+x, m_y+y, max, 20 );
gtk_myfixed_set_size( GTK_MYFIXED(m_parent->GetWxWindow()), button, m_x+x, m_y+y, max, 20 );
x += max;
node = node->Next();
@@ -389,9 +387,10 @@ void wxRadioBox::SetLabel( int WXUNUSED(item), wxBitmap *WXUNUSED(bitmap) )
wxFAIL_MSG(_T("wxRadioBox::SetLabel not implemented."));
}
void wxRadioBox::Enable( bool enable )
bool wxRadioBox::Enable( bool enable )
{
wxControl::Enable( enable );
if ( !wxControl::Enable( enable ) )
return FALSE;
wxNode *node = m_boxes.First();
while (node)
@@ -402,6 +401,8 @@ void wxRadioBox::Enable( bool enable )
gtk_widget_set_sensitive( label, enable );
node = node->Next();
}
return TRUE;
}
void wxRadioBox::Enable( int item, bool enable )

13
src/gtk1/radiobut.cpp
View File

@@ -91,9 +91,7 @@ bool wxRadioButton::Create( wxWindow *parent, wxWindowID id, const wxString& lab
gtk_signal_connect( GTK_OBJECT(m_widget), "clicked",
GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -138,13 +136,14 @@ bool wxRadioButton::GetValue(void) const
return GTK_TOGGLE_BUTTON(m_widget)->active;
}
void wxRadioButton::Enable( bool enable )
bool wxRadioButton::Enable( bool enable )
{
wxCHECK_RET( m_widget != NULL, _T("invalid radiobutton") );
wxControl::Enable( enable );
if ( !wxControl::Enable( enable ) )
return FALSE;
gtk_widget_set_sensitive( GTK_BUTTON(m_widget)->child, enable );
return TRUE;
}
void wxRadioButton::ApplyWidgetStyle()

13
src/gtk1/scrolbar.cpp
View File

@@ -53,7 +53,7 @@ static void gtk_scrollbar_callback( GtkWidget *WXUNUSED(widget), wxScrollBar *wi
float line_step = win->m_adjust->step_increment;
float page_step = win->m_adjust->page_increment;
if (win->m_isScrolling)
if (win->IsScrolling())
{
command = wxEVT_SCROLL_THUMBTRACK;
}
@@ -70,8 +70,7 @@ static void gtk_scrollbar_callback( GtkWidget *WXUNUSED(widget), wxScrollBar *wi
int value = (int)(win->m_adjust->value+0.5);
int orient = wxHORIZONTAL;
if (win->GetWindowStyleFlag() & wxSB_VERTICAL == wxSB_VERTICAL) orient = wxVERTICAL;
int orient = win->HasFlag(wxSB_VERTICAL) ? wxVERTICAL : wxHORIZONTAL;
wxScrollEvent event( command, win->GetId(), value, orient );
event.SetEventObject( win );
@@ -94,7 +93,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
{
if (g_isIdle) wxapp_install_idle_handler();
win->m_isScrolling = TRUE;
win->SetScrolling(TRUE);
// g_blockEventsOnScroll = TRUE; doesn't work in DialogEd
return FALSE;
@@ -110,7 +109,7 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *WXUNUSED(widget),
{
if (g_isIdle) wxapp_install_idle_handler();
win->m_isScrolling = FALSE;
win->SetScrolling(FALSE);
// g_blockEventsOnScroll = FALSE;
gtk_signal_emit_by_name( GTK_OBJECT(win->m_adjust), "value_changed" );
@@ -163,9 +162,7 @@ bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
(GtkSignalFunc)gtk_scrollbar_button_release_callback,
(gpointer) this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk1/slider.cpp
View File

@@ -144,9 +144,7 @@ bool wxSlider::Create(wxWindow *parent, wxWindowID id,
SetRange( minValue, maxValue );
SetValue( value );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk1/spinbutt.cpp
View File

@@ -111,9 +111,7 @@ bool wxSpinButton::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, c
(GtkSignalFunc) gtk_spinbutt_callback,
(gpointer) this );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk1/statbmp.cpp
View File

@@ -60,9 +60,7 @@ bool wxStaticBitmap::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bi
m_widget = gtk_label_new( "Bitmap" );
}
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk1/statbox.cpp
View File

@@ -45,9 +45,7 @@ bool wxStaticBox::Create( wxWindow *parent, wxWindowID id, const wxString &label
m_widget = gtk_frame_new(m_label.mbc_str());
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk1/statline.cpp
View File

@@ -46,9 +46,7 @@ bool wxStaticLine::Create( wxWindow *parent, wxWindowID id,
else
m_widget = gtk_hseparator_new();
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk1/stattext.cpp
View File

@@ -76,9 +76,7 @@ bool wxStaticText::Create(wxWindow *parent,
SetSize( newSize.x, newSize.y );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

4
src/gtk1/tbargtk.cpp
View File

@@ -209,9 +209,7 @@ bool wxToolBar::Create( wxWindow *parent, wxWindowID id,
m_xMargin = 0;
m_yMargin = 0;
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();

42
src/gtk1/textctrl.cpp
View File

@@ -46,11 +46,11 @@ gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
{
if (g_isIdle) wxapp_install_idle_handler();
if (!win->m_hasVMT) return;
if (!win->HasVMT()) return;
win->SetModified();
wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->m_windowId );
wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
event.SetString( win->GetValue() );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
@@ -67,7 +67,7 @@ gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
win->CalculateScrollbar();
if (!win->m_hasVMT) return;
if (!win->HasVMT()) return;
}
//-----------------------------------------------------------------------------
@@ -152,7 +152,6 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
/* ... and put into the upper left hand corner of the table */
m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
@@ -160,13 +159,11 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
/* always wrap words */
gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
/* put the horizontal scrollbar in the lower left hand corner */
if (bHasHScrollbar)
{
GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
GTK_WIDGET_UNSET_FLAGS( hscrollbar, GTK_CAN_FOCUS );
gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
GTK_FILL,
@@ -178,11 +175,9 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
gtk_text_set_line_wrap( GTK_TEXT(m_text), FALSE );
#endif
}
/* finally, put the vertical scrollbar in the upper right corner */
m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
GTK_FILL,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
@@ -200,9 +195,7 @@ bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
if (newSize.y == -1) newSize.y = 26;
SetSize( newSize.x, newSize.y );
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
PostCreation();
@@ -948,46 +941,53 @@ bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
return (window == GTK_ENTRY(m_text)->text_area);
}
void wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
bool wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
{
wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
// doesn't work
return FALSE;
}
void wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
bool wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
{
wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
// doesn't work
return FALSE;
}
void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
{
wxCHECK_RET( m_text != NULL, _T("invalid text ctrl") );
wxCHECK_MSG( m_text != NULL, FALSE, _T("invalid text ctrl") );
wxControl::SetBackgroundColour( colour );
if (!m_widget->window) return;
if (!m_widget->window)
return FALSE;
wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
if (sysbg.Red() == colour.Red() &&
sysbg.Green() == colour.Green() &&
sysbg.Blue() == colour.Blue())
{
return;
return FALSE; // FIXME or TRUE?
}
if (!m_backgroundColour.Ok()) return;
if (!m_backgroundColour.Ok())
return FALSE;
if (m_windowStyle & wxTE_MULTILINE)
{
GdkWindow *window = GTK_TEXT(m_text)->text_area;
if (!window) return;
if (!window)
return FALSE;
m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
return TRUE;
}
void wxTextCtrl::ApplyWidgetStyle()

4
src/gtk1/treectrl.cpp
View File

@@ -133,9 +133,7 @@ printf("5\n");
SetValidator(validator);
printf("Robert's new insertion code :-)\n");
m_parent->AddChild( this );
(m_parent->m_insertCallback)( m_parent, this );
m_parent->DoAddChild( this );
printf("postcreate\n");
PostCreation();

1888
src/gtk1/window.cpp
View File

File diff suppressed because it is too large Load Diff