4b7f216556
2. reorganized wxImageList a bit, created a new wxInvertMask() function 3. an incredibly ugly fix (?) for "unsatisfied constraints" warnings 4. added wxIcon and wxBitmap ctors from XPM 5. XPM handler now creates bitmaps with mask 6. added wxPrinterDC::BitBlt() and DrawBitmap(), cleared the horrible mess in the wxDC methods with the same names git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@5571 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
885 lines
31 KiB
C++
885 lines
31 KiB
C++
///////////////////////////////////////////////////////////////////////////////
|
|
// Name: window.h
|
|
// Purpose: wxWindowBase class - the interface of wxWindow
|
|
// 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_
|
|
|
|
#ifdef __GNUG__
|
|
#pragma interface "windowbase.h"
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// 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/utils.h"
|
|
|
|
#include "wx/validate.h" // for wxDefaultValidator (always include it)
|
|
|
|
#if wxUSE_ACCEL
|
|
#include "wx/accel.h"
|
|
#endif // wxUSE_ACCEL
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// forward declarations
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class WXDLLEXPORT wxCaret;
|
|
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 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 wxValidator& validator = wxDefaultValidator,
|
|
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)
|
|
virtual void SetLabel(const wxString& label) { SetTitle(label); }
|
|
virtual 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; }
|
|
// get the id of the control following the one with the given
|
|
// (autogenerated) id
|
|
static int NextControlId(int id) { return id - 1; }
|
|
// get the id of the control preceding the one with the given
|
|
// (autogenerated) id
|
|
static int PrevControlId(int id) { return id + 1; }
|
|
|
|
// 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);
|
|
}
|
|
|
|
// get the size best suited for the window (in fact, minimal
|
|
// acceptable size using which it will still look "nice")
|
|
wxSize GetBestSize() const { return DoGetBestSize(); }
|
|
void GetBestSize(int *w, int *h) const
|
|
{
|
|
wxSize s = DoGetBestSize();
|
|
if ( w )
|
|
*w = s.x;
|
|
if ( h )
|
|
*h = s.y;
|
|
}
|
|
|
|
// centre with respect to the the parent window
|
|
void Centre( int direction = wxBOTH );
|
|
void Center( int direction = wxBOTH ) { Centre(direction); }
|
|
void CentreOnParent( int dir = wxBOTH ) { Centre(dir | wxCENTER_FRAME); }
|
|
void CenterOnParent( int dir = wxBOTH ) { Centre(dir | wxCENTER_FRAME); }
|
|
|
|
// 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 );
|
|
|
|
int GetMinWidth() const { return m_minWidth; }
|
|
int GetMinHeight() const { return m_minHeight; }
|
|
int GetMaxWidth() const { return m_maxWidth; }
|
|
int GetMaxHeight() const { return m_maxHeight; }
|
|
|
|
// 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?
|
|
virtual bool IsTopLevel() const;
|
|
|
|
// 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
|
|
// --------------------------
|
|
|
|
#if wxUSE_VALIDATORS
|
|
// 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; }
|
|
#endif // wxUSE_VALIDATORS
|
|
|
|
// 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 - but not both of them
|
|
void SetClientObject( wxClientData *data ) { DoSetClientObject(data); }
|
|
wxClientData *GetClientObject() const { return DoGetClientObject(); }
|
|
|
|
void SetClientData( void *data ) { DoSetClientData(data); }
|
|
void *GetClientData() const { return DoGetClientData(); }
|
|
|
|
// 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();
|
|
|
|
#if wxUSE_ACCEL
|
|
// accelerators
|
|
// ------------
|
|
virtual void SetAcceleratorTable( const wxAcceleratorTable& accel )
|
|
{ m_acceleratorTable = accel; }
|
|
wxAcceleratorTable *GetAcceleratorTable()
|
|
{ return &m_acceleratorTable; }
|
|
#endif // wxUSE_ACCEL
|
|
|
|
// 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 & WXUNUSED(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; }
|
|
|
|
#if wxUSE_CARET
|
|
// associate a caret with the window
|
|
void SetCaret(wxCaret *caret);
|
|
// get the current caret (may be NULL)
|
|
wxCaret *GetCaret() const { return m_caret; }
|
|
#endif // wxUSE_CARET
|
|
|
|
// 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)
|
|
void ClientToScreen( int *x, int *y ) const
|
|
{ DoClientToScreen(x, y); }
|
|
void ScreenToClient( int *x, int *y ) const
|
|
{ DoScreenToClient(x, y); }
|
|
wxPoint ClientToScreen(const wxPoint& pt) const
|
|
{
|
|
int x = pt.x, y = pt.y;
|
|
DoClientToScreen(&x, &y);
|
|
|
|
return wxPoint(x, y);
|
|
}
|
|
|
|
wxPoint ScreenToClient(const wxPoint& pt) const
|
|
{
|
|
int x = pt.x, y = pt.y;
|
|
DoScreenToClient(&x, &y);
|
|
|
|
return wxPoint(x, y);
|
|
}
|
|
|
|
// misc
|
|
// ----
|
|
|
|
void UpdateWindowUI();
|
|
|
|
bool PopupMenu( wxMenu *menu, const wxPoint& pos )
|
|
{ return DoPopupMenu(menu, pos.x, pos.y); }
|
|
bool PopupMenu( wxMenu *menu, int x, int y )
|
|
{ return DoPopupMenu(menu, x, y); }
|
|
|
|
// 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 phase);
|
|
|
|
// these methods are virtual but normally won't be overridden
|
|
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; }
|
|
#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 );
|
|
|
|
// get the haqndle of the window for the underlying window system: this
|
|
// is only used for wxWin itself or for user code which wants to call
|
|
// platform-specific APIs
|
|
virtual WXWidget GetHandle() const = 0;
|
|
|
|
protected:
|
|
// the window id - a number which uniquely identifies a window among
|
|
// its siblings unless it is -1
|
|
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;
|
|
|
|
#if wxUSE_VALIDATORS
|
|
// associated validator or NULL if none
|
|
wxValidator *m_windowValidator;
|
|
#endif // wxUSE_VALIDATORS
|
|
|
|
#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;
|
|
|
|
#if wxUSE_CARET
|
|
wxCaret *m_caret;
|
|
#endif // wxUSE_CARET
|
|
|
|
// the region which should be repainted in response to paint event
|
|
wxRegion m_updateRegion;
|
|
|
|
#if wxUSE_ACCEL
|
|
// the accelerator table for the window which translates key strokes into
|
|
// command events
|
|
wxAcceleratorTable m_acceleratorTable;
|
|
#endif // wxUSE_ACCEL
|
|
|
|
// 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 - only one type of data can be used with the given window
|
|
// (i.e. you cannot set the void data and then associate the window with
|
|
// wxClientData or vice versa)
|
|
union
|
|
{
|
|
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; }
|
|
|
|
// sets the size to be size but take width and/or height from
|
|
// DoGetBestSize() if width/height of size is -1
|
|
//
|
|
// NB: when calling this function from the ctor, the DoGetBestSize() of
|
|
// the class with the same name as the ctor, not the real (most
|
|
// derived) one - but this is what we usually want
|
|
void SetSizeOrDefault(const wxSize& size = wxDefaultSize)
|
|
{
|
|
if ( size.x == -1 || size.y == -1 )
|
|
{
|
|
wxSize sizeDef = GetBestSize();
|
|
SetSize( size.x == -1 ? sizeDef.x : size.x,
|
|
size.y == -1 ? sizeDef.y : size.y);
|
|
}
|
|
else
|
|
{
|
|
SetSize(size);
|
|
}
|
|
}
|
|
|
|
// 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.
|
|
|
|
// coordinates translation
|
|
virtual void DoClientToScreen( int *x, int *y ) const = 0;
|
|
virtual void DoScreenToClient( int *x, int *y ) const = 0;
|
|
|
|
// 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;
|
|
|
|
// get the size which best suits the window: for a control, it would be
|
|
// the minimal size which doesn't truncate the control, for a panel - the
|
|
// same size as it would have after a call to Fit()
|
|
virtual wxSize DoGetBestSize() const;
|
|
|
|
// 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;
|
|
|
|
// move the window to the specified location and resize it: this is called
|
|
// from both DoSetSize() and DoSetClientSize() and would usually just
|
|
// reposition this window except for composite controls which will want to
|
|
// arrange themselves inside the given rectangle
|
|
virtual void DoMoveWindow(int x, int y, int width, int height) = 0;
|
|
|
|
#if wxUSE_TOOLTIPS
|
|
virtual void DoSetToolTip( wxToolTip *tip );
|
|
#endif // wxUSE_TOOLTIPS
|
|
|
|
virtual bool DoPopupMenu( wxMenu *menu, int x, int y ) = 0;
|
|
|
|
// client data accessors
|
|
virtual void DoSetClientObject( wxClientData *data );
|
|
virtual wxClientData *DoGetClientObject() const;
|
|
|
|
virtual void DoSetClientData( void *data );
|
|
virtual void *DoGetClientData() const;
|
|
|
|
// what kind of data do we have?
|
|
enum wxClientDataType
|
|
{
|
|
ClientData_None, // we don't know yet because we don't have it at all
|
|
ClientData_Object, // our client data is typed and we own it
|
|
ClientData_Void // client data is untyped and we don't own it
|
|
} m_clientDataType;
|
|
|
|
private:
|
|
// contains the last id generated by NewControlId
|
|
static int ms_lastControlId;
|
|
|
|
DECLARE_NO_COPY_CLASS(wxWindowBase);
|
|
DECLARE_EVENT_TABLE()
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// now include the declaration of wxWindow class
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#if defined(__WXMSW__)
|
|
#include "wx/msw/window.h"
|
|
#elif defined(__WXMOTIF__)
|
|
#include "wx/motif/window.h"
|
|
#elif defined(__WXGTK__)
|
|
#include "wx/gtk/window.h"
|
|
#elif defined(__WXQT__)
|
|
#include "wx/qt/window.h"
|
|
#elif defined(__WXMAC__)
|
|
#include "wx/mac/window.h"
|
|
#elif defined(__WXPM__)
|
|
#include "wx/os2/window.h"
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// inline functions which couldn't be declared in the class body because of
|
|
// forward dependencies
|
|
// ----------------------------------------------------------------------------
|
|
|
|
inline wxWindow *wxWindowBase::GetGrandParent() const
|
|
{
|
|
return m_parent ? m_parent->GetParent() : (wxWindow *)NULL;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// global function
|
|
// ----------------------------------------------------------------------------
|
|
|
|
WXDLLEXPORT extern wxWindow* wxGetActiveWindow();
|
|
|
|
// deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
|
|
inline WXDLLEXPORT int NewControlId() { return wxWindowBase::NewControlId(); }
|
|
|
|
#endif
|
|
// _WX_WINDOW_H_BASE_
|