[wxWidgets.git] / src / motif / toolbar.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        toolbar.cpp
// Purpose:     wxToolBar
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "toolbar.h"
#endif

#include "wx/wx.h"
#include "wx/app.h"
#include "wx/timer.h"
#include "wx/motif/toolbar.h"

#include <Xm/Xm.h>
#include <Xm/PushBG.h>
#include <Xm/PushB.h>
#include <Xm/Label.h>
#include <Xm/ToggleB.h>
#include <Xm/ToggleBG.h>
#include <Xm/Form.h>

#include "wx/motif/private.h"

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)

BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
END_EVENT_TABLE()
#endif

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
{
public:
  wxToolBarTimer() { }
  virtual void Notify();

  static Widget help_popup;
  static Widget buttonWidget;
  static wxString helpString;
};

static wxToolBarTimer* wxTheToolBarTimer = (wxToolBarTimer*) NULL;

Widget wxToolBarTimer::help_popup = (Widget) 0;
Widget wxToolBarTimer::buttonWidget = (Widget) 0;
wxString wxToolBarTimer::helpString = "";

wxToolBar::wxToolBar():
  m_widgets(wxKEY_INTEGER)
{
  m_maxWidth = -1;
  m_maxHeight = -1;
  m_defaultWidth = 24;
  m_defaultHeight = 22;
}

bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
            long style, const wxString& name)
{
    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;

    SetParent(parent);

    if (parent) parent->AddChild(this);

    Widget parentWidget = (Widget) parent->GetClientWidget();

    Widget toolbar = XtVaCreateManagedWidget("toolbar",
                xmFormWidgetClass, parentWidget,
                XmNtraversalOn, False,
                XmNhorizontalSpacing, 0,
                XmNverticalSpacing, 0,
                XmNleftOffset, 0,
                XmNrightOffset, 0,
                XmNmarginWidth, 0,
                XmNmarginHeight, 0,
                NULL);

    m_mainWidget = (WXWidget) toolbar;

    SetCanAddEventHandler(TRUE);
    AttachWidget (parent, m_mainWidget, (WXWidget) NULL, pos.x, pos.y, size.x, size.y);

    SetFont(* parent->GetFont());
    ChangeBackgroundColour();
  
    return TRUE;
}

wxToolBar::~wxToolBar()
{
    delete wxTheToolBarTimer;
    wxTheToolBarTimer = NULL;
    ClearTools();
    DestroyPixmaps();
}

