[wxWidgets.git] / include / wx / gtk / window.h

/////////////////////////////////////////////////////////////////////////////
// Name:        window.h
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////


#ifndef __GTKWINDOWH__
#define __GTKWINDOWH__

#ifdef __GNUG__
#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 char *wxFrameNameStr;
extern wxList wxTopLevelWindows;

//-----------------------------------------------------------------------------
// global function
//-----------------------------------------------------------------------------

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 char *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;
};

//-----------------------------------------------------------------------------
// (debug)
//-----------------------------------------------------------------------------

#ifdef __WXDEBUG__

void debug_focus_in( GtkWidget* widget, const char* name, const char* window );

#endif

//-----------------------------------------------------------------------------
// wxWindow
//-----------------------------------------------------------------------------

class wxWindow: public wxEvtHandler
{
  DECLARE_DYNAMIC_CLASS(wxWindow)

public:
  wxWindow();
  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,
           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

  bool Close( bool force = FALSE );
  virtual bool Destroy();
  virtual bool DestroyChildren();

  virtual void PrepareDC( wxDC &dc );

  virtual void SetSize( int x, int y, int width, int height,
    int sizeFlags = wxSIZE_AUTO );
  virtual void SetSize( int width, int height );

  virtual void Move( int x, int y );

  virtual void GetSize( int *width, int *height ) const;
  wxSize GetSize() const { int w, h; GetSize(& w, & h); return wxSize(w, h); }

  virtual void SetClientSize( int const width, int const height );

  virtual void GetClientSize( int *width, int *height ) const;
  wxSize GetClientSize() const { int w, h; GetClientSize(& w, & h); return wxSize(w, h); }

  virtual void GetPosition( int *x, int *y ) const;
  wxPoint GetPosition() const { int w, h; GetPosition(& w, & h); return wxPoint(w, h); }

  wxRect GetRect() const
    { int x, y, w, h; GetPosition(& x, & y); GetSize(& w, & h); return wxRect(x, y, w, h); }

  virtual void Centre( int direction = wxHORIZONTAL );
  inline void Center(int direction = wxHORIZONTAL) { Centre(direction); }
  virtual void Fit();

  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 );
  inline wxSize ConvertPixelsToDialog( const wxSize& sz )
      { wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }
  inline wxSize ConvertDialogToPixels( const wxSize& sz )
      { wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }

  void OnSize( wxSizeEvent &event );

  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 bool OnClose();

  virtual void SetFocus();
  static wxWindow *FindFocus();

  virtual void AddChild( wxWindow *child );
  wxList& GetChildren() { return m_children; }

  virtual void RemoveChild( wxWindow *child );
  void SetReturnCode( int retCode );
  int GetReturnCode();
  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 );

  wxEvtHandler *GetEventHandler() const;
  void SetEventHandler( wxEvtHandler *handler );
  void PushEventHandler( wxEvtHandler *handler );
  wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );

  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();

  virtual void SetAcceleratorTable( const wxAcceleratorTable& accel );
  virtual wxAcceleratorTable *GetAcceleratorTable() { return &m_acceleratorTable; }

  bool IsBeingDeleted();

  void SetId( wxWindowID id );
  wxWindowID GetId() const;

  void SetCursor( const wxCursor &cursor );

  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;

  virtual wxColour GetBackgroundColour() const;
  virtual void SetBackgroundColour( const wxColour &colour );
  virtual wxColour GetForegroundColour() const;
  virtual void SetForegroundColour( const wxColour &colour );

  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
  inline virtual void SetButtonFont(const wxFont& font) { SetFont(font); }
  inline virtual void SetLabelFont(const wxFont& font) { SetFont(font); }
  inline virtual wxFont& GetLabelFont() { return GetFont(); };
  inline 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 );

  void AllowDoubleClick( bool WXUNUSED(allow) ) {};
  void SetDoubleClick( bool WXUNUSED(allow) ) {};

  virtual void ClientToScreen( int *x, int *y );
  virtual void ScreenToClient( int *x, int *y );

  virtual bool Validate();
  virtual bool TransferDataToWindow();
  virtual bool TransferDataFromWindow();
  void OnInitDialog( wxInitDialogEvent &event );
  virtual void InitDialog();

  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 bool AcceptsFocus() const;

  void UpdateWindowUI();

  // implementation

  virtual wxPoint GetClientAreaOrigin() const;
  virtual void AdjustForParentClientOrigin( int& x, int& y, int sizeFlags );

  bool HasVMT();

  virtual void OnInternalIdle();

  /* used by all classes in the widget creation process */

  void PreCreation( wxWindow *parent, wxWindowID id, const wxPoint &pos,
                    const wxSize &size, long style, const wxString &name );
  void PostCreation();

  /* 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.
     also, it is nor clear, which native widget is the top
     widget where (most of) the input goes. even tooltips have
     to be applied to all subwidgets. */

  virtual GtkWidget* GetConnectWidget();
  virtual bool IsOwnGtkWindow( GdkWindow *window );
  void ConnectWidget( GtkWidget *widget );

  GtkStyle *GetWidgetStyle();
  void SetWidgetStyle();
  virtual void ApplyWidgetStyle();

