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
// "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

70
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
// Author: Julian Smart
// Modified by:
@@ -17,76 +17,78 @@
#endif
#if wxUSE_TOOLBAR
#include "wx/tbarbase.h"
WXDLLEXPORT_DATA(extern const wxChar*) wxToolBarNameStr;
#include "wx/tbarbase.h"
class WXDLLEXPORT wxToolBar95 : public wxToolBarBase
{
DECLARE_DYNAMIC_CLASS(wxToolBar95)
public:
/*
* Public interface
*/
wxToolBar95() { Init(); }
wxToolBar95();
wxToolBar95(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
wxToolBar95(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxNO_BORDER | wxTB_HORIZONTAL,
const wxString& name = wxToolBarNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
~wxToolBar95();
bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxNO_BORDER | wxTB_HORIZONTAL,
const wxString& name = wxToolBarNameStr);
// Call default behaviour
void OnMouseEvent(wxMouseEvent& event);
// override base class virtuals
// 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
// 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 = "");
virtual void ClearTools();
// Set default bitmap size
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();
virtual bool Realize() { return CreateTools(); };
// The button size is bigger than the bitmap size
wxSize GetToolSize() const;
virtual void EnableTool(int toolIndex, bool enable);
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;
// Add all the buttons: required for Win95.
virtual bool CreateTools();
virtual void SetRows(int nRows);
virtual void LayoutButtons() {}
// The post-tool-addition call
bool Realize() { return CreateTools(); };
// IMPLEMENTATION
virtual bool MSWCommand(WXUINT param, WXWORD id);
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
// Responds to colour changes
void OnMouseEvent(wxMouseEvent& event);
void OnSysColourChanged(wxSysColourChangedEvent& event);
protected:
// common part of all ctors
void Init();
WXHBITMAP m_hBitmap;
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxToolBar95)
};
#endif // wxUSE_TOOLBAR

278
include/wx/tbarbase.h
View File