bool wxToolBar::CreateTools()
{
    if (m_tools.Number() == 0)
        return FALSE;

    // Separator spacing
    const int separatorSize = GetToolSeparation(); // 8;

    int currentSpacing = 0;

    m_widgets.Clear();
    Widget prevButton = (Widget) 0;
    wxNode* node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool *)node->Data();

        if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR)
            currentSpacing = separatorSize;
        else if (tool->m_bitmap1.Ok())
        {
            Widget button = (Widget) 0;

            if (tool->m_isToggle)
            {
                button = XtVaCreateManagedWidget("toggleButton", 
                   xmToggleButtonWidgetClass, (Widget) m_mainWidget,
                   XmNleftAttachment, (prevButton == (Widget) 0) ? XmATTACH_FORM : XmATTACH_WIDGET,
                   XmNleftWidget, (prevButton == (Widget) 0) ? NULL : prevButton,
                   XmNleftOffset, currentSpacing,
                   XmNtopAttachment, XmATTACH_FORM,
						 //                   XmNpushButtonEnabled, True,
                   XmNmultiClick, XmMULTICLICK_KEEP,
                   XmNlabelType, XmPIXMAP,
                   NULL);
                XtAddCallback ((Widget) button, XmNvalueChangedCallback, (XtCallbackProc) wxToolButtonCallback,
		 (XtPointer) this);
            }
            else
            {
                button = XtVaCreateManagedWidget("button", 
                   xmPushButtonWidgetClass, (Widget) m_mainWidget,
                   XmNleftAttachment, (prevButton == (Widget) 0) ? XmATTACH_FORM : XmATTACH_WIDGET,
                   XmNleftWidget, (prevButton == (Widget) 0) ? NULL : prevButton,
                   XmNleftOffset, currentSpacing,
                   XmNtopAttachment, XmATTACH_FORM,
                   XmNpushButtonEnabled, True,
                   XmNmultiClick, XmMULTICLICK_KEEP,
                   XmNlabelType, XmPIXMAP,
                   NULL);
                XtAddCallback (button,
                   XmNactivateCallback, (XtCallbackProc) wxToolButtonCallback,
                   (XtPointer) this);
            }

            // 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())
            {
                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);

            if (tool->m_bitmap2.Ok() && tool->m_bitmap2.GetMask())
            {
                // Use what's there
                wxBitmap newBitmap = wxCreateMaskedBitmap(tool->m_bitmap2, col);
                tool->m_bitmap2 = newBitmap;
            }
            else
            {
                // Use unselected bitmap
                if (originalBitmap.GetMask())
                {
                    wxBitmap newBitmap = wxCreateMaskedBitmap(originalBitmap, col);
                    tool->m_bitmap2 = newBitmap;
		}
                else
                    tool->m_bitmap2 = tool->m_bitmap1;
            }

            Pixmap pixmap = (Pixmap) tool->m_bitmap1.GetPixmap();
            Pixmap insensPixmap = (Pixmap) tool->m_bitmap1.GetInsensPixmap();

            if (tool->m_isToggle)
            {
                // Toggle button
                Pixmap pixmap2 = (Pixmap) 0;
                Pixmap insensPixmap2 = (Pixmap) 0;

                // If there's a bitmap for the toggled state, use it,
                // otherwise generate one.
                if (tool->m_bitmap2.Ok())
                {
                    pixmap2 = (Pixmap) tool->m_bitmap2.GetPixmap();
                    insensPixmap2 = (Pixmap) tool->m_bitmap2.GetInsensPixmap();
                }
                else
                {
                    pixmap2 = (Pixmap) tool->m_bitmap1.GetArmPixmap(button);
                    insensPixmap2 = XCreateInsensitivePixmap((Display*) wxGetDisplay(), pixmap2);
                    m_pixmaps.Append((wxObject*) insensPixmap2); // Store for later deletion
                }
                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())
                {
                    pixmap2 = (Pixmap) tool->m_bitmap2.GetPixmap();
                }
                else
                {
                    pixmap2 = (Pixmap) tool->m_bitmap1.GetArmPixmap(button);

                }
                // Normal button
                XtVaSetValues(button,
                   XmNlabelPixmap, pixmap,
                   XmNlabelInsensitivePixmap, insensPixmap,
                   XmNarmPixmap, pixmap2,
                   NULL);
            }

            XtAddEventHandler (button, EnterWindowMask | LeaveWindowMask, 
                       False, wxToolButtonPopupCallback, (XtPointer) this);
            m_widgets.Append(tool->m_index, (wxObject*) button);

            prevButton = button;
            currentSpacing = 0;
        }
        node = node->Next();
    }

    return TRUE;
}

void wxToolBar::SetToolBitmapSize(const wxSize& size)
{
    m_defaultWidth = size.x; m_defaultHeight = size.y;
    // TODO
}

wxSize wxToolBar::GetMaxSize() const
{
    // TODO
    return wxSize(0, 0);
}

// The button size is bigger than the bitmap size
wxSize wxToolBar::GetToolSize() const
{
    // TODO
    return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
}

void wxToolBar::EnableTool(int toolIndex, bool enable)
{
    wxNode *node = m_tools.Find((long)toolIndex);
    if (node)
    {
        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
        tool->m_enabled = enable;

        WXWidget widget = FindWidgetForIndex(tool->m_index);
        if (widget == (WXWidget) 0)
            return;

        XtSetSensitive((Widget) widget, (Boolean) enable);
    }
}

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)
        {
            tool->m_toggleState = toggle;

            WXWidget widget = FindWidgetForIndex(tool->m_index);
            if (widget == (WXWidget) 0)
                return;

            XmToggleButtonSetState((Widget) widget, (Boolean) toggle, False);
        }
    }
}

void wxToolBar::ClearTools()
{
    wxNode* node = m_widgets.First();
    while (node)
    {
        Widget button = (Widget) node->Data();
        XtDestroyWidget(button);
        node = node->Next();
    }
    m_widgets.Clear();
    DestroyPixmaps();

    wxToolBarBase::ClearTools();
}

void wxToolBar::DestroyPixmaps()
{
    wxNode* node = m_pixmaps.First();
    while (node)
    {
        Pixmap pixmap = (Pixmap) node->Data();
        XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) GetXDisplay()), pixmap);
        node = node->Next();
    }
    m_pixmaps.Clear();
}