#if wxUSE_TOOLTIPS
  virtual void ApplyToolTip( GtkTooltips *tips, const char *tip );
#endif // wxUSE_TOOLTIPS

  /* private member variables */

  wxWindow            *m_parent;
  wxList               m_children;
  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;
  GtkWidget           *m_wxwindow;
  GtkAdjustment       *m_hAdjust,*m_vAdjust;
  float                m_oldHorizontalPos;
  float                m_oldVerticalPos;
  bool                 m_needParent;
  bool                 m_hasScrolling;
  bool                 m_isScrolling;
  bool                 m_hasVMT;
  bool                 m_sizeSet;
  bool                 m_resizing;
  GdkGC               *m_scrollGC;
  GtkStyle            *m_widgetStyle;
  bool                 m_isStaticBox;
  bool                 m_acceptsFocus;

  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 ;

private:
  DECLARE_EVENT_TABLE()
};

#endif // __GTKWINDOWH__
Commit	Line	Data
c801d85f KB	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: window.h
	3	// Purpose:
	4	// Author: Robert Roebling
58614078 RR	5	// Id: $Id$
58614078 RR	6	// Copyright: (c) 1998 Robert Roebling
aed8df38	7	// Licence: wxWindows licence
c801d85f KB	8	/////////////////////////////////////////////////////////////////////////////
	9
	10
	11	#ifndef __GTKWINDOWH__
	12	#define __GTKWINDOWH__
	13
	14	#ifdef __GNUG__
	15	#pragma interface
	16	#endif
	17
	18	#include "wx/defs.h"
	19	#include "wx/object.h"
	20	#include "wx/list.h"
	21	#include "wx/event.h"
	22	#include "wx/validate.h"
	23	#include "wx/cursor.h"
	24	#include "wx/font.h"
c801d85f	25	#include "wx/region.h"
bcf1fa6b	26	#include "wx/accel.h"
c801d85f KB	27
	28	//-----------------------------------------------------------------------------
	29	// global data
	30	//-----------------------------------------------------------------------------
	31
	32	extern const char *wxFrameNameStr;
	33	extern wxList wxTopLevelWindows;
	34
bbe0af5b RR	35	//-----------------------------------------------------------------------------
	36	// global function
	37	//-----------------------------------------------------------------------------
	38
	39	wxWindow* wxGetActiveWindow();
	40
c801d85f KB	41	//-----------------------------------------------------------------------------
	42	// classes
	43	//-----------------------------------------------------------------------------
	44
	45	class wxLayoutConstraints;
	46	class wxSizer;
ac57418f	47	class wxDC;
fd0eed64 RR	48	class wxClientData;
fd0eed64 RR	49	class wxVoidClientData;
c801d85f	50	class wxWindow;
06cfab17	51	#if wxUSE_WX_RESOURCES
ac57418f RR	52	class wxResourceTable;
	53	class wxItemResource;
	54	#endif
