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

controls can now be put in the toolbars (MSW only so far, preliminary version)

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4478 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-11-12 02:17:44 +00:00
parent 7c74e7fe1d
commit 1c383dbac9
6 changed files with 790 additions and 538 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/wx/defs.h
View File

@@ -143,6 +143,12 @@
#endif #endif
#endif #endif
// "old" GNUWIN32 is the one without Norlander's headers: it lacks the standard
// Win32 headers and we define the used stuff ourselves for it in
// wx/msw/gnuwin32/extra.h
#if defined(__MINGW32__) && !wxUSE_NORLANDER_HEADERS
#define __GNUWIN32_OLD__
#endif
////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////
// Currently Only MS-Windows/NT, XView and Motif are supported // Currently Only MS-Windows/NT, XView and Motif are supported

104
include/wx/msw/tbar95.h
View File

@@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: tbar95.h // Name: wx/msw/tbar95.h
// Purpose: wxToolBar95 (Windows 95 toolbar) class // Purpose: wxToolBar95 (Windows 95 toolbar) class
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
@@ -17,76 +17,78 @@
#endif #endif
#if wxUSE_TOOLBAR #if wxUSE_TOOLBAR
#include "wx/tbarbase.h" #include "wx/tbarbase.h"
WXDLLEXPORT_DATA(extern const wxChar*) wxToolBarNameStr; class WXDLLEXPORT wxToolBar95 : public wxToolBarBase
class WXDLLEXPORT wxToolBar95: public wxToolBarBase
{ {
DECLARE_DYNAMIC_CLASS(wxToolBar95) public:
public: wxToolBar95() { Init(); }
/*
* Public interface
*/
wxToolBar95(); wxToolBar95(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxNO_BORDER | wxTB_HORIZONTAL,
const wxString& name = wxToolBarNameStr)
{
Init();
wxToolBar95(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, Create(parent, id, pos, size, style, name);
long style = wxNO_BORDER|wxTB_HORIZONTAL, }
const wxString& name = wxToolBarNameStr)
{
Create(parent, id, pos, size, style, name);
}
~wxToolBar95();
bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, ~wxToolBar95();
long style = wxNO_BORDER|wxTB_HORIZONTAL,
const wxString& name = wxToolBarNameStr);
// Call default behaviour bool Create(wxWindow *parent,
void OnMouseEvent(wxMouseEvent& event); wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxNO_BORDER | wxTB_HORIZONTAL,
const wxString& name = wxToolBarNameStr);
// Handle wxToolBar95 events // override base class virtuals
// If pushedBitmap is NULL, a reversed version of bitmap is virtual wxToolBarTool *AddTool(int toolIndex,
// created and used as the pushed/toggled image. const wxBitmap& bitmap,
// If toggle is TRUE, the button toggles between the two states. const wxBitmap& pushedBitmap = wxNullBitmap,
wxToolBarTool *AddTool(int toolIndex, const wxBitmap& bitmap, const wxBitmap& pushedBitmap = wxNullBitmap, bool toggle = FALSE,
bool toggle = FALSE, long xPos = -1, long yPos = -1, wxObject *clientData = NULL, long xPos = -1, long yPos = -1,
const wxString& helpString1 = "", const wxString& helpString2 = ""); wxObject *clientData = NULL,
const wxString& helpString1 = wxEmptyString,
const wxString& helpString2 = wxEmptyString);
virtual bool AddControl(wxControl *control);
// Set default bitmap size virtual void ClearTools();
void SetToolBitmapSize(const wxSize& size);
void EnableTool(int toolIndex, bool enable); // additional drawing on enabling
void ToggleTool(int toolIndex, bool toggle); // toggle is TRUE if toggled on
void ClearTools();
// The button size is bigger than the bitmap size virtual bool Realize() { return CreateTools(); };
wxSize GetToolSize() const;
wxSize GetMaxSize() const; virtual void EnableTool(int toolIndex, bool enable);
virtual void ToggleTool(int toolIndex, bool toggle);
virtual bool GetToolState(int toolIndex) const; virtual void SetToolBitmapSize(const wxSize& size);
virtual wxSize GetToolSize() const;
virtual wxSize GetMaxSize() const;
// Add all the buttons: required for Win95. virtual bool GetToolState(int toolIndex) const;
virtual bool CreateTools();
virtual void SetRows(int nRows);
virtual void LayoutButtons() {}
// The post-tool-addition call virtual bool CreateTools();
bool Realize() { return CreateTools(); }; virtual void SetRows(int nRows);
// IMPLEMENTATION // IMPLEMENTATION
virtual bool MSWCommand(WXUINT param, WXWORD id); virtual bool MSWCommand(WXUINT param, WXWORD id);
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result); virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
// Responds to colour changes void OnMouseEvent(wxMouseEvent& event);
void OnSysColourChanged(wxSysColourChangedEvent& event); void OnSysColourChanged(wxSysColourChangedEvent& event);
protected: protected:
WXHBITMAP m_hBitmap; // common part of all ctors
void Init();
DECLARE_EVENT_TABLE() WXHBITMAP m_hBitmap;
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxToolBar95)
}; };
#endif // wxUSE_TOOLBAR #endif // wxUSE_TOOLBAR

466
include/wx/tbarbase.h
View File