@@ -12,82 +12,226 @@
#ifndef _WX_TBARBASE_H_
#define _WX_TBARBASE_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma interface "tbarbase.h"
#endif
#include "wx/setup.h"
#include "wx/defs.h"
#include "wx/bitmap.h"
#include "wx/list.h"
#include "wx/control.h"
class WXDLLEXPORT wxToolBar;
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const wxChar*) wxToolBarNameStr;
WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
#define wxTOOL_STYLE_BUTTON 1
#define wxTOOL_STYLE_SEPARATOR 2
enum
{
wxTOOL_STYLE_BUTTON = 1,
wxTOOL_STYLE_SEPARATOR = 2,
wxTOOL_STYLE_CONTROL
};
#ifdef __WXGTK__
class WXDLLEXPORT wxToolBar;
#endif
// ----------------------------------------------------------------------------
// wxToolBarTool is one button/separator/whatever in the toolbar
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxToolBarTool : public wxObject
{
DECLARE_DYNAMIC_CLASS(wxToolBarTool)
public:
// ctors & dtor
// ------------
wxToolBarTool() { }
#ifdef __WXGTK__
wxToolBarTool(wxToolBar *owner,
int theIndex = 0, const wxBitmap& bitmap1 = wxNullBitmap, const wxBitmap& bitmap2 = wxNullBitmap,
bool toggle = FALSE, wxObject *clientData = (wxObject *) NULL,
const wxString& shortHelpString = "", const wxString& longHelpString = "",
int theIndex = 0,
const wxBitmap& bitmap1 = wxNullBitmap,
const wxBitmap& bitmap2 = wxNullBitmap,
bool toggle = FALSE,
wxObject *clientData = (wxObject *) NULL,
const wxString& shortHelpString = wxEmptyString,
const wxString& longHelpString = wxEmptyString,
GtkWidget *pixmap = (GtkWidget *) NULL );
#else
wxToolBarTool(int theIndex, const wxBitmap& bitmap1 = wxNullBitmap, const wxBitmap& bitmap2 = wxNullBitmap,
bool toggle = FALSE, long xPos = -1, long yPos = -1,
const wxString& shortHelpString = wxEmptyString, const wxString& longHelpString = wxEmptyString);
#endif
#else // !GTK
wxToolBarTool(int theIndex,
const wxBitmap& bitmap1 = wxNullBitmap,
const wxBitmap& bitmap2 = wxNullBitmap,
bool toggle = FALSE,
long xPos = -1,
long yPos = -1,
const wxString& shortHelpString = wxEmptyString,
const wxString& longHelpString = wxEmptyString);
#endif // GTK/!GTK
wxToolBarTool(wxControl *control);
~wxToolBarTool();
inline void SetSize( long w, long h ) { m_width = w; m_height = h; }
inline long GetWidth () const { return m_width; }
inline long GetHeight () const { return m_height; }
// 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:
int m_toolStyle;
wxObject * m_clientData;
int m_index;
long m_x;
long m_y;
long m_width;
long m_height;
// as controls have their own client data, no need to waste memory
union
{
wxObject *m_clientData;
wxControl *m_control;
};
wxCoord m_x;
wxCoord m_y;
wxCoord m_width;
wxCoord m_height;
bool m_toggleState;
bool m_isToggle;
bool m_deleteSecondBitmap;
bool m_enabled;
bool m_isMenuCommand;
bool m_deleteSecondBitmap;
wxBitmap m_bitmap1;
wxBitmap m_bitmap2;
bool m_isMenuCommand;
wxString m_shortHelpString;
wxString m_longHelpString;
#ifdef __WXGTK__
wxToolBar *m_owner;
GtkWidget *m_item;
GtkWidget *m_pixmap;
#endif
#endif // GTK
private:
DECLARE_DYNAMIC_CLASS(wxToolBarTool)
};
// ----------------------------------------------------------------------------
// the base class for all toolbars
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxToolBarBase : public wxControl
{
DECLARE_ABSTRACT_CLASS(wxToolBarBase)
public:
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
// -----------------------
// 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);
@@ -99,54 +243,9 @@ class WXDLLEXPORT wxToolBarBase : public wxControl
// Argument is -1 if mouse is exiting the toolbar.
virtual void OnMouseEnter(int toolIndex);
// If pushedBitmap is NULL, a reversed version of bitmap is
// created and used as the pushed/toggled image.
// If toggle is TRUE, the button toggles between the two states.
virtual wxToolBarTool *AddTool(int toolIndex, const wxBitmap& bitmap, const wxBitmap& pushedBitmap = wxNullBitmap,
bool toggle = FALSE, long xPos = -1, long yPos = -1, wxObject *clientData = NULL,
const wxString& helpString1 = wxEmptyString, const wxString& helpString2 = wxEmptyString);
virtual void AddSeparator();
virtual void ClearTools();
// more deprecated functions
// -------------------------
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
void SetDefaultSize(int w, int h) { SetDefaultSize(wxSize(w, h)); }
long GetDefaultWidth() const { return m_defaultWidth; }
@@ -156,7 +255,14 @@ class WXDLLEXPORT wxToolBarBase : public wxControl
virtual void SetDefaultSize(const wxSize& size) { SetToolBitmapSize(size); }
virtual wxSize GetDefaultSize() const { return GetToolBitmapSize(); }
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
virtual void LayoutTools();
@@ -164,10 +270,6 @@ class WXDLLEXPORT wxToolBarBase : public wxControl
// Add all the buttons: required for Win95.
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);
// 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)
virtual void DoToolbarUpdates();
inline void SetMaxRowsCols(int rows, int cols) { m_maxRows = rows; m_maxCols = cols; }
inline int GetMaxRows() const { return m_maxRows; }
inline int GetMaxCols() const { return m_maxCols; }
// event handlers
void OnScroll(wxScrollEvent& 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;
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;
@@ -248,8 +349,9 @@ protected:
int m_xScrollLinesPerPage;
int m_yScrollLinesPerPage;
public:
private:
DECLARE_EVENT_TABLE()
DECLARE_ABSTRACT_CLASS(wxToolBarBase)
};
#endif

23
samples/toolbar/test.cpp
View File