06cfab17	55	#if wxUSE_DRAG_AND_DROP
ac57418f RR	56	class wxDropTarget;
ac57418f RR	57	#endif
b1170810	58	class wxToolTip;
c801d85f	59
6ca41e57	60	//-----------------------------------------------------------------------------
fd0eed64	61	// callback definition for inserting a window (internal)
6ca41e57 RR	62	//-----------------------------------------------------------------------------
	63
	64	typedef void (wxInsertChildFunction)( wxWindow, wxWindow* );
	65
c801d85f KB	66	//-----------------------------------------------------------------------------
	67	// global data
	68	//-----------------------------------------------------------------------------
	69
	70	extern const char *wxPanelNameStr;
	71	extern const wxSize wxDefaultSize;
	72	extern const wxPoint wxDefaultPosition;
	73
fd0eed64 RR	74	//-----------------------------------------------------------------------------
	75	// wxClientData
	76	//-----------------------------------------------------------------------------
	77
	78	class wxClientData
	79	{
	80	public:
36b3b54a RR	81	wxClientData() { }
36b3b54a RR	82	virtual ~wxClientData() { }
fd0eed64 RR	83	};
fd0eed64 RR	84
fd0eed64 RR	85	//-----------------------------------------------------------------------------
	86	// wxStringClientData
	87	//-----------------------------------------------------------------------------
	88
	89	class wxStringClientData: public wxClientData
	90	{
	91	public:
	92	wxStringClientData() { }
	93	wxStringClientData( wxString &data ) { m_data = data; }
	94	void SetData( wxString &data ) { m_data = data; }
	95	wxString GetData() const { return m_data; }
8bbe427f	96
fd0eed64 RR	97	private:
	98	wxString m_data;
	99	};
	100
b292e2f5 RR	101	//-----------------------------------------------------------------------------
	102	// (debug)
	103	//-----------------------------------------------------------------------------
	104
	105	#ifdef __WXDEBUG__
	106
	107	void debug_focus_in( GtkWidget* widget, const char* name, const char* window );
	108
	109	#endif
	110
