/////////////////////////////////////////////////////////////////////////////
-// Name: toolbar.cpp
+// Name: motif/toolbar.cpp
// Purpose: wxToolBar
// Author: Julian Smart
-// Modified by:
+// Modified by: 13.12.99 by VZ during toolbar classes reorganization
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
-// Licence: wxWindows licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
#ifdef __GNUG__
-#pragma implementation "toolbar.h"
+ #pragma implementation "toolbar.h"
#endif
-#include "wx/wx.h"
+#ifdef __VMS
+#define XtDisplay XTDISPLAY
+#endif
+
+#include "wx/settings.h"
#include "wx/app.h"
#include "wx/timer.h"
#include "wx/toolbar.h"
+#include "wx/frame.h"
+#ifdef __VMS__
+#pragma message disable nosimpint
+#endif
#include <Xm/Xm.h>
#include <Xm/PushBG.h>
#include <Xm/PushB.h>
#include <Xm/ToggleB.h>
#include <Xm/ToggleBG.h>
#include <Xm/Form.h>
+#ifdef __VMS__
+#pragma message enable nosimpint
+#endif
#include "wx/motif/private.h"
+#include "wx/motif/bmpmotif.h"
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
+// ----------------------------------------------------------------------------
+// wxWin macros
+// ----------------------------------------------------------------------------
-BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
-END_EVENT_TABLE()
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
#endif
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
static void wxToolButtonCallback (Widget w, XtPointer clientData,
XtPointer ptr);
static void wxToolButtonPopupCallback (Widget w, XtPointer client_data,
XEvent *event, Boolean *continue_to_dispatch);
-class wxToolBarTimer: public wxTimer
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+class wxToolBarTimer : public wxTimer
{
public:
- wxToolBarTimer() { }
- virtual void Notify();
+ virtual void Notify();
+
+ static Widget help_popup;
+ static Widget buttonWidget;
+ static wxString helpString;
+};
+
+class wxToolBarTool : public wxToolBarToolBase
+{
+public:
+ wxToolBarTool(wxToolBar *tbar,
+ int id,
+ const wxString& label,
+ const wxBitmap& bmpNormal,
+ const wxBitmap& bmpToggled,
+ wxItemKind kind,
+ wxObject *clientData,
+ const wxString& shortHelp,
+ const wxString& longHelp)
+ : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpToggled, kind,
+ clientData, shortHelp, longHelp)
+ {
+ Init();
+ }
+
+ wxToolBarTool(wxToolBar *tbar, wxControl *control)
+ : wxToolBarToolBase(tbar, control)
+ {
+ Init();
+ }
- static Widget help_popup;
- static Widget buttonWidget;
- static wxString helpString;
+ virtual ~wxToolBarTool();
+
+ // accessors
+ void SetWidget(Widget widget) { m_widget = widget; }
+ Widget GetButtonWidget() const { return m_widget; }
+
+ Pixmap GetArmPixmap()
+ {
+ m_bitmapCache.SetBitmap( GetNormalBitmap() );
+ return (Pixmap)m_bitmapCache.GetArmPixmap( (WXWidget)m_widget );
+ }
+
+ Pixmap GetInsensPixmap()
+ {
+ m_bitmapCache.SetBitmap( GetNormalBitmap() );
+ return (Pixmap)m_bitmapCache.GetInsensPixmap( (WXWidget)m_widget );
+ }
+protected:
+ void Init();
+
+ Widget m_widget;
+ wxBitmapCache m_bitmapCache;
};
+// ----------------------------------------------------------------------------
+// globals
+// ----------------------------------------------------------------------------
+
static wxToolBarTimer* wxTheToolBarTimer = (wxToolBarTimer*) NULL;
Widget wxToolBarTimer::help_popup = (Widget) 0;
Widget wxToolBarTimer::buttonWidget = (Widget) 0;
-wxString wxToolBarTimer::helpString = "";
+wxString wxToolBarTimer::helpString;
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxToolBarTool
+// ----------------------------------------------------------------------------
+
+wxToolBarToolBase *wxToolBar::CreateTool(int id,
+ const wxString& label,
+ const wxBitmap& bmpNormal,
+ const wxBitmap& bmpToggled,
+ wxItemKind kind,
+ wxObject *clientData,
+ const wxString& shortHelp,
+ const wxString& longHelp)
+{
+ return new wxToolBarTool(this, id, label, bmpNormal, bmpToggled, kind,
+ clientData, shortHelp, longHelp);
+}
+
+
+wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
+{
+ return new wxToolBarTool(this, control);
+}
-wxToolBar::wxToolBar():
- m_widgets(wxKEY_INTEGER)
+void wxToolBarTool::Init()
{
- m_maxWidth = -1;
- m_maxHeight = -1;
- m_defaultWidth = 24;
- m_defaultHeight = 22;
+ m_widget = (Widget)0;
}
-bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
- long style, const wxString& name)
+wxToolBarTool::~wxToolBarTool()
+{
+ if ( m_widget )
+ XtDestroyWidget(m_widget);
+}
+
+// ----------------------------------------------------------------------------
+// wxToolBar construction
+// ----------------------------------------------------------------------------
+
+void wxToolBar::Init()
{
m_maxWidth = -1;
m_maxHeight = -1;
-
m_defaultWidth = 24;
m_defaultHeight = 22;
- SetName(name);
- m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
- m_foregroundColour = parent->GetForegroundColour();
- m_windowStyle = style;
+ m_toolPacking = 2;
+ m_toolSeparation = 8;
+ m_xMargin = 2;
+ m_yMargin = 2;
+ m_maxRows = 100;
+ m_maxCols = 100;
+}
- SetParent(parent);
+bool wxToolBar::Create(wxWindow *parent,
+ wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
+{
+ if( !wxControl::CreateControl( parent, id, pos, size, style,
+ wxDefaultValidator, name ) )
+ return FALSE;
- if (parent) parent->AddChild(this);
+ m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
Widget parentWidget = (Widget) parent->GetClientWidget();
m_mainWidget = (WXWidget) toolbar;
- m_font = parent->GetFont();
ChangeFont(FALSE);
- SetCanAddEventHandler(TRUE);
- AttachWidget (parent, m_mainWidget, (WXWidget) NULL, pos.x, pos.y, size.x, size.y);
+ wxPoint rPos = pos;
+ wxSize rSize = size;
+
+ if( rPos.x == -1 ) rPos.x = 0;
+ if( rPos.y == -1 ) rPos.y = 0;
+ if( rSize.x == -1 && GetParent() )
+ rSize.x = GetParent()->GetSize().x;
+
+ AttachWidget (parent, m_mainWidget, (WXWidget) NULL,
+ rPos.x, rPos.y, rSize.x, rSize.y);
ChangeBackgroundColour();
{
delete wxTheToolBarTimer;
wxTheToolBarTimer = NULL;
- ClearTools();
- DestroyPixmaps();
}
-bool wxToolBar::CreateTools()
+bool wxToolBar::Realize()
{
- if (m_tools.Number() == 0)
- return FALSE;
+ if ( m_tools.GetCount() == 0 )
+ {
+ // nothing to do
+ return TRUE;
+ }
+
+ bool isVertical = GetWindowStyle() & wxTB_VERTICAL;
// Separator spacing
const int separatorSize = GetToolSeparation(); // 8;
wxSize margins = GetToolMargins();
+ int packing = GetToolPacking();
int marginX = margins.x;
int marginY = margins.y;
int currentX = marginX;
int currentY = marginY;
- int buttonHeight = 0;
+ int buttonHeight = 0, buttonWidth = 0;
int currentSpacing = 0;
- m_widgets.Clear();
- Widget prevButton = (Widget) 0;
- wxNode* node = m_tools.First();
- while (node)
+ Widget button;
+ Pixmap pixmap, insensPixmap;
+ wxBitmap bmp, insensBmp;
+
+ wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
+ while ( node )
{
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
+ wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
- if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR)
- currentX += separatorSize;
- else if (tool->m_bitmap1.Ok())
+ switch ( tool->GetStyle() )
{
- Widget button = (Widget) 0;
-
- if (tool->m_isToggle)
- {
- button = XtVaCreateWidget("toggleButton",
- xmToggleButtonWidgetClass, (Widget) m_mainWidget,
- XmNx, currentX, XmNy, currentY,
- // XmNpushButtonEnabled, True,
- XmNmultiClick, XmMULTICLICK_KEEP,
- XmNlabelType, XmPIXMAP,
- NULL);
- XtAddCallback ((Widget) button, XmNvalueChangedCallback, (XtCallbackProc) wxToolButtonCallback,
- (XtPointer) this);
-
- XtVaSetValues ((Widget) button,
- XmNselectColor, m_backgroundColour.AllocColour(XtDisplay((Widget) button)),
- NULL);
- }
- else
- {
- button = XtVaCreateWidget("button",
- xmPushButtonWidgetClass, (Widget) m_mainWidget,
- XmNx, currentX, XmNy, currentY,
- XmNpushButtonEnabled, True,
- XmNmultiClick, XmMULTICLICK_KEEP,
- XmNlabelType, XmPIXMAP,
- NULL);
- XtAddCallback (button,
- XmNactivateCallback, (XtCallbackProc) wxToolButtonCallback,
- (XtPointer) this);
- }
-
- DoChangeBackgroundColour((WXWidget) button, m_backgroundColour, TRUE);
-
- // For each button, if there is a mask, we must create
- // a new wxBitmap that has the correct background colour
- // for the button. Otherwise the background will just be
- // e.g. black if a transparent XPM has been loaded.
- wxBitmap originalBitmap = tool->m_bitmap1;
-
- if (tool->m_bitmap1.GetMask())
+ case wxTOOL_STYLE_CONTROL:
{
- int backgroundPixel;
- XtVaGetValues(button, XmNbackground, &backgroundPixel,
- NULL);
-
-
- wxColour col;
- col.SetPixel(backgroundPixel);
-
- wxBitmap newBitmap = wxCreateMaskedBitmap(tool->m_bitmap1, col);
-
- tool->m_bitmap1 = newBitmap;
- }
-
- // Create a selected/toggled bitmap. If there isn't a m_bitmap2,
- // we need to create it (with a darker, selected background)
- int backgroundPixel;
- if (tool->m_isToggle)
- XtVaGetValues(button, XmNselectColor, &backgroundPixel,
- NULL);
- else
- XtVaGetValues(button, XmNarmColor, &backgroundPixel,
- NULL);
-
- wxColour col;
- col.SetPixel(backgroundPixel);
+ wxControl* control = tool->GetControl();
+ wxSize sz = control->GetSize();
+ wxPoint pos = control->GetPosition();
+ // Allow a control to specify a y[x]-offset by setting
+ // its initial position, but still don't allow it to
+ // position itself above the top[left] margin.
+ int controlY = (pos.y > 0) ? pos.y : currentY;
+ int controlX = (pos.x > 0) ? pos.x : currentX;
+ control->Move( isVertical ? controlX : currentX,
+ isVertical ? currentY : controlY );
+ if ( isVertical )
+ currentY += sz.y + packing;
+ else
+ currentX += sz.x + packing;
- if (tool->m_bitmap2.Ok() && tool->m_bitmap2.GetMask())
- {
- // Use what's there
- wxBitmap newBitmap = wxCreateMaskedBitmap(tool->m_bitmap2, col);
- tool->m_bitmap2 = newBitmap;
+ break;
}
- else
- {
- // Use unselected bitmap
- if (originalBitmap.GetMask())
+ case wxTOOL_STYLE_SEPARATOR:
+ // skip separators for vertical toolbars
+ if( !isVertical )
{
- wxBitmap newBitmap = wxCreateMaskedBitmap(originalBitmap, col);
- tool->m_bitmap2 = newBitmap;
+ currentX += separatorSize;
}
- else
- tool->m_bitmap2 = tool->m_bitmap1;
- }
+ break;
- Pixmap pixmap = (Pixmap) tool->m_bitmap1.GetPixmap();
- Pixmap insensPixmap = (Pixmap) tool->m_bitmap1.GetInsensPixmap();
+ case wxTOOL_STYLE_BUTTON:
+ button = (Widget) 0;
- if (tool->m_isToggle)
- {
- // Toggle button
- Pixmap pixmap2 = (Pixmap) 0;
- Pixmap insensPixmap2 = (Pixmap) 0;
+ if ( tool->CanBeToggled() && !tool->GetButtonWidget() )
+ {
+ button = XtVaCreateWidget("toggleButton",
+ xmToggleButtonWidgetClass, (Widget) m_mainWidget,
+ XmNx, currentX, XmNy, currentY,
+ XmNindicatorOn, False,
+ XmNshadowThickness, 2,
+ XmNborderWidth, 0,
+ XmNspacing, 0,
+ XmNmarginWidth, 0,
+ XmNmarginHeight, 0,
+ XmNmultiClick, XmMULTICLICK_KEEP,
+ XmNlabelType, XmPIXMAP,
+ NULL);
+ XtAddCallback ((Widget) button,
+ XmNvalueChangedCallback,
+ (XtCallbackProc) wxToolButtonCallback,
+ (XtPointer) this);
+
+ XtVaSetValues ((Widget) button,
+ XmNselectColor,
+ m_backgroundColour.AllocColour
+ (XtDisplay((Widget) button)),
+ NULL);
+ }
+ else if( !tool->GetButtonWidget() )
+ {
+ button = XtVaCreateWidget("button",
+ xmPushButtonWidgetClass, (Widget) m_mainWidget,
+ XmNx, currentX, XmNy, currentY,
+ XmNpushButtonEnabled, True,
+ XmNmultiClick, XmMULTICLICK_KEEP,
+ XmNlabelType, XmPIXMAP,
+ NULL);
+ XtAddCallback (button,
+ XmNactivateCallback,
+ (XtCallbackProc) wxToolButtonCallback,
+ (XtPointer) this);
+ }
- // If there's a bitmap for the toggled state, use it,
- // otherwise generate one.
- if (tool->m_bitmap2.Ok())
+ if( !tool->GetButtonWidget() )
{
- pixmap2 = (Pixmap) tool->m_bitmap2.GetPixmap();
- insensPixmap2 = (Pixmap) tool->m_bitmap2.GetInsensPixmap();
+ wxDoChangeBackgroundColour((WXWidget) button,
+ m_backgroundColour, TRUE);
+
+ tool->SetWidget(button);
}
else
{
- pixmap2 = (Pixmap) tool->m_bitmap1.GetArmPixmap(button);
- insensPixmap2 = XCreateInsensitivePixmap((Display*) wxGetDisplay(), pixmap2);
- m_pixmaps.Append((wxObject*) insensPixmap2); // Store for later deletion
+ button = (Widget)tool->GetButtonWidget();
+ XtVaSetValues( button,
+ XmNx, currentX, XmNy, currentY,
+ NULL );
}
- XtVaSetValues (button,
- XmNindicatorOn, False,
- XmNshadowThickness, 2,
- // XmNborderWidth, 0,
- // XmNspacing, 0,
- XmNmarginWidth, 0,
- XmNmarginHeight, 0,
- XmNfillOnSelect, True,
- XmNlabelPixmap, pixmap,
- XmNselectPixmap, pixmap2,
- XmNlabelInsensitivePixmap, insensPixmap,
- XmNselectInsensitivePixmap, insensPixmap2,
- XmNlabelType, XmPIXMAP,
- NULL);
- }
- else
- {
- Pixmap pixmap2 = (Pixmap) 0;
- // If there's a bitmap for the armed state, use it,
- // otherwise generate one.
- if (tool->m_bitmap2.Ok())
+ // For each button, if there is a mask, we must create
+ // a new wxBitmap that has the correct background colour
+ // for the button. Otherwise the background will just be
+ // e.g. black if a transparent XPM has been loaded.
+ bmp = tool->GetNormalBitmap();
+ insensBmp = tool->GetDisabledBitmap();
+ if ( bmp.GetMask() || insensBmp.GetMask() )
{
- pixmap2 = (Pixmap) tool->m_bitmap2.GetPixmap();
+ int backgroundPixel;
+ XtVaGetValues(button, XmNbackground, &backgroundPixel,
+ NULL);
+
+ wxColour col;
+ col.SetPixel(backgroundPixel);
+
+ if( bmp.Ok() && bmp.GetMask() )
+ {
+ bmp = wxCreateMaskedBitmap(bmp, col);
+ tool->SetNormalBitmap(bmp);
+ }
+
+ if( insensBmp.Ok() && insensBmp.GetMask() )
+ {
+ insensBmp = wxCreateMaskedBitmap(insensBmp, col);
+ tool->SetDisabledBitmap(insensBmp);
+ }
}
+
+ // Create a selected/toggled bitmap. If there isn't a 2nd
+ // bitmap, we need to create it (with a darker, selected
+ // background)
+ int backgroundPixel;
+ if ( tool->CanBeToggled() )
+ XtVaGetValues(button, XmNselectColor, &backgroundPixel,
+ NULL);
else
+ XtVaGetValues(button, XmNarmColor, &backgroundPixel,
+ NULL);
+ wxColour col;
+ col.SetPixel(backgroundPixel);
+
+ pixmap = (Pixmap) bmp.GetDrawable();
{
- pixmap2 = (Pixmap) tool->m_bitmap1.GetArmPixmap(button);
+ wxBitmap tmp = tool->GetDisabledBitmap();
+ insensPixmap = tmp.Ok() ?
+ (Pixmap)tmp.GetDrawable() :
+ tool->GetInsensPixmap();
+ }
+
+ if (tool->CanBeToggled())
+ {
+ // Toggle button
+ Pixmap pixmap2 = tool->GetArmPixmap();
+ Pixmap insensPixmap2 = tool->GetInsensPixmap();
+
+ XtVaSetValues (button,
+ XmNfillOnSelect, True,
+ XmNlabelPixmap, pixmap,
+ XmNselectPixmap, pixmap2,
+ XmNlabelInsensitivePixmap, insensPixmap,
+ XmNselectInsensitivePixmap, insensPixmap2,
+ XmNlabelType, XmPIXMAP,
+ NULL);
+ }
+ else
+ {
+ Pixmap pixmap2 = tool->GetArmPixmap();
+
+ // Normal button
+ XtVaSetValues(button,
+ XmNlabelPixmap, pixmap,
+ XmNlabelInsensitivePixmap, insensPixmap,
+ XmNarmPixmap, pixmap2,
+ NULL);
}
- // Normal button
- XtVaSetValues(button,
- XmNlabelPixmap, pixmap,
- XmNlabelInsensitivePixmap, insensPixmap,
- XmNarmPixmap, pixmap2,
- NULL);
- }
- XtManageChild(button);
- Dimension width, height;
- XtVaGetValues(button, XmNwidth, & width, XmNheight, & height,
- NULL);
- currentX += width + marginX;
- buttonHeight = wxMax(buttonHeight, height);
+ XtManageChild(button);
- XtAddEventHandler (button, EnterWindowMask | LeaveWindowMask,
- False, wxToolButtonPopupCallback, (XtPointer) this);
- m_widgets.Append(tool->m_index, (wxObject*) button);
+ {
+ Dimension width, height;
+ XtVaGetValues(button,
+ XmNwidth, &width,
+ XmNheight, & height,
+ NULL);
+ if ( isVertical )
+ currentY += height + packing;
+ else
+ currentX += width + packing;
+ buttonHeight = wxMax(buttonHeight, height);
+ buttonWidth = wxMax(buttonWidth, width);
+ }
+
+ XtAddEventHandler (button, EnterWindowMask | LeaveWindowMask,
+ False, wxToolButtonPopupCallback, (XtPointer) this);
- prevButton = button;
- currentSpacing = 0;
+ currentSpacing = 0;
+ break;
}
- node = node->Next();
+
+ node = node->GetNext();
}
- SetSize(-1, -1, currentX, buttonHeight + 2*marginY);
+ SetSize( -1, -1,
+ isVertical ? buttonWidth + 2 * marginX : -1,
+ isVertical ? -1 : buttonHeight + 2*marginY );
return TRUE;
}
-void wxToolBar::SetToolBitmapSize(const wxSize& size)
+wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x),
+ wxCoord WXUNUSED(y)) const
{
- // TODO not necessary?
- m_defaultWidth = size.x; m_defaultHeight = size.y;
+ wxFAIL_MSG( _T("TODO") );
+
+ return (wxToolBarToolBase *)NULL;
}
-wxSize wxToolBar::GetMaxSize() const
+bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
{
- int w, h;
- GetSize(& w, & h);
+ tool->Attach(this);
- return wxSize(w, h);
+ return TRUE;
}
-// The button size is bigger than the bitmap size
-wxSize wxToolBar::GetToolSize() const
+bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
{
- // TODO not necessary?
- return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
-}
+ tool->Detach();
-void wxToolBar::EnableTool(int toolIndex, bool enable)
-{
- wxNode *node = m_tools.Find((long)toolIndex);
- if (node)
+ bool isVertical = GetWindowStyle() & wxTB_VERTICAL;
+ const int separatorSize = GetToolSeparation(); // 8;
+ int packing = GetToolPacking();
+ int offset = 0;
+
+ for( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
+ node; node = node->GetNext() )
{
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- tool->m_enabled = enable;
+ wxToolBarTool *t = (wxToolBarTool*)node->GetData();
- WXWidget widget = FindWidgetForIndex(tool->m_index);
- if (widget == (WXWidget) 0)
- return;
+ if( t == tool )
+ {
+ switch ( t->GetStyle() )
+ {
+ case wxTOOL_STYLE_CONTROL:
+ {
+ wxSize size = t->GetControl()->GetSize();
+ offset = isVertical ? size.y : size.x;
+ offset += packing;
+ break;
+ }
+ case wxTOOL_STYLE_SEPARATOR:
+ offset = isVertical ? 0 : separatorSize;
+ break;
+ case wxTOOL_STYLE_BUTTON:
+ {
+ Widget w = t->GetButtonWidget();
+ Dimension width, height;
- XtSetSensitive((Widget) widget, (Boolean) enable);
- }
-}
+ XtVaGetValues( w,
+ XmNwidth, &width,
+ XmNheight, &height,
+ NULL );
-void wxToolBar::ToggleTool(int toolIndex, bool toggle)
-{
- wxNode *node = m_tools.Find((long)toolIndex);
- if (node)
- {
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- if (tool->m_isToggle)
+ offset = isVertical ? height : width;
+ offset += packing;
+ break;
+ }
+ }
+ }
+ else if( offset )
{
- tool->m_toggleState = toggle;
+ switch ( t->GetStyle() )
+ {
+ case wxTOOL_STYLE_CONTROL:
+ {
+ wxPoint pos = t->GetControl()->GetPosition();
+
+ if( isVertical )
+ pos.y -= offset;
+ else
+ pos.x -= offset;
- WXWidget widget = FindWidgetForIndex(tool->m_index);
- if (widget == (WXWidget) 0)
- return;
+ t->GetControl()->Move( pos );
+ break;
+ }
+ case wxTOOL_STYLE_SEPARATOR:
+ break;
+ case wxTOOL_STYLE_BUTTON:
+ {
+ Dimension x, y;
+ XtVaGetValues( t->GetButtonWidget(),
+ XmNx, &x,
+ XmNy, &y,
+ NULL );
+
+ if( isVertical )
+ y -= offset;
+ else
+ x -= offset;
- XmToggleButtonSetState((Widget) widget, (Boolean) toggle, False);
+ XtVaSetValues( t->GetButtonWidget(),
+ XmNx, x,
+ XmNy, y,
+ NULL );
+ break;
+ }
+ }
}
}
+
+ return TRUE;
}
-void wxToolBar::ClearTools()
+void wxToolBar::DoEnableTool(wxToolBarToolBase *toolBase, bool enable)
{
- wxNode* node = m_widgets.First();
- while (node)
- {
- Widget button = (Widget) node->Data();
- XtDestroyWidget(button);
- node = node->Next();
- }
- m_widgets.Clear();
- DestroyPixmaps();
+ wxToolBarTool *tool = (wxToolBarTool *)toolBase;
- wxToolBarBase::ClearTools();
+ XtSetSensitive(tool->GetButtonWidget(), (Boolean) enable);
}
-void wxToolBar::DestroyPixmaps()
+void wxToolBar::DoToggleTool(wxToolBarToolBase *toolBase, bool toggle)
{
- wxNode* node = m_pixmaps.First();
- while (node)
- {
- Pixmap pixmap = (Pixmap) node->Data();
- XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) GetXDisplay()), pixmap);
- node = node->Next();
- }
- m_pixmaps.Clear();
-}
+ wxToolBarTool *tool = (wxToolBarTool *)toolBase;
-// 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.
+ XmToggleButtonSetState(tool->GetButtonWidget(), (Boolean) toggle, False);
+}
-wxToolBarTool *wxToolBar::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap,
- bool toggle, long xPos, long yPos, wxObject *clientData, const wxString& helpString1, const wxString& helpString2)
+void wxToolBar::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
+ bool WXUNUSED(toggle))
{
- 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;
+ // nothing to do
+}
- if (yPos > -1)
- tool->m_y = yPos;
- else
- tool->m_y = m_yMargin;
+void wxToolBar::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+{
+ int old_width, old_height;
+ GetSize(&old_width, &old_height);
- wxSize size = GetToolSize();
- tool->SetSize(size.x, size.y);
+ // Correct width and height if needed.
+ if ( width == -1 || height == -1 )
+ {
+ wxSize defaultSize = GetSize();
- m_tools.Append((long)index, tool);
- return tool;
-}
+ if ( width == -1 )
+ width = defaultSize.x;
+ if ( height == -1 )
+ height = defaultSize.y;
+ }
-int wxToolBar::FindIndexForWidget(WXWidget w)
-{
- wxNode* node = m_widgets.First();
- while (node)
+ wxToolBarBase::DoSetSize(x, y, width, height, sizeFlags);
+
+ // We must refresh the frame size when the toolbar changes size
+ // otherwise the toolbar can be shown incorrectly
+ if ( old_width != width || old_height != height )
{
- WXWidget widget = (WXWidget) node->Data();
- if (widget == w)
- return (int) node->GetKeyInteger();
- node = node->Next();
+ // But before we send the size event check it
+ // we have a frame that is not being deleted.
+ wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
+ if ( frame && !frame->IsBeingDeleted() )
+ {
+ frame->SendSizeEvent();
+ }
}
- return -1;
}
-WXWidget wxToolBar::FindWidgetForIndex(int index)
-{
- wxNode* node = m_widgets.Find((long) index);
- if (!node)
- return (WXWidget) 0;
- else
- return (WXWidget) node->Data();
-}
+// ----------------------------------------------------------------------------
+// Motif callbacks
+// ----------------------------------------------------------------------------
-WXWidget wxToolBar::GetTopWidget() const
+wxToolBarToolBase *wxToolBar::FindToolByWidget(WXWidget w) const
{
- return m_mainWidget;
-}
+ wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
+ while ( node )
+ {
+ wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
+ if ( tool->GetButtonWidget() == w)
+ {
+ return tool;
+ }
-WXWidget wxToolBar::GetClientWidget() const
-{
- return m_mainWidget;
-}
+ node = node->GetNext();
+ }
-WXWidget wxToolBar::GetMainWidget() const
-{
- return m_mainWidget;
+ return (wxToolBarToolBase *)NULL;
}
-
-void wxToolButtonCallback (Widget w, XtPointer clientData,
- XtPointer ptr)
+static void wxToolButtonCallback(Widget w,
+ XtPointer clientData,
+ XtPointer WXUNUSED(ptr))
{
wxToolBar *toolBar = (wxToolBar *) clientData;
- int index = toolBar->FindIndexForWidget((WXWidget) w);
+ wxToolBarToolBase *tool = toolBar->FindToolByWidget((WXWidget) w);
+ if ( !tool )
+ return;
- if (index != -1)
+ if ( tool->CanBeToggled() )
+ tool->Toggle();
+
+ if ( !toolBar->OnLeftClick(tool->GetId(), tool->IsToggled()) )
{
- wxNode *node = toolBar->GetTools().Find((long)index);
- if (!node)
- return;
- wxToolBarTool *tool = (wxToolBarTool *)node->Data();
- if (tool->m_isToggle)
- tool->m_toggleState = !tool->m_toggleState;
-
- (void) toolBar->OnLeftClick(index, tool->m_toggleState);
+ // revert
+ tool->Toggle();
}
-
}
-static void wxToolButtonPopupCallback (Widget w, XtPointer client_data,
- XEvent *event, Boolean *continue_to_dispatch)
+static void wxToolButtonPopupCallback(Widget w,
+ XtPointer client_data,
+ XEvent *event,
+ Boolean *WXUNUSED(continue_to_dispatch))
{
// TODO: retrieve delay before popping up tooltip from wxSystemSettings.
- int delayMilli = 800;
+ static const int delayMilli = 800;
+
wxToolBar* toolBar = (wxToolBar*) client_data;
+ wxToolBarToolBase *tool = toolBar->FindToolByWidget((WXWidget) w);
- int index = toolBar->FindIndexForWidget((WXWidget) w);
+ if ( !tool )
+ return;
- if (index != -1)
- {
- wxNode *node = toolBar->GetTools().Find((long)index);
- if (!node)
- return;
- wxString str(toolBar->GetToolShortHelp(index));
- if (str.IsNull() || str == "")
- return;
+ wxString tooltip = tool->GetShortHelp();
+ if ( !tooltip )
+ return;
- if (!wxTheToolBarTimer)
- wxTheToolBarTimer = new wxToolBarTimer;
-
- wxToolBarTimer::buttonWidget = w;
- wxToolBarTimer::helpString = str;
+ if (!wxTheToolBarTimer)
+ wxTheToolBarTimer = new wxToolBarTimer;
+ wxToolBarTimer::buttonWidget = w;
+ wxToolBarTimer::helpString = tooltip;
/************************************************************/
/* Popup help label */
}
wxToolBarTimer::help_popup = (Widget) 0;
}
- }
}
void wxToolBarTimer::Notify()
projects / wxWidgets.git / blobdiff