// 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 *wxToolBar::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, (wxBitmap *)NULL, 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(GetDefaultButtonWidth(), GetDefaultButtonHeight());

  m_tools.Append((long)index, tool);
  return tool;
}

int wxToolBar::FindIndexForWidget(WXWidget w)
{
    wxNode* node = m_widgets.First();
    while (node)
    {
        WXWidget widget = (WXWidget) node->Data();
        if (widget == w)
            return (int) node->key.integer;
        node = node->Next();
    }
    return -1;
}

WXWidget wxToolBar::FindWidgetForIndex(int index)
{
    wxNode* node = m_widgets.Find((long) index);
    if (!node)
        return (WXWidget) 0;
    else
        return (WXWidget) node->Data();
}

void wxToolButtonCallback (Widget w, XtPointer clientData,
		    XtPointer ptr)
{
    wxToolBar *toolBar = (wxToolBar *) clientData;
    int index = toolBar->FindIndexForWidget((WXWidget) w);

    if (index != -1)
    {
        wxNode *node = toolBar->GetTools().Find((long)index);
        if (!node)
            return;
        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
        if (tool->m_isToggle)
            tool->m_toggleState = toolBar->GetToolState(index);

        (void) toolBar->OnLeftClick(index, tool->m_toggleState);
    }

}


static void wxToolButtonPopupCallback (Widget w, XtPointer client_data,
                     XEvent *event, Boolean *continue_to_dispatch)
{
    // TODO: retrieve delay before popping up tooltip from wxSystemSettings.
    int delayMilli = 800;
    wxToolBar* toolBar = (wxToolBar*) client_data;

    int index = toolBar->FindIndexForWidget((WXWidget) w);

    if (index != -1)
    {
        wxNode *node = toolBar->GetTools().Find((long)index);
        if (!node)
            return;
        wxToolBarTool *tool = (wxToolBarTool *)node->Data();
        wxString str(toolBar->GetToolShortHelp(index));
        if (str.IsNull() || str == "")
            return;

        if (!wxTheToolBarTimer)
          wxTheToolBarTimer = new wxToolBarTimer;

	wxToolBarTimer::buttonWidget = w;
	wxToolBarTimer::helpString = str;


    /************************************************************/
    /* Popup help label                                         */
    /************************************************************/
    if (event->type == EnterNotify)
    {
        if (wxToolBarTimer::help_popup != (Widget) 0)
        {
            XtDestroyWidget (wxToolBarTimer::help_popup);
            XtPopdown (wxToolBarTimer::help_popup);
	}
        wxToolBarTimer::help_popup = (Widget) 0;

        // One shot
        wxTheToolBarTimer->Start(delayMilli, TRUE);

    }
    /************************************************************/
    /* Popdown help label                                       */
    /************************************************************/
    else if (event->type == LeaveNotify)
    {
        if (wxTheToolBarTimer)
            wxTheToolBarTimer->Stop();
        if (wxToolBarTimer::help_popup != (Widget) 0)
        {
            XtDestroyWidget (wxToolBarTimer::help_popup);
            XtPopdown (wxToolBarTimer::help_popup);
	}
        wxToolBarTimer::help_popup = (Widget) 0;
    }
    }
}

void wxToolBarTimer::Notify()
{
    Position x, y;

        /************************************************************/
        /* Create shell without window decorations                  */
        /************************************************************/
        help_popup = XtVaCreatePopupShell ("shell", 
                                           overrideShellWidgetClass, (Widget) wxTheApp->GetTopLevelWidget(), 
                                           NULL);

        /************************************************************/
        /* Get absolute position on display of toolbar button       */
        /************************************************************/
        XtTranslateCoords (buttonWidget,
                           (Position) 0, 
                           (Position) 0, 
                           &x, &y);

        // Move the tooltip more or less above the button
        int yOffset = 20; // TODO: What should be really?
        y -= yOffset;
        if (y < yOffset) y = 0;

        /************************************************************/
        /* Set the position of the help popup                       */
        /************************************************************/
        XtVaSetValues (help_popup, 
                       XmNx, (Position) x, 
                       XmNy, (Position) y, 
                       NULL);
        
        /************************************************************/
        /* Create help label                                        */
        /************************************************************/
        XmString text = XmStringCreateSimple ((char*) (const char*) helpString);
        XtVaCreateManagedWidget ("help_label", 
                                 xmLabelWidgetClass, help_popup, 
                                 XmNlabelString, text,
                                 XtVaTypedArg, 
                                 XmNforeground, XtRString, "black", 
                                                strlen("black")+1,      
                                 XtVaTypedArg, 
                                 XmNbackground, XtRString, "LightGoldenrod", 
                                                strlen("LightGoldenrod")+1, 
                                 NULL);
        XmStringFree (text);

        /************************************************************/
        /* Popup help label                                         */
        /************************************************************/
        XtPopup (help_popup, XtGrabNone);
}
Commit	Line	Data
4bb6408c JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: toolbar.cpp
	3	// Purpose: wxToolBar
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "toolbar.h"
	14	#endif
	15
	16	#include "wx/wx.h"