c801d85f KB	111	//-----------------------------------------------------------------------------
	112	// wxWindow
	113	//-----------------------------------------------------------------------------
	114
	115	class wxWindow: public wxEvtHandler
	116	{
a60c99e6	117	DECLARE_DYNAMIC_CLASS(wxWindow)
8bbe427f	118
aed8df38 VZ	119	public:
aed8df38 VZ	120	wxWindow();
6ca41e57	121	wxWindow(wxWindow *parent, wxWindowID id,
6de97a3b RR	122	const wxPoint& pos = wxDefaultPosition,
	123	const wxSize& size = wxDefaultSize,
	124	long style = 0,
6ca41e57	125	const wxString& name = wxPanelNameStr);
6de97a3b RR	126	bool Create(wxWindow *parent, wxWindowID id,
	127	const wxPoint& pos = wxDefaultPosition,
	128	const wxSize& size = wxDefaultSize,
	129	long style = 0,
	130	const wxString& name = wxPanelNameStr);
aed8df38	131	virtual ~wxWindow();
cd0183ca	132
f5abe911	133	#if wxUSE_WX_RESOURCES
8bbe427f	134	virtual bool LoadFromResource( wxWindow *parent, const wxString& resourceName,
bcf1fa6b	135	const wxResourceTable table = (const wxResourceTable ) NULL);
fd71308f	136	virtual wxControl CreateItem(const wxItemResource childResource, const wxItemResource* parentResource,
bcf1fa6b	137	const wxResourceTable table = (const wxResourceTable ) NULL);
f5abe911	138	#endif
cd0183ca	139
aed8df38 VZ	140	bool Close( bool force = FALSE );
	141	virtual bool Destroy();
	142	virtual bool DestroyChildren();
	143
	144	virtual void PrepareDC( wxDC &dc );
	145
	146	virtual void SetSize( int x, int y, int width, int height,
	147	int sizeFlags = wxSIZE_AUTO );
	148	virtual void SetSize( int width, int height );
ff8bfdbb	149
aed8df38	150	virtual void Move( int x, int y );
ff8bfdbb	151
aed8df38	152	virtual void GetSize( int width, int height ) const;
4f22cf8d	153	wxSize GetSize() const { int w, h; GetSize(& w, & h); return wxSize(w, h); }
ff8bfdbb	154
aed8df38	155	virtual void SetClientSize( int const width, int const height );
ff8bfdbb	156
aed8df38	157	virtual void GetClientSize( int width, int height ) const;
4f22cf8d	158	wxSize GetClientSize() const { int w, h; GetClientSize(& w, & h); return wxSize(w, h); }
ff8bfdbb	159
aed8df38	160	virtual void GetPosition( int x, int y ) const;
4f22cf8d	161	wxPoint GetPosition() const { int w, h; GetPosition(& w, & h); return wxPoint(w, h); }
ff8bfdbb	162
4f22cf8d RR	163	wxRect GetRect() const
4f22cf8d RR	164	{ int x, y, w, h; GetPosition(& x, & y); GetSize(& w, & h); return wxRect(x, y, w, h); }
ff8bfdbb	165
aed8df38	166	virtual void Centre( int direction = wxHORIZONTAL );
cd0183ca	167	inline void Center(int direction = wxHORIZONTAL) { Centre(direction); }
aed8df38	168	virtual void Fit();
2f2aa628 RR	169
2f2aa628 RR	170	virtual void SetSizeHints( int minW, int minH, int maxW = -1, int maxH = -1, int incW = -1, int incH = -1 );
aed8df38	171
36b3b54a RR	172	/* Dialog units translations. Implemented in wincmn.cpp. */
	173	wxPoint ConvertPixelsToDialog( const wxPoint& pt );
	174	wxPoint ConvertDialogToPixels( const wxPoint& pt );
	175	inline wxSize ConvertPixelsToDialog( const wxSize& sz )
	176	{ wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }
	177	inline wxSize ConvertDialogToPixels( const wxSize& sz )
	178	{ wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }
fd71308f	179
aed8df38	180	void OnSize( wxSizeEvent &event );
aed8df38 VZ	181
	182	virtual bool Show( bool show );
	183	virtual void Enable( bool enable );
	184	virtual void MakeModal( bool modal );
903f689b	185	virtual bool IsEnabled() const { return m_isEnabled; }
fd0eed64	186	inline bool Enabled() const { return IsEnabled(); }
aed8df38 VZ	187	virtual bool OnClose();
aed8df38 VZ	188
b292e2f5 RR	189	virtual void SetFocus();
b292e2f5 RR	190	static wxWindow *FindFocus();
ff8bfdbb	191
aed8df38	192	virtual void AddChild( wxWindow *child );
8bbe427f VZ	193	wxList& GetChildren() { return m_children; }
8bbe427f VZ	194
aed8df38 VZ	195	virtual void RemoveChild( wxWindow *child );
	196	void SetReturnCode( int retCode );
	197	int GetReturnCode();
cd0183ca	198	wxWindow *GetParent() const
c33c4050	199	{ return m_parent; }
fd0eed64	200	wxWindow *GetGrandParent() const
c33c4050	201	{ return (m_parent ? m_parent->m_parent : (wxWindow*)NULL); }
36b3b54a RR	202	void SetParent( wxWindow *parent )
36b3b54a RR	203	{ m_parent = parent; }
463c1fa1	204	virtual wxWindow ReParent( wxWindow newParent );
aed8df38	205
8bbe427f	206	wxEvtHandler *GetEventHandler() const;
86b29a61 RR	207	void SetEventHandler( wxEvtHandler *handler );
	208	void PushEventHandler( wxEvtHandler *handler );
	209	wxEvtHandler *PopEventHandler( bool deleteHandler = FALSE );
aed8df38	210
6de97a3b	211	virtual void SetValidator( const wxValidator &validator );
b1170810	212	virtual wxValidator *GetValidator();
aed8df38	213
fd0eed64 RR	214	virtual void SetClientObject( wxClientData *data );
fd0eed64 RR	215	virtual wxClientData *GetClientObject();
8bbe427f	216
fd0eed64 RR	217	virtual void SetClientData( void *data );
fd0eed64 RR	218	virtual void *GetClientData();
8bbe427f	219
bcf1fa6b RR	220	virtual void SetAcceleratorTable( const wxAcceleratorTable& accel );
bcf1fa6b RR	221	virtual wxAcceleratorTable *GetAcceleratorTable() { return &m_acceleratorTable; }
8bbe427f	222
aed8df38 VZ	223	bool IsBeingDeleted();
	224
	225	void SetId( wxWindowID id );
8bbe427f	226	wxWindowID GetId() const;
aed8df38 VZ	227
aed8df38 VZ	228	void SetCursor( const wxCursor &cursor );
ff8bfdbb	229
4f22cf8d	230	void WarpPointer(int x, int y);
ff8bfdbb VZ	231
	232	#if wxUSE_TOOLTIPS
	233	void SetToolTip( const wxString &tip );
b1170810	234	virtual void SetToolTip( wxToolTip *tip );
ff8bfdbb VZ	235	wxToolTip* GetToolTip() const { return m_toolTip; }
ff8bfdbb VZ	236	#endif // wxUSE_TOOLTIPS
b1170810	237
c67daf87	238	virtual void Refresh( bool eraseBackground = TRUE, const wxRect rect = (const wxRect ) NULL );
aed8df38	239	virtual void Clear();
8bbe427f	240
8429bec1	241	virtual wxRegion GetUpdateRegion() const;
301cd871 RR	242	virtual bool IsExposed( int x, int y ) const;
	243	virtual bool IsExposed( int x, int y, int w, int h ) const;
	244	virtual bool IsExposed( const wxPoint& pt ) const;
	245	virtual bool IsExposed( const wxRect& rect ) const;
aed8df38 VZ	246
	247	virtual wxColour GetBackgroundColour() const;
	248	virtual void SetBackgroundColour( const wxColour &colour );
6de97a3b RR	249	virtual wxColour GetForegroundColour() const;
6de97a3b RR	250	virtual void SetForegroundColour( const wxColour &colour );
cd0183ca	251
fd0eed64 RR	252	virtual int GetCharHeight() const;
fd0eed64 RR	253	virtual int GetCharWidth() const;
c33c4050	254	virtual void GetTextExtent( const wxString& string, int x, int y,
c67daf87 UR	255	int descent = (int ) NULL,
	256	int externalLeading = (int ) NULL,
	257	const wxFont theFont = (const wxFont ) NULL, bool use16 = FALSE) const;
aed8df38	258
aed8df38	259	virtual void SetFont( const wxFont &font );
4f22cf8d	260	virtual wxFont& GetFont() { return m_font; }
8bbe427f	261
fd0eed64	262	// For backward compatibility
aed8df38 VZ	263	inline virtual void SetButtonFont(const wxFont& font) { SetFont(font); }
aed8df38 VZ	264	inline virtual void SetLabelFont(const wxFont& font) { SetFont(font); }
4f22cf8d RR	265	inline virtual wxFont& GetLabelFont() { return GetFont(); };
4f22cf8d RR	266	inline virtual wxFont& GetButtonFont() { return GetFont(); };
8bbe427f	267
aed8df38 VZ	268	virtual void SetWindowStyleFlag( long flag );
aed8df38 VZ	269	virtual long GetWindowStyleFlag() const;
8bbe427f	270
aed8df38 VZ	271	virtual void CaptureMouse();
aed8df38 VZ	272	virtual void ReleaseMouse();
8bbe427f	273
aed8df38 VZ	274	virtual void SetTitle( const wxString &title );
	275	virtual wxString GetTitle() const;
	276	virtual void SetName( const wxString &name );
	277	virtual wxString GetName() const;
	278	virtual wxString GetLabel() const;
c801d85f	279
aed8df38	280	void OnSysColourChanged( wxSysColourChangedEvent &WXUNUSED(event) ) {};
b666df2c	281	void OnKeyDown( wxKeyEvent &event );
aed8df38 VZ	282
aed8df38 VZ	283	virtual bool IsShown() const;
e149aaeb	284
fd0eed64 RR	285	virtual void Raise();
fd0eed64 RR	286	virtual void Lower();
e149aaeb	287
aed8df38 VZ	288	virtual bool IsRetained();
	289	virtual wxWindow *FindWindow( long id );
	290	virtual wxWindow *FindWindow( const wxString& name );
8bbe427f	291
aed8df38 VZ	292	void AllowDoubleClick( bool WXUNUSED(allow) ) {};
aed8df38 VZ	293	void SetDoubleClick( bool WXUNUSED(allow) ) {};
8bbe427f	294
aed8df38 VZ	295	virtual void ClientToScreen( int x, int y );
	296	virtual void ScreenToClient( int x, int y );
	297
	298	virtual bool Validate();
	299	virtual bool TransferDataToWindow();
	300	virtual bool TransferDataFromWindow();
	301	void OnInitDialog( wxInitDialogEvent &event );
	302	virtual void InitDialog();
cd0183ca	303
30dea054	304	virtual bool PopupMenu( wxMenu *menu, int x, int y );
aed8df38	305
06cfab17	306	#if wxUSE_DRAG_AND_DROP
aed8df38 VZ	307	virtual void SetDropTarget( wxDropTarget *dropTarget );
aed8df38 VZ	308	virtual wxDropTarget *GetDropTarget() const;
ac57418f	309	#endif
cd0183ca	310
aed8df38 VZ	311	virtual void SetScrollbar( int orient, int pos, int thumbVisible,
	312	int range, bool refresh = TRUE );
	313	virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE );
	314	virtual int GetScrollPos( int orient ) const;
	315	virtual int GetScrollThumb( int orient ) const;
	316	virtual int GetScrollRange( int orient ) const;
