X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/debe6624c1e9d4bf3243381153d1e173c849bcd8..14619f10b0bdb630206607abd0ce0319d45e095a:/include/wx/tbarbase.h diff --git a/include/wx/tbarbase.h b/include/wx/tbarbase.h index b410ac6a82..709b7c53ea 100644 --- a/include/wx/tbarbase.h +++ b/include/wx/tbarbase.h @@ -1,240 +1,716 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: tbarbase.h +// Name: wx/tbarbase.h // Purpose: Base class for toolbar classes // Author: Julian Smart // Modified by: // Created: 01/02/97 // RCS-ID: $Id$ -// Copyright: (c) Julian Smart and Markus Holzem -// Licence: wxWindows licence +// Copyright: (c) Julian Smart +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifndef __TBARBASEH__ -#define __TBARBASEH__ +#ifndef _WX_TBARBASE_H_ +#define _WX_TBARBASE_H_ -#ifdef __GNUG__ -#pragma interface "tbarbase.h" -#endif +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- #include "wx/defs.h" -#if USE_TOOLBAR +#if wxUSE_TOOLBAR #include "wx/bitmap.h" #include "wx/list.h" #include "wx/control.h" -WXDLLEXPORT_DATA(extern const char*) wxToolBarNameStr; -WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize; -WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition; +class WXDLLIMPEXP_FWD_CORE wxToolBarBase; +class WXDLLIMPEXP_FWD_CORE wxToolBarToolBase; +class WXDLLIMPEXP_FWD_CORE wxImage; -#define wxTOOL_STYLE_BUTTON 1 -#define wxTOOL_STYLE_SEPARATOR 2 +// ---------------------------------------------------------------------------- +// constants +// ---------------------------------------------------------------------------- -class WXDLLEXPORT wxToolBarTool: public wxObject -{ - DECLARE_DYNAMIC_CLASS(wxToolBarTool) - public: - wxToolBarTool(int theIndex = 0, const wxBitmap& bitmap1 = wxNullBitmap, const wxBitmap& bitmap2 = wxNullBitmap, - bool toggle = FALSE, long xPos = -1, long yPos = -1, - const wxString& shortHelpString = "", const wxString& longHelpString = ""); - ~wxToolBarTool (); - inline void SetSize( long w, long h ) { m_width = w; m_height = h; } - inline long GetWidth () const { return m_width; } - inline long GetHeight () const { return m_height; } +extern WXDLLIMPEXP_DATA_CORE(const char) wxToolBarNameStr[]; +extern WXDLLIMPEXP_DATA_CORE(const wxSize) wxDefaultSize; +extern WXDLLIMPEXP_DATA_CORE(const wxPoint) wxDefaultPosition; -public: - int m_toolStyle; - wxObject * m_clientData; - int m_index; - long m_x; - long m_y; - long m_width; - long m_height; - bool m_toggleState; - bool m_isToggle; - bool m_deleteSecondBitmap; - bool m_enabled; - wxBitmap m_bitmap1; - wxBitmap m_bitmap2; - bool m_isMenuCommand; - wxString m_shortHelpString; - wxString m_longHelpString; +enum wxToolBarToolStyle +{ + wxTOOL_STYLE_BUTTON = 1, + wxTOOL_STYLE_SEPARATOR = 2, + wxTOOL_STYLE_CONTROL }; -class WXDLLEXPORT wxToolBarBase : public wxControl +// ---------------------------------------------------------------------------- +// wxToolBarTool is a toolbar element. +// +// It has a unique id (except for the separators which always have id wxID_ANY), the +// style (telling whether it is a normal button, separator or a control), the +// state (toggled or not, enabled or not) and short and long help strings. The +// default implementations use the short help string for the tooltip text which +// is popped up when the mouse pointer enters the tool and the long help string +// for the applications status bar. +// ---------------------------------------------------------------------------- + +class WXDLLIMPEXP_CORE wxToolBarToolBase : public wxObject { - DECLARE_DYNAMIC_CLASS(wxToolBarBase) - public: - - wxToolBarBase(void); - ~wxToolBarBase(void); - - // Handle wxToolBar events - - // Only allow toggle if returns TRUE. Call when left button up. - virtual bool OnLeftClick(int toolIndex, bool toggleDown); - - // Call when right button down. - virtual void OnRightClick(int toolIndex, long x, long y); - - // Called when the mouse cursor enters a tool bitmap. - // Argument is -1 if mouse is exiting the toolbar. - virtual void OnMouseEnter(int toolIndex); - - // If pushedBitmap is NULL, a reversed version of bitmap is - // created and used as the pushed/toggled image. - // If toggle is TRUE, the button toggles between the two states. - virtual wxToolBarTool *AddTool(int toolIndex, const wxBitmap& bitmap, const wxBitmap& pushedBitmap = wxNullBitmap, - bool toggle = FALSE, long xPos = -1, long yPos = -1, wxObject *clientData = NULL, - const wxString& helpString1 = "", const wxString& helpString2 = ""); - virtual void AddSeparator(void); - virtual void ClearTools(void); - - virtual void EnableTool(int toolIndex, bool enable); - virtual void ToggleTool(int toolIndex, bool toggle); // toggle is TRUE if toggled on - virtual void SetToggle(int toolIndex, bool toggle); // Set this to be togglable (or not) - virtual wxObject *GetToolClientData(int index) const; - inline wxList& GetTools(void) const { return (wxList&) m_tools; } - - // After the toolbar has initialized, this is the size the tools take up -#if WXWXIN_COMPATIBILITY - inline void GetMaxSize ( long * width, long * height ) const - { wxSize maxSize(GetMaxSize()); *width = maxSize.x; *height = maxSize.y; } -#endif - virtual wxSize GetMaxSize ( void ) const; - - virtual bool GetToolState(int toolIndex) const; - virtual bool GetToolEnabled(int toolIndex) const; - virtual wxToolBarTool *FindToolForPosition(long x, long y) const; - - virtual void SetToolShortHelp(int toolIndex, const wxString& helpString); - virtual wxString GetToolShortHelp(int toolIndex) const; - virtual void SetToolLongHelp(int toolIndex, const wxString& helpString); - virtual wxString GetToolLongHelp(int toolIndex) const; - - virtual void SetMargins(int x, int y); - inline void SetMargins(const wxSize& size) { SetMargins(size.x, size.y); } - virtual void SetToolPacking(int packing); - virtual void SetToolSeparation(int separation); - - inline virtual wxSize GetToolMargins(void) { return wxSize(m_xMargin, m_yMargin); } - inline virtual int GetToolPacking(void) { return m_toolPacking; } - inline virtual int GetToolSeparation(void) { return m_toolSeparation; } - - virtual void SetDefaultSize(const wxSize& size) { m_defaultWidth = size.x; m_defaultHeight = size.y; }; - virtual wxSize GetDefaultSize(void) const { return wxSize(m_defaultWidth, m_defaultHeight); } - - // The button size (in some implementations) is bigger than the bitmap size: this returns - // the total button size. - virtual wxSize GetDefaultButtonSize(void) const { return wxSize(m_defaultWidth, m_defaultHeight); } ; - - // Compatibility -#if WXWIN_COMPATIBILITY - inline void SetDefaultSize(int w, int h) { SetDefaultSize(wxSize(w, h)); } - inline long GetDefaultWidth(void) const { return m_defaultWidth; } - inline long GetDefaultHeight(void) const { return m_defaultHeight; } - inline int GetDefaultButtonWidth(void) const { return GetDefaultButtonSize().x; }; - inline int GetDefaultButtonHeight(void) const { return GetDefaultButtonSize().y; }; +public: + // ctors & dtor + // ------------ + + // generic ctor for any kind of tool + wxToolBarToolBase(wxToolBarBase *tbar = NULL, + int toolid = wxID_SEPARATOR, + const wxString& label = wxEmptyString, + const wxBitmap& bmpNormal = wxNullBitmap, + const wxBitmap& bmpDisabled = wxNullBitmap, + wxItemKind kind = wxITEM_NORMAL, + wxObject *clientData = NULL, + const wxString& shortHelpString = wxEmptyString, + const wxString& longHelpString = wxEmptyString) + : m_label(label), + m_shortHelpString(shortHelpString), + m_longHelpString(longHelpString) + { + Init + ( + tbar, + toolid == wxID_SEPARATOR ? wxTOOL_STYLE_SEPARATOR + : wxTOOL_STYLE_BUTTON, + toolid == wxID_ANY ? wxWindow::NewControlId() + : toolid, + kind + ); + + m_clientData = clientData; + + m_bmpNormal = bmpNormal; + m_bmpDisabled = bmpDisabled; + } + + // ctor for controls only + wxToolBarToolBase(wxToolBarBase *tbar, + wxControl *control, + const wxString& label) + : m_label(label) + { + Init(tbar, wxTOOL_STYLE_CONTROL, control->GetId(), wxITEM_MAX); + + m_control = control; + } + + virtual ~wxToolBarToolBase(); + + // accessors + // --------- + + // general + int GetId() const { return m_id; } + + wxControl *GetControl() const + { + wxASSERT_MSG( IsControl(), wxT("this toolbar tool is not a control") ); + + return m_control; + } + + wxToolBarBase *GetToolBar() const { return m_tbar; } + + // style/kind + bool IsStretchable() const { return m_stretchable; } + bool IsButton() const { return m_toolStyle == wxTOOL_STYLE_BUTTON; } + bool IsControl() const { return m_toolStyle == wxTOOL_STYLE_CONTROL; } + bool IsSeparator() const { return m_toolStyle == wxTOOL_STYLE_SEPARATOR; } + bool IsStretchableSpace() const { return IsSeparator() && IsStretchable(); } + int GetStyle() const { return m_toolStyle; } + wxItemKind GetKind() const + { + wxASSERT_MSG( IsButton(), wxT("only makes sense for buttons") ); + + return m_kind; + } + + void MakeStretchable() + { + wxASSERT_MSG( IsSeparator(), "only separators can be stretchable" ); + + m_stretchable = true; + } + + // state + bool IsEnabled() const { return m_enabled; } + bool IsToggled() const { return m_toggled; } + bool CanBeToggled() const + { return m_kind == wxITEM_CHECK || m_kind == wxITEM_RADIO; } + + // attributes + const wxBitmap& GetNormalBitmap() const { return m_bmpNormal; } + const wxBitmap& GetDisabledBitmap() const { return m_bmpDisabled; } + + const wxBitmap& GetBitmap() const + { return IsEnabled() ? GetNormalBitmap() : GetDisabledBitmap(); } + + const wxString& GetLabel() const { return m_label; } + + const wxString& GetShortHelp() const { return m_shortHelpString; } + const wxString& GetLongHelp() const { return m_longHelpString; } + + wxObject *GetClientData() const + { + if ( m_toolStyle == wxTOOL_STYLE_CONTROL ) + { + return (wxObject*)m_control->GetClientData(); + } + else + { + return m_clientData; + } + } + + // modifiers: return true if the state really changed + virtual bool Enable(bool enable); + virtual bool Toggle(bool toggle); + virtual bool SetToggle(bool toggle); + virtual bool SetShortHelp(const wxString& help); + virtual bool SetLongHelp(const wxString& help); + + void Toggle() { Toggle(!IsToggled()); } + + virtual void SetNormalBitmap(const wxBitmap& bmp) { m_bmpNormal = bmp; } + virtual void SetDisabledBitmap(const wxBitmap& bmp) { m_bmpDisabled = bmp; } + + virtual void SetLabel(const wxString& label) { m_label = label; } + + void SetClientData(wxObject *clientData) + { + if ( m_toolStyle == wxTOOL_STYLE_CONTROL ) + { + m_control->SetClientData(clientData); + } + else + { + m_clientData = clientData; + } + } + + // add tool to/remove it from a toolbar + virtual void Detach() { m_tbar = NULL; } + virtual void Attach(wxToolBarBase *tbar) { m_tbar = tbar; } + +#if wxUSE_MENUS + // these methods are only for tools of wxITEM_DROPDOWN kind (but even such + // tools can have a NULL associated menu) + virtual void SetDropdownMenu(wxMenu *menu); + wxMenu *GetDropdownMenu() const { return m_dropdownMenu; } #endif - // Lay the tools out - virtual void Layout(void); - - // Add all the buttons: required for Win95. - // TODO: unify API so there's no ambiguity - virtual bool CreateTools(void) { return TRUE; } +protected: + // common part of all ctors + void Init(wxToolBarBase *tbar, + wxToolBarToolStyle style, + int toolid, + wxItemKind kind) + { + m_tbar = tbar; + m_toolStyle = style; + m_id = toolid; + m_kind = kind; + + m_clientData = NULL; + + m_stretchable = false; + m_toggled = false; + m_enabled = true; + +#if wxUSE_MENUS + m_dropdownMenu = NULL; +#endif - void Command(wxCommandEvent& event); + } - // SCROLLING: this has to be copied from wxScrolledWindow since wxToolBarBase - // inherits from wxControl. This could have been put into wxToolBarSimple, - // but we might want any derived toolbar class to be scrollable. + wxToolBarBase *m_tbar; // the toolbar to which we belong (may be NULL) - // Number of pixels per user unit (0 or -1 for no scrollbar) - // Length of virtual canvas in user units - virtual void SetScrollbars(int horizontal, int vertical, - int x_length, int y_length, - int x_pos = 0, int y_pos = 0); + // tool parameters + wxToolBarToolStyle m_toolStyle; + wxWindowIDRef m_id; // the tool id, wxID_SEPARATOR for separator + wxItemKind m_kind; // for normal buttons may be wxITEM_NORMAL/CHECK/RADIO - // Physically scroll the window - virtual void Scroll(int x_pos, int y_pos); - virtual void GetScrollPixelsPerUnit(int *x_unit, int *y_unit) const; - virtual void EnableScrolling(bool x_scrolling, bool y_scrolling); - virtual void AdjustScrollbars(void); + // as controls have their own client data, no need to waste memory + union + { + wxObject *m_clientData; + wxControl *m_control; + }; - // Prepare the DC by translating it according to the current scroll position - virtual void PrepareDC(wxDC& dc); + // true if this tool is stretchable: currently is only value for separators + bool m_stretchable; - int GetScrollPageSize(int orient) const ; - void SetScrollPageSize(int orient, int pageSize); + // tool state + bool m_toggled; + bool m_enabled; - // Get the view start - virtual void ViewStart(int *x, int *y) const; + // normal and disabled bitmaps for the tool, both can be invalid + wxBitmap m_bmpNormal; + wxBitmap m_bmpDisabled; - // Actual size in pixels when scrolling is taken into account - virtual void GetVirtualSize(int *x, int *y) const; + // the button label + wxString m_label; - // Do the toolbar button updates (check for EVT_UPDATE_UI handlers) - virtual void DoToolbarUpdates(void); + // short and long help strings + wxString m_shortHelpString; + wxString m_longHelpString; -/* - virtual void CalcScrolledPosition(int x, int y, int *xx, int *yy) const ; - virtual void CalcUnscrolledPosition(int x, int y, long *xx, long *yy) const ; -*/ +#if wxUSE_MENUS + wxMenu *m_dropdownMenu; +#endif - void OnScroll(wxScrollEvent& event); - void OnSize(wxSizeEvent& event); - void OnIdle(wxIdleEvent& event); + DECLARE_DYNAMIC_CLASS_NO_COPY(wxToolBarToolBase) +}; - // Required to force normal cursor-setting behaviour in Windows -#ifdef __WINDOWS__ - virtual void MSWOnMouseMove(int x, int y, const WXUINT flags); -#endif +// a list of toolbar tools +WX_DECLARE_EXPORTED_LIST(wxToolBarToolBase, wxToolBarToolsList); - protected: - wxList m_tools; - int m_tilingDirection; - int m_rowsOrColumns; - int m_currentRowsOrColumns; - long m_lastX, m_lastY; - long m_maxWidth, m_maxHeight; - int m_currentTool; // Tool where mouse currently is - int m_pressedTool; // Tool where mouse pressed - int m_xMargin; - int m_yMargin; - int m_toolPacking; - int m_toolSeparation; - long m_defaultWidth; - long m_defaultHeight; +// ---------------------------------------------------------------------------- +// the base class for all toolbars +// ---------------------------------------------------------------------------- +class WXDLLIMPEXP_CORE wxToolBarBase : public wxControl +{ public: - //////////////////////////////////////////////////////////////////////// - //// IMPLEMENTATION - - // Calculate scroll increment - virtual int CalcScrollInc(wxScrollEvent& event); - - //////////////////////////////////////////////////////////////////////// - //// PROTECTED DATA -protected: - int m_xScrollPixelsPerLine; - int m_yScrollPixelsPerLine; - bool m_xScrollingEnabled; - bool m_yScrollingEnabled; - int m_xScrollPosition; - int m_yScrollPosition; - bool m_calcScrolledOffset; // If TRUE, wxCanvasDC uses scrolled offsets - int m_xScrollLines; - int m_yScrollLines; - int m_xScrollLinesPerPage; - int m_yScrollLinesPerPage; + wxToolBarBase(); + virtual ~wxToolBarBase(); + + // toolbar construction + // -------------------- + + // the full AddTool() function + // + // If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap + // is created and used as the disabled image. + wxToolBarToolBase *AddTool(int toolid, + const wxString& label, + const wxBitmap& bitmap, + const wxBitmap& bmpDisabled, + wxItemKind kind = wxITEM_NORMAL, + const wxString& shortHelp = wxEmptyString, + const wxString& longHelp = wxEmptyString, + wxObject *data = NULL) + { + return DoAddTool(toolid, label, bitmap, bmpDisabled, kind, + shortHelp, longHelp, data); + } + + // the most common AddTool() version + wxToolBarToolBase *AddTool(int toolid, + const wxString& label, + const wxBitmap& bitmap, + const wxString& shortHelp = wxEmptyString, + wxItemKind kind = wxITEM_NORMAL) + { + return AddTool(toolid, label, bitmap, wxNullBitmap, kind, shortHelp); + } + + // add a check tool, i.e. a tool which can be toggled + wxToolBarToolBase *AddCheckTool(int toolid, + const wxString& label, + const wxBitmap& bitmap, + const wxBitmap& bmpDisabled = wxNullBitmap, + const wxString& shortHelp = wxEmptyString, + const wxString& longHelp = wxEmptyString, + wxObject *data = NULL) + { + return AddTool(toolid, label, bitmap, bmpDisabled, wxITEM_CHECK, + shortHelp, longHelp, data); + } + + // add a radio tool, i.e. a tool which can be toggled and releases any + // other toggled radio tools in the same group when it happens + wxToolBarToolBase *AddRadioTool(int toolid, + const wxString& label, + const wxBitmap& bitmap, + const wxBitmap& bmpDisabled = wxNullBitmap, + const wxString& shortHelp = wxEmptyString, + const wxString& longHelp = wxEmptyString, + wxObject *data = NULL) + { + return AddTool(toolid, label, bitmap, bmpDisabled, wxITEM_RADIO, + shortHelp, longHelp, data); + } + + + // insert the new tool at the given position, if pos == GetToolsCount(), it + // is equivalent to AddTool() + virtual wxToolBarToolBase *InsertTool + ( + size_t pos, + int toolid, + const wxString& label, + const wxBitmap& bitmap, + const wxBitmap& bmpDisabled = wxNullBitmap, + wxItemKind kind = wxITEM_NORMAL, + const wxString& shortHelp = wxEmptyString, + const wxString& longHelp = wxEmptyString, + wxObject *clientData = NULL + ); + + virtual wxToolBarToolBase *AddTool (wxToolBarToolBase *tool); + virtual wxToolBarToolBase *InsertTool (size_t pos, wxToolBarToolBase *tool); + + // add an arbitrary control to the toolbar (notice that the control will be + // deleted by the toolbar and that it will also adjust its position/size) + // + // the label is optional and, if specified, will be shown near the control + // NB: the control should have toolbar as its parent + virtual wxToolBarToolBase * + AddControl(wxControl *control, const wxString& label = wxEmptyString); + + virtual wxToolBarToolBase * + InsertControl(size_t pos, wxControl *control, + const wxString& label = wxEmptyString); + + // get the control with the given id or return NULL + virtual wxControl *FindControl( int toolid ); + + // add a separator to the toolbar + virtual wxToolBarToolBase *AddSeparator(); + virtual wxToolBarToolBase *InsertSeparator(size_t pos); + + // add a stretchable space to the toolbar: this is similar to a separator + // except that it's always blank and that all the extra space the toolbar + // has is [equally] distributed among the stretchable spaces in it + virtual wxToolBarToolBase *AddStretchableSpace(); + virtual wxToolBarToolBase *InsertStretchableSpace(size_t pos); + + // remove the tool from the toolbar: the caller is responsible for actually + // deleting the pointer + virtual wxToolBarToolBase *RemoveTool(int toolid); + + // delete tool either by index or by position + virtual bool DeleteToolByPos(size_t pos); + virtual bool DeleteTool(int toolid); + + // delete all tools + virtual void ClearTools(); + + // must be called after all buttons have been created to finish toolbar + // initialisation + // + // derived class versions should call the base one first, before doing + // platform-specific stuff + virtual bool Realize(); + + // tools state + // ----------- + + virtual void EnableTool(int toolid, bool enable); + virtual void ToggleTool(int toolid, bool toggle); + + // Set this to be togglable (or not) + virtual void SetToggle(int toolid, bool toggle); + + // set/get tools client data (not for controls) + virtual wxObject *GetToolClientData(int toolid) const; + virtual void SetToolClientData(int toolid, wxObject *clientData); + + // returns tool pos, or wxNOT_FOUND if tool isn't found + virtual int GetToolPos(int id) const; + + // return true if the tool is toggled + virtual bool GetToolState(int toolid) const; + + virtual bool GetToolEnabled(int toolid) const; + + virtual void SetToolShortHelp(int toolid, const wxString& helpString); + virtual wxString GetToolShortHelp(int toolid) const; + virtual void SetToolLongHelp(int toolid, const wxString& helpString); + virtual wxString GetToolLongHelp(int toolid) const; + + virtual void SetToolNormalBitmap(int WXUNUSED(id), + const wxBitmap& WXUNUSED(bitmap)) {} + virtual void SetToolDisabledBitmap(int WXUNUSED(id), + const wxBitmap& WXUNUSED(bitmap)) {} + + + // margins/packing/separation + // -------------------------- + + virtual void SetMargins(int x, int y); + void SetMargins(const wxSize& size) + { SetMargins((int) size.x, (int) size.y); } + virtual void SetToolPacking(int packing) + { m_toolPacking = packing; } + virtual void SetToolSeparation(int separation) + { m_toolSeparation = separation; } + + virtual wxSize GetToolMargins() const { return wxSize(m_xMargin, m_yMargin); } + virtual int GetToolPacking() const { return m_toolPacking; } + virtual int GetToolSeparation() const { return m_toolSeparation; } + + // toolbar geometry + // ---------------- + + // set the number of toolbar rows + virtual void SetRows(int nRows); + + // the toolbar can wrap - limit the number of columns or rows it may take + void SetMaxRowsCols(int rows, int cols) + { m_maxRows = rows; m_maxCols = cols; } + int GetMaxRows() const { return m_maxRows; } + int GetMaxCols() const { return m_maxCols; } + + // get/set the size of the bitmaps used by the toolbar: should be called + // before adding any tools to the toolbar + virtual void SetToolBitmapSize(const wxSize& size) + { m_defaultWidth = size.x; m_defaultHeight = size.y; } + virtual wxSize GetToolBitmapSize() const + { return wxSize(m_defaultWidth, m_defaultHeight); } + + // the button size in some implementations is bigger than the bitmap size: + // get the total button size (by default the same as bitmap size) + virtual wxSize GetToolSize() const + { return GetToolBitmapSize(); } + + // returns a (non separator) tool containing the point (x, y) or NULL if + // there is no tool at this point (coordinates are client) + virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, + wxCoord y) const = 0; + + // find the tool by id + wxToolBarToolBase *FindById(int toolid) const; + + // return true if this is a vertical toolbar, otherwise false + bool IsVertical() const; + + // these methods allow to access tools by their index in the toolbar + size_t GetToolsCount() const { return m_tools.GetCount(); } + const wxToolBarToolBase *GetToolByPos(int pos) const { return m_tools[pos]; } + +#if WXWIN_COMPATIBILITY_2_8 + // the old versions of the various methods kept for compatibility + // don't use in the new code! + // -------------------------------------------------------------- + wxDEPRECATED_INLINE( + wxToolBarToolBase *AddTool(int toolid, + const wxBitmap& bitmap, + const wxBitmap& bmpDisabled, + bool toggle = false, + wxObject *clientData = NULL, + const wxString& shortHelpString = wxEmptyString, + const wxString& longHelpString = wxEmptyString) + , + return AddTool(toolid, wxEmptyString, + bitmap, bmpDisabled, + toggle ? wxITEM_CHECK : wxITEM_NORMAL, + shortHelpString, longHelpString, clientData); + ) + wxDEPRECATED_INLINE( + wxToolBarToolBase *AddTool(int toolid, + const wxBitmap& bitmap, + const wxString& shortHelpString = wxEmptyString, + const wxString& longHelpString = wxEmptyString) + , + return AddTool(toolid, wxEmptyString, + bitmap, wxNullBitmap, wxITEM_NORMAL, + shortHelpString, longHelpString, NULL); + ) + wxDEPRECATED_INLINE( + wxToolBarToolBase *AddTool(int toolid, + const wxBitmap& bitmap, + const wxBitmap& bmpDisabled, + bool toggle, + wxCoord xPos, + wxCoord yPos = wxDefaultCoord, + wxObject *clientData = NULL, + const wxString& shortHelp = wxEmptyString, + const wxString& longHelp = wxEmptyString) + , + return DoAddTool(toolid, wxEmptyString, bitmap, bmpDisabled, + toggle ? wxITEM_CHECK : wxITEM_NORMAL, + shortHelp, longHelp, clientData, xPos, yPos); + ) + wxDEPRECATED_INLINE( + wxToolBarToolBase *InsertTool(size_t pos, + int toolid, + const wxBitmap& bitmap, + const wxBitmap& bmpDisabled = wxNullBitmap, + bool toggle = false, + wxObject *clientData = NULL, + const wxString& shortHelp = wxEmptyString, + const wxString& longHelp = wxEmptyString) + , + return InsertTool(pos, toolid, wxEmptyString, bitmap, bmpDisabled, + toggle ? wxITEM_CHECK : wxITEM_NORMAL, + shortHelp, longHelp, clientData); + ) +#endif // WXWIN_COMPATIBILITY_2_8 + + // event handlers + // -------------- + + // NB: these functions are deprecated, use EVT_TOOL_XXX() instead! + + // Only allow toggle if returns true. Call when left button up. + virtual bool OnLeftClick(int toolid, bool toggleDown); + + // Call when right button down. + virtual void OnRightClick(int toolid, long x, long y); + + // Called when the mouse cursor enters a tool bitmap. + // Argument is wxID_ANY if mouse is exiting the toolbar. + virtual void OnMouseEnter(int toolid); + + // more deprecated functions + // ------------------------- + + // use GetToolMargins() instead + wxSize GetMargins() const { return GetToolMargins(); } + + // Tool factories, + // helper functions to create toolbar tools + // ------------------------- + virtual wxToolBarToolBase *CreateTool(int toolid, + const wxString& label, + const wxBitmap& bmpNormal, + const wxBitmap& bmpDisabled = wxNullBitmap, + wxItemKind kind = wxITEM_NORMAL, + wxObject *clientData = NULL, + const wxString& shortHelp = wxEmptyString, + const wxString& longHelp = wxEmptyString) = 0; + + virtual wxToolBarToolBase *CreateTool(wxControl *control, + const wxString& label) = 0; + + // this one is not virtual but just a simple helper/wrapper around + // CreateTool() for separators + wxToolBarToolBase *CreateSeparator() + { + return CreateTool(wxID_SEPARATOR, + wxEmptyString, + wxNullBitmap, wxNullBitmap, + wxITEM_SEPARATOR, NULL, + wxEmptyString, wxEmptyString); + } + + + // implementation only from now on + // ------------------------------- + + // Do the toolbar button updates (check for EVT_UPDATE_UI handlers) + virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE) ; + + // don't want toolbars to accept the focus + virtual bool AcceptsFocus() const { return false; } + +#if wxUSE_MENUS + // Set dropdown menu + bool SetDropdownMenu(int toolid, wxMenu *menu); +#endif -public: +protected: + // choose the default border for this window + virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; } + + // to implement in derived classes + // ------------------------------- + + // create a new toolbar tool and add it to the toolbar, this is typically + // implemented by just calling InsertTool() + virtual wxToolBarToolBase *DoAddTool + ( + int toolid, + const wxString& label, + const wxBitmap& bitmap, + const wxBitmap& bmpDisabled, + wxItemKind kind, + const wxString& shortHelp = wxEmptyString, + const wxString& longHelp = wxEmptyString, + wxObject *clientData = NULL, + wxCoord xPos = wxDefaultCoord, + wxCoord yPos = wxDefaultCoord + ); + + // the tool is not yet inserted into m_tools list when this function is + // called and will only be added to it if this function succeeds + virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool) = 0; + + // the tool is still in m_tools list when this function is called, it will + // only be deleted from it if it succeeds + virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool) = 0; + + // called when the tools enabled flag changes + virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable) = 0; + + // called when the tool is toggled + virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle) = 0; + + // called when the tools "can be toggled" flag changes + virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle) = 0; + + + // helper functions + // ---------------- + + // call this from derived class ctor/Create() to ensure that we have either + // wxTB_HORIZONTAL or wxTB_VERTICAL style, there is a lot of existing code + // which randomly checks either one or the other of them and gets confused + // if neither is set (and making one of them 0 is not an option neither as + // then the existing tests would break down) + void FixupStyle(); + + // un-toggle all buttons in the same radio group + void UnToggleRadioGroup(wxToolBarToolBase *tool); + + // make the size of the buttons big enough to fit the largest bitmap size + void AdjustToolBitmapSize(); + + // calls InsertTool() and deletes the tool if inserting it failed + wxToolBarToolBase *DoInsertNewTool(size_t pos, wxToolBarToolBase *tool) + { + if ( !InsertTool(pos, tool) ) + { + delete tool; + return NULL; + } + + return tool; + } + + // the list of all our tools + wxToolBarToolsList m_tools; + + // the offset of the first tool + int m_xMargin; + int m_yMargin; + + // the maximum number of toolbar rows/columns + int m_maxRows; + int m_maxCols; + + // the tool packing and separation + int m_toolPacking, + m_toolSeparation; + + // the size of the toolbar bitmaps + wxCoord m_defaultWidth, m_defaultHeight; + +private: DECLARE_EVENT_TABLE() + wxDECLARE_NO_COPY_CLASS(wxToolBarBase); }; -#endif // USE_TOOLBAR +// deprecated function for creating the image for disabled buttons, use +// wxImage::ConvertToGreyscale() instead +#if WXWIN_COMPATIBILITY_2_8 + +wxDEPRECATED( bool wxCreateGreyedImage(const wxImage& in, wxImage& out) ); + +#endif // WXWIN_COMPATIBILITY_2_8 + + +#endif // wxUSE_TOOLBAR + #endif - // __TBARBASEH__ + // _WX_TBARBASE_H_