1a3ac83f JS	17	#include "wx/app.h"
1a3ac83f JS	18	#include "wx/timer.h"
0d57be45 JS	19	#include "wx/motif/toolbar.h"
	20
	21	#include <Xm/Xm.h>
	22	#include <Xm/PushBG.h>
	23	#include <Xm/PushB.h>
1a3ac83f	24	#include <Xm/Label.h>
0d57be45 JS	25	#include <Xm/ToggleB.h>
	26	#include <Xm/ToggleBG.h>
	27	#include <Xm/Form.h>
	28
	29	#include "wx/motif/private.h"
4bb6408c JS	30
	31	#if !USE_SHARED_LIBRARY
	32	IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
	33
	34	BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
	35	END_EVENT_TABLE()
	36	#endif
	37
1a3ac83f JS	38	static void wxToolButtonCallback (Widget w, XtPointer clientData,
	39	XtPointer ptr);
	40	static void wxToolButtonPopupCallback (Widget w, XtPointer client_data,
	41	XEvent event, Boolean continue_to_dispatch);
	42
1a3ac83f JS	43	class wxToolBarTimer: public wxTimer
	44	{
	45	public:
	46	wxToolBarTimer() { }
	47	virtual void Notify();
	48
	49	static Widget help_popup;
	50	static Widget buttonWidget;
	51	static wxString helpString;
	52	};
	53
	54	static wxToolBarTimer* wxTheToolBarTimer = (wxToolBarTimer*) NULL;
	55
	56	Widget wxToolBarTimer::help_popup = (Widget) 0;
	57	Widget wxToolBarTimer::buttonWidget = (Widget) 0;
	58	wxString wxToolBarTimer::helpString = "";
	59