c67daf87	317	virtual void ScrollWindow( int dx, int dy, const wxRect* rect = (wxRect *) NULL );
aed8df38	318
aed8df38	319	virtual bool AcceptsFocus() const;
8bbe427f	320
aed8df38 VZ	321	void UpdateWindowUI();
aed8df38 VZ	322
a60c99e6	323	// implementation
8bbe427f	324
301cd871 RR	325	virtual wxPoint GetClientAreaOrigin() const;
	326	virtual void AdjustForParentClientOrigin( int& x, int& y, int sizeFlags );
	327
	328	bool HasVMT();
	329
	330	virtual void OnInternalIdle();
ff8bfdbb	331
301cd871	332	/* used by all classes in the widget creation process */
ff8bfdbb	333
9390a202 RR	334	void PreCreation( wxWindow *parent, wxWindowID id, const wxPoint &pos,
	335	const wxSize &size, long style, const wxString &name );
	336	void PostCreation();
ff8bfdbb	337
301cd871 RR	338	/* the methods below are required because many native widgets
301cd871 RR	339	are composed of several subwidgets and setting a style for
ff8bfdbb	340	the widget means setting it for all subwidgets as well.
301cd871 RR	341	also, it is nor clear, which native widget is the top
	342	widget where (most of) the input goes. even tooltips have
	343	to be applied to all subwidgets. */
