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

80
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,
wxToolBar95(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxPoint& pos = wxDefaultPosition,
long style = wxNO_BORDER|wxTB_HORIZONTAL, const wxSize& size = wxDefaultSize,
long style = wxNO_BORDER | wxTB_HORIZONTAL,
const wxString& name = wxToolBarNameStr) const wxString& name = wxToolBarNameStr)
{ {
Init();
Create(parent, id, pos, size, style, name); Create(parent, id, pos, size, style, name);
} }
~wxToolBar95(); ~wxToolBar95();
bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, bool Create(wxWindow *parent,
long style = wxNO_BORDER|wxTB_HORIZONTAL, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxNO_BORDER | wxTB_HORIZONTAL,
const wxString& name = wxToolBarNameStr); const wxString& name = wxToolBarNameStr);
// Call default behaviour // override base class virtuals
void OnMouseEvent(wxMouseEvent& event);
// Handle wxToolBar95 events 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 bool AddControl(wxControl *control);
// If pushedBitmap is NULL, a reversed version of bitmap is virtual void ClearTools();
// created and used as the pushed/toggled image.
// If toggle is TRUE, the button toggles between the two states.
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 = "");
// Set default bitmap size virtual bool Realize() { return CreateTools(); };
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 void EnableTool(int toolIndex, bool enable);
wxSize GetToolSize() const; virtual void ToggleTool(int toolIndex, bool toggle);
wxSize GetMaxSize() const; virtual void SetToolBitmapSize(const wxSize& size);
virtual wxSize GetToolSize() const;
virtual wxSize GetMaxSize() const;
virtual bool GetToolState(int toolIndex) const; virtual bool GetToolState(int toolIndex) const;
// Add all the buttons: required for Win95.
virtual bool CreateTools(); virtual bool CreateTools();
virtual void SetRows(int nRows); virtual void SetRows(int nRows);
virtual void LayoutButtons() {}
// The post-tool-addition call
bool Realize() { return CreateTools(); };
// 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:
// common part of all ctors
void Init();
WXHBITMAP m_hBitmap; WXHBITMAP m_hBitmap;
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxToolBar95)
}; };
#endif // wxUSE_TOOLBAR #endif // wxUSE_TOOLBAR

296
include/wx/tbarbase.h
View File