0d57be45 JS	60	wxToolBar::wxToolBar():
0d57be45 JS	61	m_widgets(wxKEY_INTEGER)
4bb6408c JS	62	{
	63	m_maxWidth = -1;
	64	m_maxHeight = -1;
	65	m_defaultWidth = 24;
	66	m_defaultHeight = 22;
4bb6408c JS	67	}
	68
	69	bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
	70	long style, const wxString& name)
	71	{
	72	m_maxWidth = -1;
	73	m_maxHeight = -1;
	74
	75	m_defaultWidth = 24;
	76	m_defaultHeight = 22;
	77	SetName(name);
0d57be45 JS	78	m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
0d57be45 JS	79	m_foregroundColour = parent->GetForegroundColour();
4bb6408c JS	80	m_windowStyle = style;
	81
	82	SetParent(parent);
	83
	84	if (parent) parent->AddChild(this);
	85
0d57be45 JS	86	Widget parentWidget = (Widget) parent->GetClientWidget();
	87
	88	Widget toolbar = XtVaCreateManagedWidget("toolbar",
	89	xmFormWidgetClass, parentWidget,
	90	XmNtraversalOn, False,
	91	XmNhorizontalSpacing, 0,
	92	XmNverticalSpacing, 0,
1a3ac83f JS	93	XmNleftOffset, 0,
	94	XmNrightOffset, 0,
	95	XmNmarginWidth, 0,
	96	XmNmarginHeight, 0,
0d57be45 JS	97	NULL);
	98
	99	m_mainWidget = (WXWidget) toolbar;
	100
	101	SetCanAddEventHandler(TRUE);
	102	AttachWidget (parent, m_mainWidget, (WXWidget) NULL, pos.x, pos.y, size.x, size.y);
	103
	104	SetFont(* parent->GetFont());
	105	ChangeBackgroundColour();
4bb6408c	106
0d57be45	107	return TRUE;
4bb6408c JS	108	}
	109
	110	wxToolBar::~wxToolBar()
	111	{
1a3ac83f JS	112	delete wxTheToolBarTimer;
	113	wxTheToolBarTimer = NULL;
	114	ClearTools();
	115	DestroyPixmaps();
4bb6408c JS	116	}
	117
	118	bool wxToolBar::CreateTools()
	119	{
	120	if (m_tools.Number() == 0)
	121	return FALSE;
	122
1a3ac83f JS	123	// Separator spacing
	124	const int separatorSize = GetToolSeparation(); // 8;
	125
	126	int currentSpacing = 0;
	127
0d57be45 JS	128	m_widgets.Clear();
	129	Widget prevButton = (Widget) 0;
	130	wxNode* node = m_tools.First();
	131	while (node)
	132	{
	133	wxToolBarTool tool = (wxToolBarTool )node->Data();
1a3ac83f JS	134
	135	if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR)
	136	currentSpacing = separatorSize;
	137	else if (tool->m_bitmap1.Ok())
0d57be45 JS	138	{
	139	Widget button = (Widget) 0;
	140
	141	if (tool->m_isToggle)
	142	{
	143	button = XtVaCreateManagedWidget("toggleButton",
	144	xmToggleButtonWidgetClass, (Widget) m_mainWidget,
	145	XmNleftAttachment, (prevButton == (Widget) 0) ? XmATTACH_FORM : XmATTACH_WIDGET,
	146	XmNleftWidget, (prevButton == (Widget) 0) ? NULL : prevButton,
1a3ac83f	147	XmNleftOffset, currentSpacing,
0d57be45 JS	148	XmNtopAttachment, XmATTACH_FORM,
	149	// XmNpushButtonEnabled, True,
	150	XmNmultiClick, XmMULTICLICK_KEEP,
	151	XmNlabelType, XmPIXMAP,
	152	NULL);
1a3ac83f JS	153	XtAddCallback ((Widget) button, XmNvalueChangedCallback, (XtCallbackProc) wxToolButtonCallback,
1a3ac83f JS	154	(XtPointer) this);
0d57be45 JS	155	}
	156	else
	157	{
	158	button = XtVaCreateManagedWidget("button",
	159	xmPushButtonWidgetClass, (Widget) m_mainWidget,
	160	XmNleftAttachment, (prevButton == (Widget) 0) ? XmATTACH_FORM : XmATTACH_WIDGET,
	161	XmNleftWidget, (prevButton == (Widget) 0) ? NULL : prevButton,
1a3ac83f	162	XmNleftOffset, currentSpacing,
0d57be45 JS	163	XmNtopAttachment, XmATTACH_FORM,
	164	XmNpushButtonEnabled, True,
	165	XmNmultiClick, XmMULTICLICK_KEEP,
	166	XmNlabelType, XmPIXMAP,
	167	NULL);
1a3ac83f JS	168	XtAddCallback (button,
	169	XmNactivateCallback, (XtCallbackProc) wxToolButtonCallback,
	170	(XtPointer) this);
	171	}
0d57be45 JS	172
	173	// For each button, if there is a mask, we must create
	174	// a new wxBitmap that has the correct background colour
	175	// for the button. Otherwise the background will just be
	176	// e.g. black if a transparent XPM has been loaded.
1a3ac83f JS	177	wxBitmap originalBitmap = tool->m_bitmap1;
1a3ac83f JS	178
0d57be45 JS	179	if (tool->m_bitmap1.GetMask())
0d57be45 JS	180	{
0d57be45 JS	181	int backgroundPixel;
	182	XtVaGetValues(button, XmNbackground, &backgroundPixel,
	183	NULL);
	184
	185
	186	wxColour col;
	187	col.SetPixel(backgroundPixel);
	188
1a3ac83f	189	wxBitmap newBitmap = wxCreateMaskedBitmap(tool->m_bitmap1, col);
0d57be45 JS	190
	191	tool->m_bitmap1 = newBitmap;
	192	}
0d57be45	193
1a3ac83f JS	194	// Create a selected/toggled bitmap. If there isn't a m_bitmap2,
	195	// we need to create it (with a darker, selected background)
	196	int backgroundPixel;
	197	if (tool->m_isToggle)
	198	XtVaGetValues(button, XmNselectColor, &backgroundPixel,
	199	NULL);
	200	else
	201	XtVaGetValues(button, XmNarmColor, &backgroundPixel,
	202	NULL);
0d57be45	203
1a3ac83f JS	204	wxColour col;
1a3ac83f JS	205	col.SetPixel(backgroundPixel);
0d57be45	206
1a3ac83f JS	207	if (tool->m_bitmap2.Ok() && tool->m_bitmap2.GetMask())
	208	{
	209	// Use what's there
	210	wxBitmap newBitmap = wxCreateMaskedBitmap(tool->m_bitmap2, col);
0d57be45 JS	211	tool->m_bitmap2 = newBitmap;
0d57be45 JS	212	}
1a3ac83f JS	213	else
	214	{
	215	// Use unselected bitmap
	216	if (originalBitmap.GetMask())
	217	{
	218	wxBitmap newBitmap = wxCreateMaskedBitmap(originalBitmap, col);
	219	tool->m_bitmap2 = newBitmap;
	220	}
	221	else
	222	tool->m_bitmap2 = tool->m_bitmap1;
	223	}
	224
0d57be45 JS	225	Pixmap pixmap = (Pixmap) tool->m_bitmap1.GetPixmap();
	226	Pixmap insensPixmap = (Pixmap) tool->m_bitmap1.GetInsensPixmap();
	227
	228	if (tool->m_isToggle)
	229	{
1a3ac83f	230	// Toggle button
0d57be45 JS	231	Pixmap pixmap2 = (Pixmap) 0;
	232	Pixmap insensPixmap2 = (Pixmap) 0;
	233
	234	// If there's a bitmap for the toggled state, use it,
	235	// otherwise generate one.
	236	if (tool->m_bitmap2.Ok())
	237	{
	238	pixmap2 = (Pixmap) tool->m_bitmap2.GetPixmap();
	239	insensPixmap2 = (Pixmap) tool->m_bitmap2.GetInsensPixmap();
	240	}
	241	else
	242	{
	243	pixmap2 = (Pixmap) tool->m_bitmap1.GetArmPixmap(button);
1a3ac83f JS	244	insensPixmap2 = XCreateInsensitivePixmap((Display*) wxGetDisplay(), pixmap2);
1a3ac83f JS	245	m_pixmaps.Append((wxObject*) insensPixmap2); // Store for later deletion
0d57be45 JS	246	}
0d57be45 JS	247	XtVaSetValues (button,
1a3ac83f JS	248	XmNindicatorOn, False,
	249	XmNshadowThickness, 2,
	250	// XmNborderWidth, 0,
	251	// XmNspacing, 0,
	252	XmNmarginWidth, 0,
	253	XmNmarginHeight, 0,
	254	XmNfillOnSelect, True,
	255	XmNlabelPixmap, pixmap,
	256	XmNselectPixmap, pixmap2,
	257	XmNlabelInsensitivePixmap, insensPixmap,
	258	XmNselectInsensitivePixmap, insensPixmap2,
	259	XmNlabelType, XmPIXMAP,
	260	NULL);
	261	}
0d57be45 JS	262	else
0d57be45 JS	263	{
1a3ac83f JS	264	Pixmap pixmap2 = (Pixmap) 0;
	265
	266	// If there's a bitmap for the armed state, use it,
	267	// otherwise generate one.
	268	if (tool->m_bitmap2.Ok())
	269	{
	270	pixmap2 = (Pixmap) tool->m_bitmap2.GetPixmap();
	271	}
	272	else
	273	{
	274	pixmap2 = (Pixmap) tool->m_bitmap1.GetArmPixmap(button);
	275
	276	}
	277	// Normal button
0d57be45 JS	278	XtVaSetValues(button,
0d57be45 JS	279	XmNlabelPixmap, pixmap,
1a3ac83f JS	280	XmNlabelInsensitivePixmap, insensPixmap,
	281	XmNarmPixmap, pixmap2,
	282	NULL);
0d57be45 JS	283	}
0d57be45 JS	284
1a3ac83f JS	285	XtAddEventHandler (button, EnterWindowMask \| LeaveWindowMask,
1a3ac83f JS	286	False, wxToolButtonPopupCallback, (XtPointer) this);
0d57be45 JS	287	m_widgets.Append(tool->m_index, (wxObject*) button);
	288
	289	prevButton = button;
1a3ac83f	290	currentSpacing = 0;
0d57be45 JS	291	}
	292	node = node->Next();
	293	}
	294
	295	return TRUE;