ff8bfdbb	344
9390a202 RR	345	virtual GtkWidget* GetConnectWidget();
	346	virtual bool IsOwnGtkWindow( GdkWindow *window );
	347	void ConnectWidget( GtkWidget *widget );
8bbe427f	348
9390a202 RR	349	GtkStyle *GetWidgetStyle();
	350	void SetWidgetStyle();
	351	virtual void ApplyWidgetStyle();
ff8bfdbb VZ	352
ff8bfdbb VZ	353	#if wxUSE_TOOLTIPS
301cd871	354	virtual void ApplyToolTip( GtkTooltips tips, const char tip );
ff8bfdbb	355	#endif // wxUSE_TOOLTIPS
301cd871 RR	356
301cd871 RR	357	/* private member variables */
aed8df38	358
bcf1fa6b RR	359	wxWindow *m_parent;
	360	wxList m_children;
	361	int m_x,m_y;
	362	int m_width,m_height;
	363	int m_minWidth,m_minHeight;
	364	int m_maxWidth,m_maxHeight;
	365	int m_retCode;
	366	wxEvtHandler *m_eventHandler;
	367	wxValidator *m_windowValidator;
06cfab17	368	#if wxUSE_DRAG_AND_DROP
fd0eed64	369	wxDropTarget *m_dropTarget;
ac57418f	370	#endif
bcf1fa6b RR	371	wxWindowID m_windowId;
	372	wxCursor *m_cursor;
	373	wxFont m_font;
	374	wxColour m_backgroundColour;