@@ -6,250 +6,352 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TBARBASE_H_ #ifndef _WX_TBARBASE_H_
#define _WX_TBARBASE_H_ #define _WX_TBARBASE_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__ #ifdef __GNUG__
#pragma interface "tbarbase.h" #pragma interface "tbarbase.h"
#endif #endif
#include "wx/setup.h"
#include "wx/defs.h" #include "wx/defs.h"
#include "wx/bitmap.h" #include "wx/bitmap.h"
#include "wx/list.h" #include "wx/list.h"
#include "wx/control.h" #include "wx/control.h"
class WXDLLEXPORT wxToolBar;
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const wxChar*) wxToolBarNameStr; WXDLLEXPORT_DATA(extern const wxChar*) wxToolBarNameStr;
WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize; WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition; WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
#define wxTOOL_STYLE_BUTTON 1 enum
#define wxTOOL_STYLE_SEPARATOR 2
#ifdef __WXGTK__
class WXDLLEXPORT wxToolBar;
#endif
class WXDLLEXPORT wxToolBarTool: public wxObject
{ {
DECLARE_DYNAMIC_CLASS(wxToolBarTool) wxTOOL_STYLE_BUTTON = 1,
public: wxTOOL_STYLE_SEPARATOR = 2,
wxToolBarTool() {} wxTOOL_STYLE_CONTROL
};
// ----------------------------------------------------------------------------
// wxToolBarTool is one button/separator/whatever in the toolbar
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxToolBarTool : public wxObject
{
public:
// ctors & dtor
// ------------
wxToolBarTool() { }
#ifdef __WXGTK__ #ifdef __WXGTK__
wxToolBarTool(wxToolBar *owner, wxToolBarTool(wxToolBar *owner,
int theIndex = 0, const wxBitmap& bitmap1 = wxNullBitmap, const wxBitmap& bitmap2 = wxNullBitmap, int theIndex = 0,
bool toggle = FALSE, wxObject *clientData = (wxObject *) NULL, const wxBitmap& bitmap1 = wxNullBitmap,
const wxString& shortHelpString = "", const wxString& longHelpString = "", const wxBitmap& bitmap2 = wxNullBitmap,
GtkWidget *pixmap = (GtkWidget *) NULL ); bool toggle = FALSE,
#else wxObject *clientData = (wxObject *) NULL,
wxToolBarTool(int theIndex, const wxBitmap& bitmap1 = wxNullBitmap, const wxBitmap& bitmap2 = wxNullBitmap, const wxString& shortHelpString = wxEmptyString,
bool toggle = FALSE, long xPos = -1, long yPos = -1, const wxString& longHelpString = wxEmptyString,
const wxString& shortHelpString = wxEmptyString, const wxString& longHelpString = wxEmptyString); GtkWidget *pixmap = (GtkWidget *) NULL );
#endif #else // !GTK
~wxToolBarTool (); wxToolBarTool(int theIndex,
inline void SetSize( long w, long h ) { m_width = w; m_height = h; } const wxBitmap& bitmap1 = wxNullBitmap,
inline long GetWidth () const { return m_width; } const wxBitmap& bitmap2 = wxNullBitmap,
inline long GetHeight () const { return m_height; } bool toggle = FALSE,
long xPos = -1,
long yPos = -1,
const wxString& shortHelpString = wxEmptyString,
const wxString& longHelpString = wxEmptyString);
#endif // GTK/!GTK
wxToolBarTool(wxControl *control);
~wxToolBarTool();
// accessors
// ---------
void SetSize( long w, long h ) { m_width = w; m_height = h; }
long GetWidth() const { return m_width; }
long GetHeight() const { return m_height; }
wxControl *GetControl() const
{
wxASSERT_MSG( m_toolStyle == wxTOOL_STYLE_CONTROL,
_T("this toolbar tool is not a control") );
return m_control;
}
public: public:
int m_toolStyle; int m_toolStyle;
wxObject * m_clientData; int m_index;
int m_index;
long m_x; // as controls have their own client data, no need to waste memory
long m_y; union
long m_width; {
long m_height; wxObject *m_clientData;
bool m_toggleState; wxControl *m_control;
bool m_isToggle; };
bool m_deleteSecondBitmap;
bool m_enabled; wxCoord m_x;
wxBitmap m_bitmap1; wxCoord m_y;
wxBitmap m_bitmap2; wxCoord m_width;
bool m_isMenuCommand; wxCoord m_height;
wxString m_shortHelpString;
wxString m_longHelpString; bool m_toggleState;
bool m_isToggle;
bool m_enabled;
bool m_isMenuCommand;
bool m_deleteSecondBitmap;
wxBitmap m_bitmap1;
wxBitmap m_bitmap2;
wxString m_shortHelpString;
wxString m_longHelpString;
#ifdef __WXGTK__ #ifdef __WXGTK__
wxToolBar *m_owner; wxToolBar *m_owner;
GtkWidget *m_item; GtkWidget *m_item;
GtkWidget *m_pixmap; GtkWidget *m_pixmap;
#endif #endif // GTK
private:
DECLARE_DYNAMIC_CLASS(wxToolBarTool)
}; };
// ----------------------------------------------------------------------------
// the base class for all toolbars
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxToolBarBase : public wxControl class WXDLLEXPORT wxToolBarBase : public wxControl
{ {
DECLARE_ABSTRACT_CLASS(wxToolBarBase) public:
public: wxToolBarBase();
~wxToolBarBase();
wxToolBarBase(); // toolbar construction
~wxToolBarBase(); // --------------------
// Handle wxToolBar events // 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,
wxCoord xPos = -1,
wxCoord yPos = -1,
wxObject *clientData = NULL,
const wxString& helpString1 = wxEmptyString,
const wxString& helpString2 = wxEmptyString);
// Only allow toggle if returns TRUE. Call when left button up. // add an arbitrary control to the toolbar at given index, return TRUE if
virtual bool OnLeftClick(int toolIndex, bool toggleDown); // ok (notice that the control will be deleted by the toolbar and that it
// will also adjust its position/size)
//
// NB: the control should have toolbar as its parent
virtual bool AddControl(wxControl *control) { return FALSE; }
// Call when right button down. virtual void AddSeparator();
virtual void OnRightClick(int toolIndex, long x, long y); virtual void ClearTools();
// Called when the mouse cursor enters a tool bitmap. // must be called after all buttons have been created to finish toolbar
// Argument is -1 if mouse is exiting the toolbar. // initialisation
virtual void OnMouseEnter(int toolIndex); virtual bool Realize() = 0;
// If pushedBitmap is NULL, a reversed version of bitmap is // tools state
// 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 = wxEmptyString, const wxString& helpString2 = wxEmptyString);
virtual void AddSeparator();
virtual void ClearTools();
virtual void EnableTool(int toolIndex, bool enable); 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() const { return (wxList&) m_tools; }
// After the toolbar has initialized, this is the size the tools take up // toggle is TRUE if toggled on
#if WXWXIN_COMPATIBILITY virtual void ToggleTool(int toolIndex, bool toggle);
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; // Set this to be togglable (or not)
virtual bool GetToolEnabled(int toolIndex) const; virtual void SetToggle(int toolIndex, bool toggle);
virtual wxToolBarTool *FindToolForPosition(long x, long y) const; virtual wxObject *GetToolClientData(int index) const;
virtual void SetToolShortHelp(int toolIndex, const wxString& helpString); virtual bool GetToolState(int toolIndex) const;
virtual wxString GetToolShortHelp(int toolIndex) const; virtual bool GetToolEnabled(int toolIndex) const;
virtual void SetToolLongHelp(int toolIndex, const wxString& helpString); virtual wxToolBarTool *FindToolForPosition(long x, long y) const;
virtual wxString GetToolLongHelp(int toolIndex) const;
virtual void SetMargins(int x, int y); virtual void SetToolShortHelp(int toolIndex, const wxString& helpString);
inline void SetMargins(const wxSize& size) { SetMargins((int) size.x, (int) size.y); } virtual wxString GetToolShortHelp(int toolIndex) const;
virtual void SetToolPacking(int packing); virtual void SetToolLongHelp(int toolIndex, const wxString& helpString);
virtual void SetToolSeparation(int separation); virtual wxString GetToolLongHelp(int toolIndex) const;
inline virtual wxSize GetToolMargins() { return wxSize(m_xMargin, m_yMargin); } // margins/packing/separation
inline virtual int GetToolPacking() { return m_toolPacking; } // --------------------------
inline virtual int GetToolSeparation() { return m_toolSeparation; }
virtual void SetToolBitmapSize(const wxSize& size) { m_defaultWidth = size.x; m_defaultHeight = size.y; }; virtual void SetMargins(int x, int y);
virtual wxSize GetToolBitmapSize() const { return wxSize(m_defaultWidth, m_defaultHeight); } void SetMargins(const wxSize& size)
{ SetMargins((int) size.x, (int) size.y); }
virtual void SetToolPacking(int packing);
virtual void SetToolSeparation(int separation);
// The button size (in some implementations) is bigger than the bitmap size: this returns virtual wxSize GetToolMargins() { return wxSize(m_xMargin, m_yMargin); }
// the total button size. virtual int GetToolPacking() { return m_toolPacking; }
virtual wxSize GetToolSize() const { return wxSize(m_defaultWidth, m_defaultHeight); } ; virtual int GetToolSeparation() { return m_toolSeparation; }
void SetMaxRowsCols(int rows, int cols)
{ m_maxRows = rows; m_maxCols = cols; }
int GetMaxRows() const { return m_maxRows; }
int GetMaxCols() const { return m_maxCols; }
// tool(bar) size
// -------------
virtual void SetToolBitmapSize(const wxSize& size)
{ m_defaultWidth = size.x; m_defaultHeight = size.y; };
virtual wxSize GetToolBitmapSize() const
{ return wxSize(m_defaultWidth, m_defaultHeight); }
// After the toolbar has initialized, this is the size the tools take up
virtual wxSize GetMaxSize() const;
// The button size (in some implementations) is bigger than the bitmap size: this returns
// the total button size.
virtual wxSize GetToolSize() const
{ return wxSize(m_defaultWidth, m_defaultHeight); } ;
// Handle wxToolBar events
// -----------------------
// 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 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);
// more deprecated functions
// -------------------------
// Compatibility
#if WXWIN_COMPATIBILITY #if WXWIN_COMPATIBILITY
void SetDefaultSize(int w, int h) { SetDefaultSize(wxSize(w, h)); } void SetDefaultSize(int w, int h) { SetDefaultSize(wxSize(w, h)); }
long GetDefaultWidth() const { return m_defaultWidth; } long GetDefaultWidth() const { return m_defaultWidth; }
long GetDefaultHeight() const { return m_defaultHeight; } long GetDefaultHeight() const { return m_defaultHeight; }
int GetDefaultButtonWidth() const { return (int) GetDefaultButtonSize().x; }; int GetDefaultButtonWidth() const { return (int) GetDefaultButtonSize().x; };
int GetDefaultButtonHeight() const { return (int) GetDefaultButtonSize().y; }; int GetDefaultButtonHeight() const { return (int) GetDefaultButtonSize().y; };
virtual void SetDefaultSize(const wxSize& size) { SetToolBitmapSize(size); } virtual void SetDefaultSize(const wxSize& size) { SetToolBitmapSize(size); }
virtual wxSize GetDefaultSize() const { return GetToolBitmapSize(); } virtual wxSize GetDefaultSize() const { return GetToolBitmapSize(); }
virtual wxSize GetDefaultButtonSize() const { return GetToolSize(); } virtual wxSize GetDefaultButtonSize() const { return GetToolSize(); }
#endif void GetMaxSize ( long * width, long * height ) const
{ wxSize maxSize(GetMaxSize()); *width = maxSize.x; *height = maxSize.y; }
#endif // WXWIN_COMPATIBILITY
// Lay the tools out // implementation only from now on
virtual void LayoutTools(); // -------------------------------
// Add all the buttons: required for Win95. wxList& GetTools() const { return (wxList&) m_tools; }
virtual bool CreateTools() { return TRUE; }
// Calls the appropriate function after tools have been created. // Lay the tools out
// E.g. Layout, or CreateTools. virtual void LayoutTools();
virtual bool Realize() = 0;
void Command(wxCommandEvent& event); // Add all the buttons: required for Win95.
virtual bool CreateTools() { return TRUE; }
// SCROLLING: this has to be copied from wxScrolledWindow since wxToolBarBase void Command(wxCommandEvent& event);
// inherits from wxControl. This could have been put into wxToolBarSimple,
// but we might want any derived toolbar class to be scrollable.
// Number of pixels per user unit (0 or -1 for no scrollbar) // SCROLLING: this has to be copied from wxScrolledWindow since wxToolBarBase
// Length of virtual canvas in user units // inherits from wxControl. This could have been put into wxToolBarSimple,
virtual void SetScrollbars(int horizontal, int vertical, // but we might want any derived toolbar class to be scrollable.
int x_length, int y_length,
int x_pos = 0, int y_pos = 0);
// Physically scroll the window // Number of pixels per user unit (0 or -1 for no scrollbar)
virtual void Scroll(int x_pos, int y_pos); // Length of virtual canvas in user units
virtual void GetScrollPixelsPerUnit(int *x_unit, int *y_unit) const; virtual void SetScrollbars(int horizontal, int vertical,
virtual void EnableScrolling(bool x_scrolling, bool y_scrolling); int x_length, int y_length,
virtual void AdjustScrollbars(); int x_pos = 0, int y_pos = 0);
// Prepare the DC by translating it according to the current scroll position // Physically scroll the window
virtual void PrepareDC(wxDC& dc); 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();
int GetScrollPageSize(int orient) const ; // Prepare the DC by translating it according to the current scroll position
void SetScrollPageSize(int orient, int pageSize); virtual void PrepareDC(wxDC& dc);
// Get the view start int GetScrollPageSize(int orient) const ;
virtual void ViewStart(int *x, int *y) const; void SetScrollPageSize(int orient, int pageSize);
// Actual size in pixels when scrolling is taken into account // Get the view start
virtual void GetVirtualSize(int *x, int *y) const; virtual void ViewStart(int *x, int *y) const;
// Do the toolbar button updates (check for EVT_UPDATE_UI handlers) // Actual size in pixels when scrolling is taken into account
virtual void DoToolbarUpdates(); virtual void GetVirtualSize(int *x, int *y) const;
inline void SetMaxRowsCols(int rows, int cols) { m_maxRows = rows; m_maxCols = cols; } // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
inline int GetMaxRows() const { return m_maxRows; } virtual void DoToolbarUpdates();
inline int GetMaxCols() const { return m_maxCols; }
void OnScroll(wxScrollEvent& event); // event handlers
void OnSize(wxSizeEvent& event); void OnScroll(wxScrollEvent& event);
void OnIdle(wxIdleEvent& event); void OnSize(wxSizeEvent& event);
void OnIdle(wxIdleEvent& event);
protected:
wxList m_tools;
// int m_tilingDirection;
// int m_rowsOrColumns;
int m_maxRows;
int m_maxCols;
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;
wxCoord m_defaultWidth;
wxCoord m_defaultHeight;
public:
////////////////////////////////////////////////////////////////////////
//// IMPLEMENTATION
// Calculate scroll increment
virtual int CalcScrollInc(wxScrollEvent& event);
////////////////////////////////////////////////////////////////////////
//// PROTECTED DATA
protected: protected:
int m_xScrollPixelsPerLine; wxList m_tools;
int m_yScrollPixelsPerLine;
bool m_xScrollingEnabled; int m_maxRows;
bool m_yScrollingEnabled; int m_maxCols;
int m_xScrollPosition; long m_maxWidth,
int m_yScrollPosition; m_maxHeight;
bool m_calcScrolledOffset; // If TRUE, wxCanvasDC uses scrolled offsets
int m_xScrollLines; int m_currentTool; // Tool where mouse currently is
int m_yScrollLines; int m_pressedTool; // Tool where mouse pressed
int m_xScrollLinesPerPage;
int m_yScrollLinesPerPage; int m_xMargin;
int m_yMargin;
int m_toolPacking;
int m_toolSeparation;
wxCoord m_defaultWidth;
wxCoord m_defaultHeight;
public: 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;
private:
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
DECLARE_ABSTRACT_CLASS(wxToolBarBase)
}; };
#endif #endif