@@ -85,6 +85,8 @@ public:
void OnToolLeftClick(wxCommandEvent& event);
void OnToolEnter(wxCommandEvent& event);
void OnCombo(wxCommandEvent& event);
private:
void DoEnablePrint();
void DoToggleHelp();
@@ -105,7 +107,9 @@ enum
{
IDM_TOOLBAR_TOGGLETOOLBAR = 200,
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_COMBOBOX(ID_COMBO, MyFrame::OnCombo)
EVT_TOOL_ENTER(ID_TOOLBAR, MyFrame::OnToolEnter)
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");
currentX += width + 5;
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 )
{
toolBar->AddSeparator();
currentX += width + 5;
toolBar->AddTool(wxID_SAVE, *(toolBarBitmaps[2]), wxNullBitmap, TRUE, currentX, -1, (wxObject *) NULL, "Toggle button 1");
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()
{
wxToolBar *tb = GetToolBar();

8
src/common/tbarbase.cpp
View File

@@ -92,6 +92,12 @@ wxToolBarTool::wxToolBarTool(int theIndex,
m_longHelpString = helpS2;
}
wxToolBarTool::wxToolBarTool(int index, wxControl *control)
{
m_toolStyle = wxTOOL_STYLE_CONTROL;
m_control = control;
}
wxToolBarTool::~wxToolBarTool()
{
/*
@@ -186,7 +192,7 @@ void wxToolBarBase::OnMouseEnter ( int toolIndex )
// created and used as the pushed/toggled image.
// If toggle is TRUE, the button toggles between the two states.
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)
{
#ifdef __WXGTK__

459
src/msw/tbar95.cpp
View File

@@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////////
// Name: tbar95.cpp
// Name: msw/tbar95.cpp
// Purpose: wxToolBar95
// Author: Julian Smart
// Modified by:
@@ -9,6 +9,14 @@
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "tbar95.h"
#endif
@@ -21,7 +29,9 @@
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#include "wx/log.h"
#include "wx/intl.h"
#include "wx/dynarray.h"
#endif
#if wxUSE_BUTTONBAR && wxUSE_TOOLBAR && defined(__WIN95__)
@@ -30,24 +40,27 @@
#include "malloc.h"
#endif
#include <windows.h>
#include "wx/msw/private.h"
#if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__) || defined(wxUSE_NORLANDER_HEADERS)
#ifndef __TWIN32__
#ifdef __GNUWIN32_OLD__
#include "wx/msw/gnuwin32/extra.h"
#else
#include <commctrl.h>
#endif
#ifndef __TWIN32__
#ifdef __GNUWIN32__
#ifndef wxUSE_NORLANDER_HEADERS
#include "wx/msw/gnuwin32/extra.h"
#endif
#endif
#endif
#endif // __TWIN32__
#include "wx/msw/dib.h"
#include "wx/tbar95.h"
#include "wx/app.h"
#include "wx/msw/private.h"
#include "wx/app.h" // for GetComCtl32Version
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// these standard constants are not always defined in compilers headers
// Styles
#ifndef TBSTYLE_FLAT
@@ -63,17 +76,23 @@
#define TB_SETSTYLE (WM_USER + 56)
#endif
/* Hint from a newsgroup for custom flatbar drawing:
Set the TBSTYLE_CUSTOMERASE style, then handle the
NM_CUSTOMDRAW message and do your custom drawing.
*/
// these values correspond to those used by comctl32.dll
#define DEFAULTBITMAPX 16
#define DEFAULTBITMAPY 15
#define DEFAULTBUTTONX 24
#define DEFAULTBUTTONY 24
#define DEFAULTBARHEIGHT 27
// ----------------------------------------------------------------------------
// function prototypes
// ----------------------------------------------------------------------------
static void wxMapBitmap(HBITMAP hBitmap, int width, int height);
// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase)
#endif
@@ -83,9 +102,15 @@ BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase)
EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged)
END_EVENT_TABLE()
static void wxMapBitmap(HBITMAP hBitmap, int width, int height);
// ============================================================================
// implementation
// ============================================================================
wxToolBar95::wxToolBar95()
// ----------------------------------------------------------------------------
// wxToolBar95 construction
// ----------------------------------------------------------------------------
void wxToolBar95::Init()
{
m_maxWidth = -1;
m_maxHeight = -1;
@@ -101,31 +126,42 @@ bool wxToolBar95::Create(wxWindow *parent,
long style,
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,
wxT("Sorry, wxToolBar95 under Windows 95 only "
"supports horizontal orientation.") );
m_maxWidth = -1;
m_maxHeight = -1;
// common initialisation
if ( !CreateControl(parent, id, pos, size, style, name) )
return FALSE;
m_hBitmap = 0;
m_defaultWidth = DEFAULTBITMAPX;
m_defaultHeight = DEFAULTBITMAPY;
SetName(name);
m_windowStyle = style;
// set up the colors and fonts
#if 0
wxRGBToColour(m_backgroundColour, GetSysColor(COLOR_BTNFACE));
m_foregroundColour = *wxBLACK;
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 y = pos.y;
int width = size.x;
@@ -134,57 +170,13 @@ bool wxToolBar95::Create(wxWindow *parent,
if (width <= 0)
width = 100;
if (height <= 0)
height = 30;
height = m_defaultHeight;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
m_windowId = (id < 0 ? NewControlId() : id);
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);
SetSize(x, y, width, height);
return TRUE;
}
@@ -196,23 +188,78 @@ wxToolBar95::~wxToolBar95()
if (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()
{
if (m_tools.Number() == 0)
size_t nTools = m_tools.GetCount();
if ( nTools == 0 )
return FALSE;
HBITMAP oldToolBarBitmap = (HBITMAP) m_hBitmap;
int totalBitmapWidth = (int)(m_defaultWidth * m_tools.Number());
int totalBitmapWidth = (int)(m_defaultWidth * nTools);
int totalBitmapHeight = (int)m_defaultHeight;
// Create a bitmap for all the tool bitmaps
HDC dc = ::GetDC(NULL);
m_hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap(dc, totalBitmapWidth, totalBitmapHeight);
m_hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap(dc,
totalBitmapWidth,
totalBitmapHeight);
::ReleaseDC(NULL, dc);
// Now blit all the tools onto this bitmap
@@ -220,26 +267,38 @@ bool wxToolBar95::CreateTools()
HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, (HBITMAP)m_hBitmap);
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;
wxNode *node = m_tools.First();
while (node)
{
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);
x += (int)m_defaultWidth;
x += m_defaultWidth;
noButtons++;
}
}
node = node->Next();
}
::SelectObject(memoryDC, oldBitmap);
::DeleteDC(memoryDC);
::DeleteDC(memoryDC2);
@@ -255,7 +314,8 @@ bool wxToolBar95::CreateTools()
replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
replaceBitmap.nIDNew = (UINT) (HBITMAP) m_hBitmap;
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"));
}
@@ -267,7 +327,7 @@ bool wxToolBar95::CreateTools()
while ( TRUE )
{
// 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;
}
}
@@ -276,78 +336,140 @@ bool wxToolBar95::CreateTools()
TBADDBITMAP addBitmap;
addBitmap.hInst = 0;
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"));
}
}
// 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 bitmapId = 0;
node = m_tools.First();
while (node)
{
wxToolBarTool *tool = (wxToolBarTool *)node->Data();
if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR)
{
buttons[i].iBitmap = 0;
buttons[i].idCommand = 0;
TBBUTTON& button = buttons[i];
buttons[i].fsState = TBSTATE_ENABLED;
buttons[i].fsStyle = TBSTYLE_SEP;
buttons[i].dwData = 0L;
buttons[i].iString = 0;
}
else
{
buttons[i].iBitmap = bitmapId;
buttons[i].idCommand = tool->m_index;
wxZeroMemory(button);
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;
buttons[i].fsState = 0;
if (tool->m_enabled)
buttons[i].fsState |= TBSTATE_ENABLED;
button.fsState |= TBSTATE_ENABLED;
if (tool->m_toggleState)
buttons[i].fsState |= TBSTATE_CHECKED;
buttons[i].fsStyle = tool->m_isToggle ? TBSTYLE_CHECK : TBSTYLE_BUTTON;
buttons[i].dwData = 0L;
buttons[i].iString = 0;
button.fsState |= TBSTATE_CHECKED;
button.fsStyle = tool->m_isToggle ? TBSTYLE_CHECK
: TBSTYLE_BUTTON;
bitmapId++;
break;
}
i++;
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);
return TRUE;
}
// ----------------------------------------------------------------------------
// message handlers
// ----------------------------------------------------------------------------
bool wxToolBar95::MSWCommand(WXUINT cmd, WXWORD id)
{
wxNode *node = m_tools.Find((long)id);
if (!node)
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)));
{
LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
tool->m_toggleState = state & TBSTATE_CHECKED;
}
BOOL ret = OnLeftClick((int)id, tool->m_toggleState);
if ( ret == FALSE && tool->m_isToggle )
{
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;
}
@@ -358,8 +480,8 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl),
// First check if this applies to us
NMHDR *hdr = (NMHDR *)lParam;
// the tooltips control created by the toolbar is sometimes Unicode, even in
// an ANSI application
// the tooltips control created by the toolbar is sometimes Unicode, even
// in an ANSI application - this seems to be a bug in comctl32.dll v5
int code = (int)hdr->code;
if ( (code != TTN_NEEDTEXTA) && (code != TTN_NEEDTEXTW) )
return FALSE;
@@ -419,39 +541,52 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl),
return TRUE;
}
// ----------------------------------------------------------------------------
// sizing stuff
// ----------------------------------------------------------------------------
void wxToolBar95::SetToolBitmapSize(const wxSize& size)
{
m_defaultWidth = size.x;
m_defaultHeight = size.y;
::SendMessage((HWND) GetHWND(), TB_SETBITMAPSIZE, 0, (LPARAM) MAKELONG ((int)size.x, (int)size.y));
wxToolBarBase::SetToolBitmapSize(size);
::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
}
void wxToolBar95::SetRows(int nRows)
{
// TRUE in wParam means to create at least as many rows
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_maxHeight = (rect.bottom - rect.top + 2);
m_maxRows = nRows;
}
wxSize wxToolBar95::GetMaxSize() const
{
if ( (m_maxWidth == -1) || (m_maxHeight == -1) )
{
RECT rect;
::SendMessage((HWND) GetHWND(), TB_SETROWS, MAKEWPARAM(m_maxRows, TRUE), (LPARAM) & rect);
((wxToolBar95 *)this)->m_maxWidth = (rect.right - rect.left + 2); // ???
((wxToolBar95 *)this)->m_maxHeight = (rect.bottom - rect.top + 2); // ???
// it has a side effect of filling m_maxWidth/Height variables
((wxToolBar95 *)this)->SetRows(m_maxRows); // const_cast
}
return wxSize(m_maxWidth, m_maxHeight);
}
// The button size is bigger than the bitmap size
wxSize wxToolBar95::GetToolSize() const
{
// FIXME: this is completely bogus (VZ)
return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
}
// ----------------------------------------------------------------------------
// tool state
// ----------------------------------------------------------------------------
void wxToolBar95::EnableTool(int toolIndex, bool enable)
{
wxNode *node = m_tools.Find((long)toolIndex);
@@ -459,7 +594,8 @@ void wxToolBar95::EnableTool(int toolIndex, bool enable)
{
wxToolBarTool *tool = (wxToolBarTool *)node->Data();
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)
{
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
{
return (::SendMessage((HWND) GetHWND(), TB_ISBUTTONCHECKED, (WPARAM)toolIndex, (LPARAM)0) != 0);
return (::SendMessage(GetHwnd(), TB_ISBUTTONCHECKED, (WPARAM)toolIndex, (LPARAM)0) != 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();
}
// 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;
}
// ----------------------------------------------------------------------------
// event handlers
// ----------------------------------------------------------------------------
// Responds to colour changes, and passes event on to children.
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
// 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_BUTTONSHADOW (RGB(128,128,128)) // dark 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)
{
COLORMAP ColorMap[] = {
COLORMAP ColorMap[] =
{
{BGR_BUTTONTEXT, COLOR_BTNTEXT}, // black
{BGR_BUTTONSHADOW, COLOR_BTNSHADOW}, // dark grey
{BGR_BUTTONFACE, COLOR_BTNFACE}, // bright grey
@@ -640,4 +755,4 @@ void wxMapBitmap(HBITMAP hBitmap, int width, int height)
#endif
#endif
#endif // !(wxUSE_TOOLBAR && Win95)