1ecc4d80	375	wxColour m_foregroundColour;
bcf1fa6b RR	376	wxRegion m_updateRegion;
	377	long m_windowStyle;
	378	bool m_isShown;
	379	bool m_isEnabled;
	380	wxString m_windowName;
	381	wxAcceleratorTable m_acceleratorTable;
f5e27805 RR	382	wxClientData *m_clientObject;
f5e27805 RR	383	void *m_clientData;
ff8bfdbb VZ	384
ff8bfdbb VZ	385	#if wxUSE_TOOLTIPS
b1170810	386	wxToolTip *m_toolTip;
ff8bfdbb	387	#endif // wxUSE_TOOLTIPS
bcf1fa6b RR	388
	389	GtkWidget *m_widget;
	390	GtkWidget *m_wxwindow;
	391	GtkAdjustment m_hAdjust,m_vAdjust;
	392	float m_oldHorizontalPos;
	393	float m_oldVerticalPos;
	394	bool m_needParent;
	395	bool m_hasScrolling;
cb43b372	396	bool m_isScrolling;
bcf1fa6b RR	397	bool m_hasVMT;
	398	bool m_sizeSet;
	399	bool m_resizing;
32e9da8b	400	GdkGC *m_scrollGC;
a81258be	401	GtkStyle *m_widgetStyle;
1ecc4d80	402	bool m_isStaticBox;
b292e2f5	403	bool m_acceptsFocus;
8bbe427f	404
6ca41e57	405	wxInsertChildFunction m_insertCallback;
bcf1fa6b RR	406
	407	public:
	408
	409	wxLayoutConstraints *m_constraints;
	410	wxList *m_constraintsInvolvedIn;
	411	wxSizer *m_windowSizer;
	412	wxWindow *m_sizerParent;
	413	bool m_autoLayout;
aed8df38 VZ	414
	415	wxLayoutConstraints *GetConstraints() const;
	416	void SetConstraints( wxLayoutConstraints *constraints );
	417	void SetAutoLayout( bool autoLayout );
	418	bool GetAutoLayout() const;
	419	bool Layout();
	420	void SetSizer( wxSizer *sizer );
	421	wxSizer *GetSizer() const;
	422	void SetSizerParent( wxWindow *win );
	423	wxWindow *GetSizerParent() const;
	424	void UnsetConstraints(wxLayoutConstraints *c);
	425	inline wxList *GetConstraintsInvolvedIn() const ;
	426	void AddConstraintReference(wxWindow *otherWin);
	427	void RemoveConstraintReference(wxWindow *otherWin);
	428	void DeleteRelatedConstraints();
	429	virtual void ResetConstraints();
	430	virtual void SetConstraintSizes(bool recurse = TRUE);
	431	virtual bool LayoutPhase1(int *noChanges);
	432	virtual bool LayoutPhase2(int *noChanges);
	433	virtual bool DoPhase(int);
	434	virtual void TransformSizerToActual(int x, int y) const ;
	435	virtual void SizerSetSize(int x, int y, int w, int h);
	436	virtual void SizerMove(int x, int y);
	437	virtual void SetSizeConstraint(int x, int y, int w, int h);
	438	virtual void MoveConstraint(int x, int y);
	439	virtual void GetSizeConstraint(int w, int h) const ;
	440	virtual void GetClientSizeConstraint(int w, int h) const ;
	441	virtual void GetPositionConstraint(int x, int y) const ;
	442
68dda785	443	private:
c801d85f KB	444	DECLARE_EVENT_TABLE()
	445	};
	446
	447	#endif // __GTKWINDOWH__