@@ -12,82 +12,226 @@
#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,
bool toggle = FALSE,
wxObject *clientData = (wxObject *) NULL,
const wxString& shortHelpString = wxEmptyString,
const wxString& longHelpString = wxEmptyString,
GtkWidget *pixmap = (GtkWidget *) NULL ); GtkWidget *pixmap = (GtkWidget *) NULL );
#else #else // !GTK
wxToolBarTool(int theIndex, const wxBitmap& bitmap1 = wxNullBitmap, const wxBitmap& bitmap2 = wxNullBitmap, wxToolBarTool(int theIndex,
bool toggle = FALSE, long xPos = -1, long yPos = -1, const wxBitmap& bitmap1 = wxNullBitmap,
const wxString& shortHelpString = wxEmptyString, const wxString& longHelpString = wxEmptyString); const wxBitmap& bitmap2 = wxNullBitmap,
#endif bool toggle = FALSE,
~wxToolBarTool (); long xPos = -1,
inline void SetSize( long w, long h ) { m_width = w; m_height = h; } long yPos = -1,
inline long GetWidth () const { return m_width; } const wxString& shortHelpString = wxEmptyString,
inline long GetHeight () const { return m_height; } 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;
long m_y; // as controls have their own client data, no need to waste memory
long m_width; union
long m_height; {
wxObject *m_clientData;
wxControl *m_control;
};
wxCoord m_x;
wxCoord m_y;
wxCoord m_width;
wxCoord m_height;
bool m_toggleState; bool m_toggleState;
bool m_isToggle; bool m_isToggle;
bool m_deleteSecondBitmap;
bool m_enabled; bool m_enabled;
bool m_isMenuCommand;
bool m_deleteSecondBitmap;
wxBitmap m_bitmap1; wxBitmap m_bitmap1;
wxBitmap m_bitmap2; wxBitmap m_bitmap2;
bool m_isMenuCommand;
wxString m_shortHelpString; wxString m_shortHelpString;
wxString m_longHelpString; 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(); ~wxToolBarBase();
// toolbar construction
// --------------------
// 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);
// add an arbitrary control to the toolbar at given index, return TRUE if
// 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; }
virtual void AddSeparator();
virtual void ClearTools();
// must be called after all buttons have been created to finish toolbar
// initialisation
virtual bool Realize() = 0;
// tools state
// -----------
virtual void EnableTool(int toolIndex, bool enable);
// toggle is TRUE if toggled on
virtual void ToggleTool(int toolIndex, bool toggle);
// Set this to be togglable (or not)
virtual void SetToggle(int toolIndex, bool toggle);
virtual wxObject *GetToolClientData(int index) 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;
// 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);
virtual void SetToolSeparation(int separation);
virtual wxSize GetToolMargins() { return wxSize(m_xMargin, m_yMargin); }
virtual int GetToolPacking() { return m_toolPacking; }
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 // Handle wxToolBar events
// -----------------------
// NB: these functions are deprecated, use EVT_TOOL_XXX() instead!
// Only allow toggle if returns TRUE. Call when left button up. // Only allow toggle if returns TRUE. Call when left button up.
virtual bool OnLeftClick(int toolIndex, bool toggleDown); virtual bool OnLeftClick(int toolIndex, bool toggleDown);
@@ -99,54 +243,9 @@ class WXDLLEXPORT wxToolBarBase : public wxControl
// Argument is -1 if mouse is exiting the toolbar. // Argument is -1 if mouse is exiting the toolbar.
virtual void OnMouseEnter(int toolIndex); virtual void OnMouseEnter(int toolIndex);
// If pushedBitmap is NULL, a reversed version of bitmap is // more deprecated functions
// 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 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
#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((int) size.x, (int) size.y); }
virtual void SetToolPacking(int packing);
virtual void SetToolSeparation(int separation);
inline virtual wxSize GetToolMargins() { return wxSize(m_xMargin, m_yMargin); }
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 wxSize GetToolBitmapSize() 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 GetToolSize() const { return wxSize(m_defaultWidth, m_defaultHeight); } ;
// 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; }
@@ -156,7 +255,14 @@ class WXDLLEXPORT wxToolBarBase : public wxControl
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
// implementation only from now on
// -------------------------------
wxList& GetTools() const { return (wxList&) m_tools; }
// Lay the tools out // Lay the tools out
virtual void LayoutTools(); virtual void LayoutTools();
@@ -164,10 +270,6 @@ class WXDLLEXPORT wxToolBarBase : public wxControl
// Add all the buttons: required for Win95. // Add all the buttons: required for Win95.
virtual bool CreateTools() { return TRUE; } virtual bool CreateTools() { return TRUE; }
// Calls the appropriate function after tools have been created.
// E.g. Layout, or CreateTools.
virtual bool Realize() = 0;
void Command(wxCommandEvent& event); void Command(wxCommandEvent& event);
// SCROLLING: this has to be copied from wxScrolledWindow since wxToolBarBase // SCROLLING: this has to be copied from wxScrolledWindow since wxToolBarBase
@@ -201,23 +303,22 @@ class WXDLLEXPORT wxToolBarBase : public wxControl
// Do the toolbar button updates (check for EVT_UPDATE_UI handlers) // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
virtual void DoToolbarUpdates(); virtual void DoToolbarUpdates();
inline void SetMaxRowsCols(int rows, int cols) { m_maxRows = rows; m_maxCols = cols; } // event handlers
inline int GetMaxRows() const { return m_maxRows; }
inline int GetMaxCols() const { return m_maxCols; }
void OnScroll(wxScrollEvent& event); void OnScroll(wxScrollEvent& event);
void OnSize(wxSizeEvent& event); void OnSize(wxSizeEvent& event);
void OnIdle(wxIdleEvent& event); void OnIdle(wxIdleEvent& event);
protected: protected:
wxList m_tools; wxList m_tools;
// int m_tilingDirection;
// int m_rowsOrColumns;
int m_maxRows; int m_maxRows;
int m_maxCols; int m_maxCols;
long m_maxWidth, m_maxHeight; long m_maxWidth,
m_maxHeight;
int m_currentTool; // Tool where mouse currently is int m_currentTool; // Tool where mouse currently is
int m_pressedTool; // Tool where mouse pressed int m_pressedTool; // Tool where mouse pressed
int m_xMargin; int m_xMargin;
int m_yMargin; int m_yMargin;
int m_toolPacking; int m_toolPacking;
@@ -248,8 +349,9 @@ protected:
int m_xScrollLinesPerPage; int m_xScrollLinesPerPage;
int m_yScrollLinesPerPage; int m_yScrollLinesPerPage;
public: 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();

8
src/common/tbarbase.cpp
View File

@@ -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__

491
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,9 +102,15 @@ 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;
@@ -101,31 +126,42 @@ bool wxToolBar95::Create(wxWindow *parent,
long style, long style,
const wxString& name) const wxString& name)
{ {
m_hWnd = 0;
m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
GetGValue(GetSysColor(COLOR_BTNFACE)),
GetBValue(GetSysColor(COLOR_BTNFACE)));
m_foregroundColour = *wxBLACK ;
wxASSERT_MSG( (style & wxTB_VERTICAL) == 0, wxASSERT_MSG( (style & wxTB_VERTICAL) == 0,
wxT("Sorry, wxToolBar95 under Windows 95 only " wxT("Sorry, wxToolBar95 under Windows 95 only "
"supports horizontal orientation.") ); "supports horizontal orientation.") );
m_maxWidth = -1; // common initialisation
m_maxHeight = -1; if ( !CreateControl(parent, id, pos, size, style, name) )
return FALSE;
m_hBitmap = 0; // set up the colors and fonts
#if 0
m_defaultWidth = DEFAULTBITMAPX; wxRGBToColour(m_backgroundColour, GetSysColor(COLOR_BTNFACE));
m_defaultHeight = DEFAULTBITMAPY; m_foregroundColour = *wxBLACK;
SetName(name);
m_windowStyle = style;
SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT)); SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
SetParent(parent); #endif
// prepare flags
DWORD msflags = 0; // WS_VISIBLE | WS_CHILD always included
if (style & wxBORDER)
msflags |= WS_BORDER;
msflags |= TBSTYLE_TOOLTIPS;
if (style & wxTB_FLAT)
{
if (wxTheApp->GetComCtl32Version() > 400)
msflags |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT;
}
// MSW-specific initialisation
if ( !wxControl::MSWCreateControl(TOOLBARCLASSNAME, msflags) )
return FALSE;
// Toolbar-specific initialisation
::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
// position it
int x = pos.x; int x = pos.x;
int y = pos.y; int y = pos.y;
int width = size.x; int width = size.x;
@@ -134,57 +170,13 @@ bool wxToolBar95::Create(wxWindow *parent,
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)
{
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; return TRUE;
} }
@@ -196,50 +188,117 @@ wxToolBar95::~wxToolBar95()
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();
if ( nTools == 0 )
return FALSE; 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,
totalBitmapWidth,
totalBitmapHeight);
::ReleaseDC(NULL, dc); ::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
wxCoord x = 0;
// the number of buttons (not separators)
int noButtons = 0; int noButtons = 0;
wxNode *node = m_tools.First();
while (node) while (node)
{ {
wxToolBarTool *tool = (wxToolBarTool *)node->Data(); wxToolBarTool *tool = (wxToolBarTool *)node->Data();
if ((tool->m_toolStyle != wxTOOL_STYLE_SEPARATOR) && tool->m_bitmap1.Ok() && tool->m_bitmap1.GetHBITMAP()) if ( tool->m_toolStyle == wxTOOL_STYLE_BUTTON && tool->m_bitmap1.Ok() )
{ {
// wxPalette *palette = tool->m_bitmap1->GetPalette(); 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());
/* int bltResult = */
BitBlt(memoryDC, x, 0, (int) m_defaultWidth, (int) m_defaultHeight, memoryDC2,
0, 0, SRCCOPY);
::SelectObject(memoryDC2, oldBitmap2); ::SelectObject(memoryDC2, oldBitmap2);
x += (int)m_defaultWidth;
noButtons ++; x += m_defaultWidth;
noButtons++;
}
} }
node = node->Next(); node = node->Next();
} }
::SelectObject(memoryDC, oldBitmap); ::SelectObject(memoryDC, oldBitmap);
::DeleteDC(memoryDC); ::DeleteDC(memoryDC);
::DeleteDC(memoryDC2); ::DeleteDC(memoryDC2);
@@ -255,7 +314,8 @@ bool wxToolBar95::CreateTools()
replaceBitmap.nIDOld = (UINT) oldToolBarBitmap; replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
replaceBitmap.nIDNew = (UINT) (HBITMAP) m_hBitmap; replaceBitmap.nIDNew = (UINT) (HBITMAP) m_hBitmap;
replaceBitmap.nButtons = noButtons; replaceBitmap.nButtons = noButtons;
if (::SendMessage((HWND) GetHWND(), TB_REPLACEBITMAP, (WPARAM) 0, (LPARAM) &replaceBitmap) == -1) if ( ::SendMessage(GetHwnd(), TB_REPLACEBITMAP,
0, (LPARAM) &replaceBitmap) == -1 )
{ {
wxFAIL_MSG(wxT("Could not add bitmap to toolbar")); wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
} }
@@ -267,7 +327,7 @@ bool wxToolBar95::CreateTools()
while ( TRUE ) while ( TRUE )
{ {
// TODO: What about separators???? They don't have an id! // TODO: What about separators???? They don't have an id!
if ( ! ::SendMessage( (HWND) GetHWND(), TB_DELETEBUTTON, i, 0 ) ) if ( ! ::SendMessage( GetHwnd(), TB_DELETEBUTTON, i, 0 ) )
break; break;
} }
} }
@@ -276,78 +336,140 @@ bool wxToolBar95::CreateTools()
TBADDBITMAP addBitmap; TBADDBITMAP addBitmap;
addBitmap.hInst = 0; addBitmap.hInst = 0;
addBitmap.nID = (UINT)m_hBitmap; addBitmap.nID = (UINT)m_hBitmap;
if (::SendMessage((HWND) GetHWND(), TB_ADDBITMAP, (WPARAM) noButtons, (LPARAM) &addBitmap) == -1) if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,
(WPARAM) noButtons, (LPARAM)&addBitmap) == -1 )
{ {
wxFAIL_MSG(wxT("Could not add bitmap to toolbar")); wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
} }
} }
// Now add the buttons. // Now add the buttons.
TBBUTTON buttons[50]; TBBUTTON *buttons = new TBBUTTON[nTools];
// this array will holds the indices of all controls in the toolbar
wxArrayInt controlIds;
node = m_tools.First();
int i = 0; int i = 0;
int bitmapId = 0; int bitmapId = 0;
node = m_tools.First();
while (node) while (node)
{ {
wxToolBarTool *tool = (wxToolBarTool *)node->Data(); wxToolBarTool *tool = (wxToolBarTool *)node->Data();
if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR) TBBUTTON& button = buttons[i];
{
buttons[i].iBitmap = 0;
buttons[i].idCommand = 0;
buttons[i].fsState = TBSTATE_ENABLED; wxZeroMemory(button);
buttons[i].fsStyle = TBSTYLE_SEP;
buttons[i].dwData = 0L; switch ( tool->m_toolStyle )
buttons[i].iString = 0; {
} case wxTOOL_STYLE_CONTROL:
else controlIds.Add(i);
{ button.idCommand = tool->m_index;
buttons[i].iBitmap = bitmapId; // fall through: create just a separator too
buttons[i].idCommand = tool->m_index;
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;
buttons[i].fsState = 0;
if (tool->m_enabled) if (tool->m_enabled)
buttons[i].fsState |= TBSTATE_ENABLED; button.fsState |= TBSTATE_ENABLED;
if (tool->m_toggleState) if (tool->m_toggleState)
buttons[i].fsState |= TBSTATE_CHECKED; button.fsState |= TBSTATE_CHECKED;
buttons[i].fsStyle = tool->m_isToggle ? TBSTYLE_CHECK : TBSTYLE_BUTTON; button.fsStyle = tool->m_isToggle ? TBSTYLE_CHECK
buttons[i].dwData = 0L; : TBSTYLE_BUTTON;
buttons[i].iString = 0;
bitmapId ++; bitmapId++;
break;
} }
i ++; i++;
node = node->Next(); node = node->Next();
} }
long rc = ::SendMessage((HWND) GetHWND(), TB_ADDBUTTONS, (WPARAM)i, (LPARAM)& buttons); if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS,
(WPARAM)i, (LPARAM)buttons) )
{
wxLogLastError("TB_ADDBUTTONS");
}
wxCHECK_MSG( rc, FALSE, wxT("failed to add buttons to the toolbar") ); delete [] buttons;
(void)::SendMessage((HWND) GetHWND(), TB_AUTOSIZE, (WPARAM)0, (LPARAM) 0); // 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); SetRows(m_maxRows);
return TRUE; 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(); wxToolBarTool *tool = (wxToolBarTool *)node->Data();
if (tool->m_isToggle) if (tool->m_isToggle)
tool->m_toggleState = (1 == (1 & (int)::SendMessage((HWND) GetHWND(), TB_GETSTATE, (WPARAM) id, (LPARAM) 0))); {
LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
tool->m_toggleState = state & TBSTATE_CHECKED;
}
BOOL ret = OnLeftClick((int)id, tool->m_toggleState); BOOL ret = OnLeftClick((int)id, tool->m_toggleState);
if (ret == FALSE && tool->m_isToggle) if ( ret == FALSE && tool->m_isToggle )
{ {
tool->m_toggleState = !tool->m_toggleState; tool->m_toggleState = !tool->m_toggleState;
::SendMessage((HWND) GetHWND(), TB_CHECKBUTTON, (WPARAM)id, (LPARAM)MAKELONG(tool->m_toggleState, 0)); ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
(WPARAM)id, (LPARAM)MAKELONG(tool->m_toggleState, 0));
} }
return TRUE; return TRUE;
} }
@@ -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,39 +541,52 @@ 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)
{ {
// TRUE in wParam means to create at least as many rows
RECT rect; RECT rect;
::SendMessage((HWND) GetHWND(), TB_SETROWS, MAKEWPARAM(nRows, TRUE), (LPARAM) & rect); ::SendMessage(GetHwnd(), TB_SETROWS,
MAKEWPARAM(nRows, TRUE), (LPARAM) &rect);
m_maxWidth = (rect.right - rect.left + 2); m_maxWidth = (rect.right - rect.left + 2);
m_maxHeight = (rect.bottom - rect.top + 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
{ {
// FIXME: this is completely bogus (VZ)
return wxSize(m_defaultWidth + 8, m_defaultHeight + 7); 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);
@@ -459,7 +594,8 @@ void wxToolBar95::EnableTool(int toolIndex, bool enable)
{ {
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));
} }
} }
@@ -472,48 +608,20 @@ void wxToolBar95::ToggleTool(int toolIndex, bool toggle)
if (tool->m_isToggle) if (tool->m_isToggle)
{ {
tool->m_toggleState = toggle; tool->m_toggleState = toggle;
::SendMessage((HWND) GetHWND(), TB_CHECKBUTTON, (WPARAM)toolIndex, (LPARAM)MAKELONG(toggle, 0)); ::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)