4bb6408c JS	296	}
	297
	298	void wxToolBar::SetToolBitmapSize(const wxSize& size)
	299	{
	300	m_defaultWidth = size.x; m_defaultHeight = size.y;
	301	// TODO
	302	}
	303
	304	wxSize wxToolBar::GetMaxSize() const
	305	{
	306	// TODO
	307	return wxSize(0, 0);
	308	}
	309
	310	// The button size is bigger than the bitmap size
	311	wxSize wxToolBar::GetToolSize() const
	312	{
	313	// TODO
	314	return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
	315	}
	316
	317	void wxToolBar::EnableTool(int toolIndex, bool enable)
	318	{
	319	wxNode *node = m_tools.Find((long)toolIndex);
	320	if (node)
	321	{
	322	wxToolBarTool tool = (wxToolBarTool )node->Data();
	323	tool->m_enabled = enable;
1a3ac83f JS	324
	325	WXWidget widget = FindWidgetForIndex(tool->m_index);
	326	if (widget == (WXWidget) 0)
	327	return;
	328
	329	XtSetSensitive((Widget) widget, (Boolean) enable);
4bb6408c JS	330	}
	331	}
	332
	333	void wxToolBar::ToggleTool(int toolIndex, bool toggle)
	334	{
	335	wxNode *node = m_tools.Find((long)toolIndex);
	336	if (node)
	337	{
	338	wxToolBarTool tool = (wxToolBarTool )node->Data();
	339	if (tool->m_isToggle)
	340	{
	341	tool->m_toggleState = toggle;
1a3ac83f JS	342
	343	WXWidget widget = FindWidgetForIndex(tool->m_index);
	344	if (widget == (WXWidget) 0)
	345	return;
	346
	347	XmToggleButtonSetState((Widget) widget, (Boolean) toggle, False);
4bb6408c JS	348	}
	349	}
	350	}
	351
	352	void wxToolBar::ClearTools()
	353	{
0d57be45 JS	354	wxNode* node = m_widgets.First();
	355	while (node)
	356	{
	357	Widget button = (Widget) node->Data();
	358	XtDestroyWidget(button);
	359	node = node->Next();
	360	}
	361	m_widgets.Clear();
1a3ac83f	362	DestroyPixmaps();
0d57be45	363
4bb6408c JS	364	wxToolBarBase::ClearTools();
	365	}
	366