23
samples/toolbar/test.cpp
View File

@@ -85,6 +85,8 @@ public:
void OnToolLeftClick(wxCommandEvent& event); void OnToolLeftClick(wxCommandEvent& event);
void OnToolEnter(wxCommandEvent& event); void OnToolEnter(wxCommandEvent& event);
void OnCombo(wxCommandEvent& event);
private: private:
void DoEnablePrint(); void DoEnablePrint();
void DoToggleHelp(); void DoToggleHelp();
@@ -105,7 +107,9 @@ enum
{ {
IDM_TOOLBAR_TOGGLETOOLBAR = 200, IDM_TOOLBAR_TOGGLETOOLBAR = 200,
IDM_TOOLBAR_ENABLEPRINT, IDM_TOOLBAR_ENABLEPRINT,
IDM_TOOLBAR_TOGGLEHELP IDM_TOOLBAR_TOGGLEHELP,
ID_COMBO = 1000
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -125,6 +129,8 @@ BEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU(-1, MyFrame::OnToolLeftClick) EVT_MENU(-1, MyFrame::OnToolLeftClick)
EVT_COMBOBOX(ID_COMBO, MyFrame::OnCombo)
EVT_TOOL_ENTER(ID_TOOLBAR, MyFrame::OnToolEnter) EVT_TOOL_ENTER(ID_TOOLBAR, MyFrame::OnToolEnter)
END_EVENT_TABLE() END_EVENT_TABLE()
@@ -205,9 +211,19 @@ bool MyApp::InitToolbar(wxToolBar* toolBar, bool smallicons)
toolBar->AddTool(wxID_NEW, *(toolBarBitmaps[0]), wxNullBitmap, FALSE, currentX, -1, (wxObject *) NULL, "New file"); toolBar->AddTool(wxID_NEW, *(toolBarBitmaps[0]), wxNullBitmap, FALSE, currentX, -1, (wxObject *) NULL, "New file");
currentX += width + 5; currentX += width + 5;
toolBar->AddTool(wxID_OPEN, *(toolBarBitmaps[1]), wxNullBitmap, FALSE, currentX, -1, (wxObject *) NULL, "Open file"); toolBar->AddTool(wxID_OPEN, *(toolBarBitmaps[1]), wxNullBitmap, FALSE, currentX, -1, (wxObject *) NULL, "Open file");
toolBar->AddSeparator();
wxComboBox *combo = new wxComboBox(toolBar, ID_COMBO);
combo->Append("This");
combo->Append("is a");
combo->Append("combobox");
combo->Append("in a");
combo->Append("toolbar");
toolBar->AddControl(combo);
if ( !smallicons ) if ( !smallicons )
{ {
toolBar->AddSeparator();
currentX += width + 5; currentX += width + 5;
toolBar->AddTool(wxID_SAVE, *(toolBarBitmaps[2]), wxNullBitmap, TRUE, currentX, -1, (wxObject *) NULL, "Toggle button 1"); toolBar->AddTool(wxID_SAVE, *(toolBarBitmaps[2]), wxNullBitmap, TRUE, currentX, -1, (wxObject *) NULL, "Toggle button 1");
currentX += width + 5; currentX += width + 5;
@@ -343,6 +359,11 @@ void MyFrame::OnToolLeftClick(wxCommandEvent& event)
} }
} }
void MyFrame::OnCombo(wxCommandEvent& event)
{
wxLogStatus(_T("Combobox string '%s' selected"), event.GetString().c_str());
}
void MyFrame::DoEnablePrint() void MyFrame::DoEnablePrint()
{ {
wxToolBar *tb = GetToolBar(); wxToolBar *tb = GetToolBar();

10
src/common/tbarbase.cpp
View File

@@ -6,7 +6,7 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -92,6 +92,12 @@ wxToolBarTool::wxToolBarTool(int theIndex,
m_longHelpString = helpS2; m_longHelpString = helpS2;
} }
wxToolBarTool::wxToolBarTool(int index, wxControl *control)
{
m_toolStyle = wxTOOL_STYLE_CONTROL;
m_control = control;
}
wxToolBarTool::~wxToolBarTool() wxToolBarTool::~wxToolBarTool()
{ {
/* /*
@@ -186,7 +192,7 @@ void wxToolBarBase::OnMouseEnter ( int toolIndex )
// created and used as the pushed/toggled image. // created and used as the pushed/toggled image.
// If toggle is TRUE, the button toggles between the two states. // If toggle is TRUE, the button toggles between the two states.
wxToolBarTool *wxToolBarBase::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap, wxToolBarTool *wxToolBarBase::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap,
bool toggle, long xPos, long yPos, wxObject *clientData, bool toggle, wxCoord xPos, wxCoord yPos, wxObject *clientData,
const wxString& helpString1, const wxString& helpString2) const wxString& helpString1, const wxString& helpString2)
{ {
#ifdef __WXGTK__ #ifdef __WXGTK__

719
src/msw/tbar95.cpp
View File

@@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: tbar95.cpp // Name: msw/tbar95.cpp
// Purpose: wxToolBar95 // Purpose: wxToolBar95
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
@@ -9,73 +9,92 @@
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation "tbar95.h" #pragma implementation "tbar95.h"
#endif #endif
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/wx.h" #include "wx/log.h"
#include "wx/intl.h"
#include "wx/dynarray.h"
#endif #endif
#if wxUSE_BUTTONBAR && wxUSE_TOOLBAR && defined(__WIN95__) #if wxUSE_BUTTONBAR && wxUSE_TOOLBAR && defined(__WIN95__)
#if !defined(__GNUWIN32__) && !defined(__SALFORDC__) #if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
#include "malloc.h" #include "malloc.h"
#endif #endif
#include <windows.h> #include "wx/msw/private.h"
#if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__) || defined(wxUSE_NORLANDER_HEADERS)
#include <commctrl.h>
#endif
#ifndef __TWIN32__ #ifndef __TWIN32__
#ifdef __GNUWIN32__
#ifndef wxUSE_NORLANDER_HEADERS #ifdef __GNUWIN32_OLD__
#include "wx/msw/gnuwin32/extra.h" #include "wx/msw/gnuwin32/extra.h"
#endif #else
#endif #include <commctrl.h>
#endif #endif
#endif // __TWIN32__
#include "wx/msw/dib.h" #include "wx/msw/dib.h"
#include "wx/tbar95.h" #include "wx/tbar95.h"
#include "wx/app.h" #include "wx/app.h" // for GetComCtl32Version
#include "wx/msw/private.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// these standard constants are not always defined in compilers headers
// Styles // Styles
#ifndef TBSTYLE_FLAT #ifndef TBSTYLE_FLAT
#define TBSTYLE_LIST 0x1000 #define TBSTYLE_LIST 0x1000
#define TBSTYLE_FLAT 0x0800 #define TBSTYLE_FLAT 0x0800
#define TBSTYLE_TRANSPARENT 0x8000 #define TBSTYLE_TRANSPARENT 0x8000
#endif #endif
// use TBSTYLE_TRANSPARENT if you use TBSTYLE_FLAT // use TBSTYLE_TRANSPARENT if you use TBSTYLE_FLAT
// Messages // Messages
#ifndef TB_GETSTYLE #ifndef TB_GETSTYLE
#define TB_GETSTYLE (WM_USER + 57) #define TB_GETSTYLE (WM_USER + 57)
#define TB_SETSTYLE (WM_USER + 56) #define TB_SETSTYLE (WM_USER + 56)
#endif #endif
/* Hint from a newsgroup for custom flatbar drawing: // these values correspond to those used by comctl32.dll
Set the TBSTYLE_CUSTOMERASE style, then handle the
NM_CUSTOMDRAW message and do your custom drawing.
*/
#define DEFAULTBITMAPX 16 #define DEFAULTBITMAPX 16
#define DEFAULTBITMAPY 15 #define DEFAULTBITMAPY 15
#define DEFAULTBUTTONX 24 #define DEFAULTBUTTONX 24
#define DEFAULTBUTTONY 24 #define DEFAULTBUTTONY 24
#define DEFAULTBARHEIGHT 27 #define DEFAULTBARHEIGHT 27
// ----------------------------------------------------------------------------
// function prototypes
// ----------------------------------------------------------------------------
static void wxMapBitmap(HBITMAP hBitmap, int width, int height);
// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY #if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase) IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase)
#endif #endif
BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase) BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase)
@@ -83,15 +102,21 @@ BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase)
EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged) EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged)
END_EVENT_TABLE() END_EVENT_TABLE()
static void wxMapBitmap(HBITMAP hBitmap, int width, int height); // ============================================================================
// implementation
// ============================================================================
wxToolBar95::wxToolBar95() // ----------------------------------------------------------------------------
// wxToolBar95 construction
// ----------------------------------------------------------------------------
void wxToolBar95::Init()
{ {
m_maxWidth = -1; m_maxWidth = -1;
m_maxHeight = -1; m_maxHeight = -1;
m_hBitmap = 0; m_hBitmap = 0;
m_defaultWidth = DEFAULTBITMAPX; m_defaultWidth = DEFAULTBITMAPX;
m_defaultHeight = DEFAULTBITMAPY; m_defaultHeight = DEFAULTBITMAPY;
} }
bool wxToolBar95::Create(wxWindow *parent, bool wxToolBar95::Create(wxWindow *parent,
@@ -101,254 +126,351 @@ bool wxToolBar95::Create(wxWindow *parent,
long style, long style,
const wxString& name) const wxString& name)
{ {
m_hWnd = 0; wxASSERT_MSG( (style & wxTB_VERTICAL) == 0,
wxT("Sorry, wxToolBar95 under Windows 95 only "
"supports horizontal orientation.") );
m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)), // common initialisation
GetGValue(GetSysColor(COLOR_BTNFACE)), if ( !CreateControl(parent, id, pos, size, style, name) )
GetBValue(GetSysColor(COLOR_BTNFACE))); return FALSE;
m_foregroundColour = *wxBLACK ;
wxASSERT_MSG( (style & wxTB_VERTICAL) == 0, // set up the colors and fonts
wxT("Sorry, wxToolBar95 under Windows 95 only " #if 0
"supports horizontal orientation.") ); wxRGBToColour(m_backgroundColour, GetSysColor(COLOR_BTNFACE));
m_foregroundColour = *wxBLACK;
m_maxWidth = -1; SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
m_maxHeight = -1; #endif
m_hBitmap = 0; // prepare flags
DWORD msflags = 0; // WS_VISIBLE | WS_CHILD always included
if (style & wxBORDER)
msflags |= WS_BORDER;
msflags |= TBSTYLE_TOOLTIPS;
m_defaultWidth = DEFAULTBITMAPX; if (style & wxTB_FLAT)
m_defaultHeight = DEFAULTBITMAPY; {
SetName(name); if (wxTheApp->GetComCtl32Version() > 400)
msflags |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT;
}
m_windowStyle = style; // MSW-specific initialisation
if ( !wxControl::MSWCreateControl(TOOLBARCLASSNAME, msflags) )
return FALSE;
SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT)); // Toolbar-specific initialisation
SetParent(parent); ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
int x = pos.x; // position it
int y = pos.y; int x = pos.x;
int width = size.x; int y = pos.y;
int height = size.y; int width = size.x;
int height = size.y;
if (width <= 0) if (width <= 0)
width = 100; width = 100;
if (height <= 0) if (height <= 0)
height = 30; height = m_defaultHeight;
if (x < 0) if (x < 0)
x = 0; x = 0;
if (y < 0) if (y < 0)
y = 0; y = 0;
m_windowId = (id < 0 ? NewControlId() : id); SetSize(x, y, width, height);
DWORD msflags = 0;
if (style & wxBORDER)
msflags |= WS_BORDER;
msflags |= WS_CHILD | WS_VISIBLE | TBSTYLE_TOOLTIPS;
if (style & wxTB_FLAT) return TRUE;
{
if (wxTheApp->GetComCtl32Version() > 400)
msflags |= TBSTYLE_FLAT;
}
bool want3D;
WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
// Even with extended styles, need to combine with WS_BORDER
// for them to look right.
if ( want3D || wxStyleHasBorder(m_windowStyle) )
msflags |= WS_BORDER;
// Create the toolbar control.
HWND hWndToolbar = CreateWindowEx
(
exStyle, // Extended styles.
TOOLBARCLASSNAME, // Class name for the toolbar.
wxT(""), // No default text.
msflags, // Styles
x, y, width, height, // Standard toolbar size and position.
(HWND) parent->GetHWND(), // Parent window of the toolbar.
(HMENU)m_windowId, // Toolbar ID.
wxGetInstance(), // Current instance.
NULL // No class data.
);
wxCHECK_MSG( hWndToolbar, FALSE, wxT("Toolbar creation failed") );
// Toolbar-specific initialisation
::SendMessage(hWndToolbar, TB_BUTTONSTRUCTSIZE,
(WPARAM)sizeof(TBBUTTON), (LPARAM)0);
m_hWnd = (WXHWND) hWndToolbar;
if (parent)
parent->AddChild(this);
SubclassWin((WXHWND)hWndToolbar);
return TRUE;
} }
wxToolBar95::~wxToolBar95() wxToolBar95::~wxToolBar95()
{ {
UnsubclassWin(); UnsubclassWin();
if (m_hBitmap) if (m_hBitmap)
{ {
::DeleteObject((HBITMAP) m_hBitmap); ::DeleteObject((HBITMAP) m_hBitmap);
m_hBitmap = 0; }
} }
void wxToolBar95::ClearTools()
{
// TODO: Don't know how to reset the toolbar bitmap, as yet.
// But adding tools and calling CreateTools should probably
// recreate a buttonbar OK.
wxToolBarBase::ClearTools();
}
bool wxToolBar95::AddControl(wxControl *control)
{
wxCHECK_MSG( control, FALSE, _T("toolbar: can't insert NULL control") );
wxCHECK_MSG( control->GetParent() == this, FALSE,
_T("control must have toolbar as parent") );
wxToolBarTool *tool = new wxToolBarTool(control);
m_tools.Append(control->GetId(), tool);
return TRUE;
}
wxToolBarTool *wxToolBar95::AddTool(int index,
const wxBitmap& bitmap,
const wxBitmap& pushedBitmap,
bool toggle,
long xPos, long yPos,
wxObject *clientData,
const wxString& helpString1,
const wxString& helpString2)
{
wxToolBarTool *tool = new wxToolBarTool(index, bitmap, wxNullBitmap,
toggle, xPos, yPos,
helpString1, helpString2);
tool->m_clientData = clientData;
if (xPos > -1)
tool->m_x = xPos;
else
tool->m_x = m_xMargin;
if (yPos > -1)
tool->m_y = yPos;
else
tool->m_y = m_yMargin;
tool->SetSize(GetToolSize().x, GetToolSize().y);
m_tools.Append((long)index, tool);
return tool;
} }
bool wxToolBar95::CreateTools() bool wxToolBar95::CreateTools()
{ {
if (m_tools.Number() == 0) size_t nTools = m_tools.GetCount();
return FALSE; if ( nTools == 0 )
return FALSE;
HBITMAP oldToolBarBitmap = (HBITMAP) m_hBitmap; HBITMAP oldToolBarBitmap = (HBITMAP) m_hBitmap;
int totalBitmapWidth = (int)(m_defaultWidth * m_tools.Number()); int totalBitmapWidth = (int)(m_defaultWidth * nTools);
int totalBitmapHeight = (int)m_defaultHeight; int totalBitmapHeight = (int)m_defaultHeight;
// Create a bitmap for all the tool bitmaps // Create a bitmap for all the tool bitmaps
HDC dc = ::GetDC(NULL); HDC dc = ::GetDC(NULL);
m_hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap(dc, totalBitmapWidth, totalBitmapHeight); m_hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap(dc,
::ReleaseDC(NULL, dc); totalBitmapWidth,
totalBitmapHeight);
::ReleaseDC(NULL, dc);
// Now blit all the tools onto this bitmap // Now blit all the tools onto this bitmap
HDC memoryDC = ::CreateCompatibleDC(NULL); HDC memoryDC = ::CreateCompatibleDC(NULL);
HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, (HBITMAP) m_hBitmap); HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, (HBITMAP)m_hBitmap);
HDC memoryDC2 = ::CreateCompatibleDC(NULL); HDC memoryDC2 = ::CreateCompatibleDC(NULL);
int x = 0;
wxNode *node = m_tools.First(); // the button position
int noButtons = 0; wxCoord x = 0;
while (node)
{ // the number of buttons (not separators)
wxToolBarTool *tool = (wxToolBarTool *)node->Data(); int noButtons = 0;
if ((tool->m_toolStyle != wxTOOL_STYLE_SEPARATOR) && tool->m_bitmap1.Ok() && tool->m_bitmap1.GetHBITMAP())
wxNode *node = m_tools.First();
while (node)
{ {
// wxPalette *palette = tool->m_bitmap1->GetPalette(); wxToolBarTool *tool = (wxToolBarTool *)node->Data();
if ( tool->m_toolStyle == wxTOOL_STYLE_BUTTON && tool->m_bitmap1.Ok() )
{
HBITMAP hbmp = GetHbitmapOf(tool->m_bitmap1);
if ( hbmp )
{
HBITMAP oldBitmap2 = (HBITMAP)::SelectObject(memoryDC2, hbmp);
if ( !BitBlt(memoryDC, x, 0, m_defaultWidth, m_defaultHeight,
memoryDC2, 0, 0, SRCCOPY) )
{
wxLogLastError("BitBlt");
}
HBITMAP oldBitmap2 = (HBITMAP) ::SelectObject(memoryDC2, (HBITMAP) tool->m_bitmap1.GetHBITMAP()); ::SelectObject(memoryDC2, oldBitmap2);
/* int bltResult = */
BitBlt(memoryDC, x, 0, (int) m_defaultWidth, (int) m_defaultHeight, memoryDC2,
0, 0, SRCCOPY);
::SelectObject(memoryDC2, oldBitmap2);
x += (int)m_defaultWidth;
noButtons ++;
}
node = node->Next();
}
::SelectObject(memoryDC, oldBitmap);
::DeleteDC(memoryDC);
::DeleteDC(memoryDC2);
// Map to system colours x += m_defaultWidth;
wxMapBitmap((HBITMAP) m_hBitmap, totalBitmapWidth, totalBitmapHeight); noButtons++;
}
if ( oldToolBarBitmap ) }
{ node = node->Next();
TBREPLACEBITMAP replaceBitmap;
replaceBitmap.hInstOld = NULL;
replaceBitmap.hInstNew = NULL;
replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
replaceBitmap.nIDNew = (UINT) (HBITMAP) m_hBitmap;
replaceBitmap.nButtons = noButtons;
if (::SendMessage((HWND) GetHWND(), TB_REPLACEBITMAP, (WPARAM) 0, (LPARAM) &replaceBitmap) == -1)
{
wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
} }
::DeleteObject((HBITMAP) oldToolBarBitmap); ::SelectObject(memoryDC, oldBitmap);
::DeleteDC(memoryDC);
::DeleteDC(memoryDC2);
// Now delete all the buttons // Map to system colours
int i = 0; wxMapBitmap((HBITMAP) m_hBitmap, totalBitmapWidth, totalBitmapHeight);
while ( TRUE )
if ( oldToolBarBitmap )
{ {
// TODO: What about separators???? They don't have an id! TBREPLACEBITMAP replaceBitmap;
if ( ! ::SendMessage( (HWND) GetHWND(), TB_DELETEBUTTON, i, 0 ) ) replaceBitmap.hInstOld = NULL;
break; replaceBitmap.hInstNew = NULL;
} replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
} replaceBitmap.nIDNew = (UINT) (HBITMAP) m_hBitmap;
else replaceBitmap.nButtons = noButtons;
{ if ( ::SendMessage(GetHwnd(), TB_REPLACEBITMAP,
TBADDBITMAP addBitmap; 0, (LPARAM) &replaceBitmap) == -1 )
addBitmap.hInst = 0; {
addBitmap.nID = (UINT)m_hBitmap; wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
if (::SendMessage((HWND) GetHWND(), TB_ADDBITMAP, (WPARAM) noButtons, (LPARAM) &addBitmap) == -1) }
{
wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
}
}
// Now add the buttons. ::DeleteObject((HBITMAP) oldToolBarBitmap);
TBBUTTON buttons[50];
node = m_tools.First(); // Now delete all the buttons
int i = 0; int i = 0;
int bitmapId = 0; while ( TRUE )
while (node) {
{ // TODO: What about separators???? They don't have an id!
wxToolBarTool *tool = (wxToolBarTool *)node->Data(); if ( ! ::SendMessage( GetHwnd(), TB_DELETEBUTTON, i, 0 ) )
if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR) break;
{ }
buttons[i].iBitmap = 0;
buttons[i].idCommand = 0;
buttons[i].fsState = TBSTATE_ENABLED;
buttons[i].fsStyle = TBSTYLE_SEP;
buttons[i].dwData = 0L;
buttons[i].iString = 0;
} }
else else
{ {
buttons[i].iBitmap = bitmapId; TBADDBITMAP addBitmap;
buttons[i].idCommand = tool->m_index; addBitmap.hInst = 0;
addBitmap.nID = (UINT)m_hBitmap;
buttons[i].fsState = 0; if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,
if (tool->m_enabled) (WPARAM) noButtons, (LPARAM)&addBitmap) == -1 )
buttons[i].fsState |= TBSTATE_ENABLED; {
if (tool->m_toggleState) wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
buttons[i].fsState |= TBSTATE_CHECKED; }
buttons[i].fsStyle = tool->m_isToggle ? TBSTYLE_CHECK : TBSTYLE_BUTTON;
buttons[i].dwData = 0L;
buttons[i].iString = 0;
bitmapId ++;
} }
i ++; // Now add the buttons.
node = node->Next(); TBBUTTON *buttons = new TBBUTTON[nTools];
}
long rc = ::SendMessage((HWND) GetHWND(), TB_ADDBUTTONS, (WPARAM)i, (LPARAM)& buttons); // this array will holds the indices of all controls in the toolbar
wxArrayInt controlIds;
wxCHECK_MSG( rc, FALSE, wxT("failed to add buttons to the toolbar") ); int i = 0;
int bitmapId = 0;
(void)::SendMessage((HWND) GetHWND(), TB_AUTOSIZE, (WPARAM)0, (LPARAM) 0); node = m_tools.First();
while (node)
{
wxToolBarTool *tool = (wxToolBarTool *)node->Data();
TBBUTTON& button = buttons[i];
SetRows(m_maxRows); wxZeroMemory(button);
return TRUE; switch ( tool->m_toolStyle )
{
case wxTOOL_STYLE_CONTROL:
controlIds.Add(i);
button.idCommand = tool->m_index;
// fall through: create just a separator too
case wxTOOL_STYLE_SEPARATOR:
button.fsState = TBSTATE_ENABLED;
button.fsStyle = TBSTYLE_SEP;
break;
case wxTOOL_STYLE_BUTTON:
button.iBitmap = bitmapId;
button.idCommand = tool->m_index;
if (tool->m_enabled)
button.fsState |= TBSTATE_ENABLED;
if (tool->m_toggleState)
button.fsState |= TBSTATE_CHECKED;
button.fsStyle = tool->m_isToggle ? TBSTYLE_CHECK
: TBSTYLE_BUTTON;
bitmapId++;
break;
}
i++;
node = node->Next();
}
if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS,
(WPARAM)i, (LPARAM)buttons) )
{
wxLogLastError("TB_ADDBUTTONS");
}
delete [] buttons;
// adjust the controls size to fit nicely in the toolbar
size_t nControls = controlIds.GetCount();
for ( size_t nCtrl = 0; nCtrl < nControls; nCtrl++ )
{
wxToolBarTool *tool = (wxToolBarTool *)
m_tools.Nth(controlIds[nCtrl])->Data();
wxControl *control = tool->GetControl();
wxSize size = control->GetSize();
// set the (underlying) separators width to be that of the control
TBBUTTONINFO tbbi;
tbbi.cbSize = sizeof(tbbi);
tbbi.dwMask = TBIF_SIZE;
tbbi.cx = size.x;
if ( !SendMessage(GetHwnd(), TB_SETBUTTONINFO,
tool->m_index, (LPARAM)&tbbi) )
{
// the index is probably invalid
wxLogLastError("TB_SETBUTTONINFO");
}
// and position the control itself correctly vertically
RECT r;
SendMessage(GetHwnd(), TB_GETRECT, 0, (LPARAM)(LPRECT)&r);
int height = r.bottom - r.top;
int diff = height - size.y;
if ( diff < 0 )
{
// the control is too high, resize to fit
control->SetSize(-1, height - 2);
diff = 2;
}
control->Move(r.left, r.top + diff / 2);
}
(void)::SendMessage(GetHwnd(), TB_AUTOSIZE, (WPARAM)0, (LPARAM) 0);
SetRows(m_maxRows);
return TRUE;
} }
// ----------------------------------------------------------------------------
// message handlers
// ----------------------------------------------------------------------------
bool wxToolBar95::MSWCommand(WXUINT cmd, WXWORD id) bool wxToolBar95::MSWCommand(WXUINT cmd, WXWORD id)
{ {
wxNode *node = m_tools.Find((long)id); wxNode *node = m_tools.Find((long)id);
if (!node) if (!node)
return FALSE; return FALSE;
wxToolBarTool *tool = (wxToolBarTool *)node->Data();
if (tool->m_isToggle)
tool->m_toggleState = (1 == (1 & (int)::SendMessage((HWND) GetHWND(), TB_GETSTATE, (WPARAM) id, (LPARAM) 0)));
BOOL ret = OnLeftClick((int)id, tool->m_toggleState); wxToolBarTool *tool = (wxToolBarTool *)node->Data();
if (ret == FALSE && tool->m_isToggle) if (tool->m_isToggle)
{ {
tool->m_toggleState = !tool->m_toggleState; LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
::SendMessage((HWND) GetHWND(), TB_CHECKBUTTON, (WPARAM)id, (LPARAM)MAKELONG(tool->m_toggleState, 0)); tool->m_toggleState = state & TBSTATE_CHECKED;
} }
return TRUE;
BOOL ret = OnLeftClick((int)id, tool->m_toggleState);
if ( ret == FALSE && tool->m_isToggle )
{
tool->m_toggleState = !tool->m_toggleState;
::SendMessage(GetHwnd(), TB_CHECKBUTTON,
(WPARAM)id, (LPARAM)MAKELONG(tool->m_toggleState, 0));
}
return TRUE;
} }
bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl), bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl),
@@ -358,8 +480,8 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl),
// First check if this applies to us // First check if this applies to us
NMHDR *hdr = (NMHDR *)lParam; NMHDR *hdr = (NMHDR *)lParam;
// the tooltips control created by the toolbar is sometimes Unicode, even in // the tooltips control created by the toolbar is sometimes Unicode, even
// an ANSI application // in an ANSI application - this seems to be a bug in comctl32.dll v5
int code = (int)hdr->code; int code = (int)hdr->code;
if ( (code != TTN_NEEDTEXTA) && (code != TTN_NEEDTEXTW) ) if ( (code != TTN_NEEDTEXTA) && (code != TTN_NEEDTEXTW) )
return FALSE; return FALSE;
@@ -419,101 +541,87 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl),
return TRUE; return TRUE;
} }
// ----------------------------------------------------------------------------
// sizing stuff
// ----------------------------------------------------------------------------
void wxToolBar95::SetToolBitmapSize(const wxSize& size) void wxToolBar95::SetToolBitmapSize(const wxSize& size)
{ {
m_defaultWidth = size.x; wxToolBarBase::SetToolBitmapSize(size);
m_defaultHeight = size.y;
::SendMessage((HWND) GetHWND(), TB_SETBITMAPSIZE, 0, (LPARAM) MAKELONG ((int)size.x, (int)size.y)); ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
} }
void wxToolBar95::SetRows(int nRows) void wxToolBar95::SetRows(int nRows)
{ {
RECT rect; // TRUE in wParam means to create at least as many rows
::SendMessage((HWND) GetHWND(), TB_SETROWS, MAKEWPARAM(nRows, TRUE), (LPARAM) & rect); RECT rect;
m_maxWidth = (rect.right - rect.left + 2); ::SendMessage(GetHwnd(), TB_SETROWS,
m_maxHeight = (rect.bottom - rect.top + 2); MAKEWPARAM(nRows, TRUE), (LPARAM) &rect);
m_maxWidth = (rect.right - rect.left + 2);
m_maxHeight = (rect.bottom - rect.top + 2);
m_maxRows = nRows;
} }
wxSize wxToolBar95::GetMaxSize() const wxSize wxToolBar95::GetMaxSize() const
{ {
if ((m_maxWidth == -1) || (m_maxHeight == -1)) if ( (m_maxWidth == -1) || (m_maxHeight == -1) )
{ {
RECT rect; // it has a side effect of filling m_maxWidth/Height variables
::SendMessage((HWND) GetHWND(), TB_SETROWS, MAKEWPARAM(m_maxRows, TRUE), (LPARAM) & rect); ((wxToolBar95 *)this)->SetRows(m_maxRows); // const_cast
((wxToolBar95 *)this)->m_maxWidth = (rect.right - rect.left + 2); // ??? }
((wxToolBar95 *)this)->m_maxHeight = (rect.bottom - rect.top + 2); // ???
} return wxSize(m_maxWidth, m_maxHeight);
return wxSize(m_maxWidth, m_maxHeight);
} }
// The button size is bigger than the bitmap size // The button size is bigger than the bitmap size
wxSize wxToolBar95::GetToolSize() const wxSize wxToolBar95::GetToolSize() const
{ {
return wxSize(m_defaultWidth + 8, m_defaultHeight + 7); // FIXME: this is completely bogus (VZ)
return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
} }
// ----------------------------------------------------------------------------
// tool state
// ----------------------------------------------------------------------------
void wxToolBar95::EnableTool(int toolIndex, bool enable) void wxToolBar95::EnableTool(int toolIndex, bool enable)
{ {
wxNode *node = m_tools.Find((long)toolIndex); wxNode *node = m_tools.Find((long)toolIndex);
if (node) if (node)
{ {
wxToolBarTool *tool = (wxToolBarTool *)node->Data(); wxToolBarTool *tool = (wxToolBarTool *)node->Data();
tool->m_enabled = enable; tool->m_enabled = enable;
::SendMessage((HWND) GetHWND(), TB_ENABLEBUTTON, (WPARAM)toolIndex, (LPARAM)MAKELONG(enable, 0)); ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
} (WPARAM)toolIndex, (LPARAM)MAKELONG(enable, 0));
}
} }
void wxToolBar95::ToggleTool(int toolIndex, bool toggle) void wxToolBar95::ToggleTool(int toolIndex, bool toggle)
{ {
wxNode *node = m_tools.Find((long)toolIndex); wxNode *node = m_tools.Find((long)toolIndex);
if (node) if (node)
{
wxToolBarTool *tool = (wxToolBarTool *)node->Data();
if (tool->m_isToggle)
{ {
tool->m_toggleState = toggle; wxToolBarTool *tool = (wxToolBarTool *)node->Data();
::SendMessage((HWND) GetHWND(), TB_CHECKBUTTON, (WPARAM)toolIndex, (LPARAM)MAKELONG(toggle, 0)); if (tool->m_isToggle)
{
tool->m_toggleState = toggle;
::SendMessage(GetHwnd(), TB_CHECKBUTTON,
(WPARAM)toolIndex, (LPARAM)MAKELONG(toggle, 0));
}
} }
}
} }
bool wxToolBar95::GetToolState(int toolIndex) const bool wxToolBar95::GetToolState(int toolIndex) const
{ {
return (::SendMessage((HWND) GetHWND(), TB_ISBUTTONCHECKED, (WPARAM)toolIndex, (LPARAM)0) != 0); return (::SendMessage(GetHwnd(), TB_ISBUTTONCHECKED, (WPARAM)toolIndex, (LPARAM)0) != 0);
} }
void wxToolBar95::ClearTools() // ----------------------------------------------------------------------------
{ // event handlers
// TODO: Don't know how to reset the toolbar bitmap, as yet. // ----------------------------------------------------------------------------
// But adding tools and calling CreateTools should probably
// recreate a buttonbar OK.
wxToolBarBase::ClearTools();
}
// 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.
wxToolBarTool *wxToolBar95::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap,
bool toggle, long xPos, long yPos, wxObject *clientData, const wxString& helpString1, const wxString& helpString2)
{
wxToolBarTool *tool = new wxToolBarTool(index, bitmap, wxNullBitmap, toggle, xPos, yPos, helpString1, helpString2);
tool->m_clientData = clientData;
if (xPos > -1)
tool->m_x = xPos;
else
tool->m_x = m_xMargin;
if (yPos > -1)
tool->m_y = yPos;
else
tool->m_y = m_yMargin;
tool->SetSize(GetToolSize().x, GetToolSize().y);
m_tools.Append((long)index, tool);
return tool;
}
// Responds to colour changes, and passes event on to children. // Responds to colour changes, and passes event on to children.
void wxToolBar95::OnSysColourChanged(wxSysColourChangedEvent& event) void wxToolBar95::OnSysColourChanged(wxSysColourChangedEvent& event)
@@ -544,9 +652,15 @@ void wxToolBar95::OnMouseEvent(wxMouseEvent& event)
} }
} }
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
// These are the default colors used to map the bitmap colors // These are the default colors used to map the bitmap colors
// to the current system colors // to the current system colors
// VZ: why are they BGR and not RGB? just to confuse the people or is there a
// deeper reason?
#define BGR_BUTTONTEXT (RGB(000,000,000)) // black #define BGR_BUTTONTEXT (RGB(000,000,000)) // black
#define BGR_BUTTONSHADOW (RGB(128,128,128)) // dark grey #define BGR_BUTTONSHADOW (RGB(128,128,128)) // dark grey
#define BGR_BUTTONFACE (RGB(192,192,192)) // bright grey #define BGR_BUTTONFACE (RGB(192,192,192)) // bright grey
@@ -556,7 +670,8 @@ void wxToolBar95::OnMouseEvent(wxMouseEvent& event)
void wxMapBitmap(HBITMAP hBitmap, int width, int height) void wxMapBitmap(HBITMAP hBitmap, int width, int height)
{ {
COLORMAP ColorMap[] = { COLORMAP ColorMap[] =
{
{BGR_BUTTONTEXT, COLOR_BTNTEXT}, // black {BGR_BUTTONTEXT, COLOR_BTNTEXT}, // black
{BGR_BUTTONSHADOW, COLOR_BTNSHADOW}, // dark grey {BGR_BUTTONSHADOW, COLOR_BTNSHADOW}, // dark grey
{BGR_BUTTONFACE, COLOR_BTNFACE}, // bright grey {BGR_BUTTONFACE, COLOR_BTNFACE}, // bright grey
@@ -640,4 +755,4 @@ void wxMapBitmap(HBITMAP hBitmap, int width, int height)
#endif #endif
#endif #endif // !(wxUSE_TOOLBAR && Win95)