1a3ac83f JS	367	void wxToolBar::DestroyPixmaps()
	368	{
	369	wxNode* node = m_pixmaps.First();
	370	while (node)
	371	{
	372	Pixmap pixmap = (Pixmap) node->Data();
	373	XmDestroyPixmap (DefaultScreenOfDisplay ((Display*) GetXDisplay()), pixmap);
	374	node = node->Next();
	375	}
	376	m_pixmaps.Clear();
	377	}
	378
4bb6408c JS	379	// If pushedBitmap is NULL, a reversed version of bitmap is
	380	// created and used as the pushed/toggled image.
	381	// If toggle is TRUE, the button toggles between the two states.
	382
	383	wxToolBarTool *wxToolBar::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap,
	384	bool toggle, long xPos, long yPos, wxObject *clientData, const wxString& helpString1, const wxString& helpString2)
	385	{
	386	wxToolBarTool tool = new wxToolBarTool(index, bitmap, (wxBitmap )NULL, toggle, xPos, yPos, helpString1, helpString2);
	387	tool->m_clientData = clientData;
	388
	389	if (xPos > -1)
	390	tool->m_x = xPos;
	391	else
	392	tool->m_x = m_xMargin;
	393
	394	if (yPos > -1)
	395	tool->m_y = yPos;
	396	else
	397	tool->m_y = m_yMargin;
	398
	399	tool->SetSize(GetDefaultButtonWidth(), GetDefaultButtonHeight());
	400
	401	m_tools.Append((long)index, tool);
	402	return tool;
	403	}
	404
1a3ac83f JS	405	int wxToolBar::FindIndexForWidget(WXWidget w)
	406	{
	407	wxNode* node = m_widgets.First();
	408	while (node)
	409	{
	410	WXWidget widget = (WXWidget) node->Data();
	411	if (widget == w)
	412	return (int) node->key.integer;
	413	node = node->Next();
	414	}
	415	return -1;
	416	}
	417
	418	WXWidget wxToolBar::FindWidgetForIndex(int index)
	419	{
	420	wxNode* node = m_widgets.Find((long) index);
	421	if (!node)
	422	return (WXWidget) 0;
	423	else
	424	return (WXWidget) node->Data();
	425	}
	426
	427	void wxToolButtonCallback (Widget w, XtPointer clientData,
	428	XtPointer ptr)
	429	{
	430	wxToolBar toolBar = (wxToolBar ) clientData;
	431	int index = toolBar->FindIndexForWidget((WXWidget) w);
	432
	433	if (index != -1)
	434	{
	435	wxNode *node = toolBar->GetTools().Find((long)index);
	436	if (!node)
	437	return;
	438	wxToolBarTool tool = (wxToolBarTool )node->Data();
	439	if (tool->m_isToggle)
	440	tool->m_toggleState = toolBar->GetToolState(index);
	441
	442	(void) toolBar->OnLeftClick(index, tool->m_toggleState);
	443	}
	444
	445	}
	446
1a3ac83f JS	447
	448	static void wxToolButtonPopupCallback (Widget w, XtPointer client_data,
	449	XEvent event, Boolean continue_to_dispatch)
	450	{
	451	// TODO: retrieve delay before popping up tooltip from wxSystemSettings.
	452	int delayMilli = 800;
	453	wxToolBar* toolBar = (wxToolBar*) client_data;
	454
	455	int index = toolBar->FindIndexForWidget((WXWidget) w);
	456
	457	if (index != -1)
	458	{
	459	wxNode *node = toolBar->GetTools().Find((long)index);
	460	if (!node)
	461	return;
	462	wxToolBarTool tool = (wxToolBarTool )node->Data();
	463	wxString str(toolBar->GetToolShortHelp(index));
	464	if (str.IsNull() \|\| str == "")
	465	return;
	466
	467	if (!wxTheToolBarTimer)
	468	wxTheToolBarTimer = new wxToolBarTimer;
	469
	470	wxToolBarTimer::buttonWidget = w;
	471	wxToolBarTimer::helpString = str;
	472
	473
	474	/************************************************************/
	475	/* Popup help label */
	476	/************************************************************/
	477	if (event->type == EnterNotify)
	478	{
	479	if (wxToolBarTimer::help_popup != (Widget) 0)
	480	{
	481	XtDestroyWidget (wxToolBarTimer::help_popup);
	482	XtPopdown (wxToolBarTimer::help_popup);
	483	}
	484	wxToolBarTimer::help_popup = (Widget) 0;
	485
	486	// One shot
	487	wxTheToolBarTimer->Start(delayMilli, TRUE);
	488
	489	}
	490	/************************************************************/
	491	/* Popdown help label */
	492	/************************************************************/
	493	else if (event->type == LeaveNotify)
	494	{
	495	if (wxTheToolBarTimer)
	496	wxTheToolBarTimer->Stop();
	497	if (wxToolBarTimer::help_popup != (Widget) 0)
	498	{
	499	XtDestroyWidget (wxToolBarTimer::help_popup);
	500	XtPopdown (wxToolBarTimer::help_popup);
	501	}
	502	wxToolBarTimer::help_popup = (Widget) 0;
	503	}
	504	}
	505	}
	506
	507	void wxToolBarTimer::Notify()
	508	{
	509	Position x, y;
	510
511	/************************************************************/
512	/* Create shell without window decorations */
513	/************************************************************/
514	help_popup = XtVaCreatePopupShell ("shell",
515	overrideShellWidgetClass, (Widget) wxTheApp->GetTopLevelWidget(),
516	NULL);
517
518	/************************************************************/
519	/* Get absolute position on display of toolbar button */
520	/************************************************************/
521	XtTranslateCoords (buttonWidget,
522	(Position) 0,
523	(Position) 0,
524	&x, &y);
525
526	// Move the tooltip more or less above the button
527	int yOffset = 20; // TODO: What should be really?
528	y -= yOffset;
529	if (y < yOffset) y = 0;
530
531	/************************************************************/
532	/* Set the position of the help popup */
533	/************************************************************/
534	XtVaSetValues (help_popup,
535	XmNx, (Position) x,
536	XmNy, (Position) y,
537	NULL);
538
539	/************************************************************/
540	/* Create help label */
541	/************************************************************/
542	XmString text = XmStringCreateSimple ((char) (const char) helpString);
543	XtVaCreateManagedWidget ("help_label",
544	xmLabelWidgetClass, help_popup,
545	XmNlabelString, text,
546	XtVaTypedArg,
547	XmNforeground, XtRString, "black",
548	strlen("black")+1,
549	XtVaTypedArg,
550	XmNbackground, XtRString, "LightGoldenrod",
551	strlen("LightGoldenrod")+1,
552	NULL);
553	XmStringFree (text);
554
555	/************************************************************/
556	/* Popup help label */
557	/************************************************************/
558	XtPopup (help_popup, XtGrabNone);
559	}
560