src/motif/toolbar.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/motif/toolbar.cpp
// Purpose:     wxToolBar
// Author:      Julian Smart
// 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
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.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/Label.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"

// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)

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

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

class wxToolBarTimer : public wxTimer
{
public:
    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();
    }

    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;

// ============================================================================
// 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);
}

void wxToolBarTool::Init()
{
    m_widget = (Widget)0;
}

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;
    m_toolPacking = 2;
    m_toolSeparation = 8;
    m_xMargin = 2;
    m_yMargin = 2;
    m_maxRows = 100;
    m_maxCols = 100;
}

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;

    m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);

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

    Widget toolbar = XtVaCreateManagedWidget("toolbar",
                    xmBulletinBoardWidgetClass, (Widget) parentWidget,
                    XmNmarginWidth, 0,
                    XmNmarginHeight, 0,
                    XmNresizePolicy, XmRESIZE_NONE,
                    NULL);
/*
    Widget toolbar = XtVaCreateManagedWidget("toolbar",
                xmFormWidgetClass, (Widget) m_clientWidget,
                XmNtraversalOn, False,
                XmNhorizontalSpacing, 0,
                XmNverticalSpacing, 0,
                XmNleftOffset, 0,
                XmNrightOffset, 0,
                XmNmarginWidth, 0,
                XmNmarginHeight, 0,
                NULL);
*/

    m_mainWidget = (WXWidget) toolbar;

    ChangeFont(false);

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

    return true;
}

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

bool wxToolBar::Realize()
{
    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, buttonWidth = 0;

    Widget button;
    Pixmap pixmap, insensPixmap;
    wxBitmap bmp, insensBmp;

    wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
    while ( node )
    {
        wxToolBarTool *tool = (wxToolBarTool *)node->GetData();

        switch ( tool->GetStyle() )
        {
            case wxTOOL_STYLE_CONTROL:
            {
                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;

                break;
            }
            case wxTOOL_STYLE_SEPARATOR:
                // skip separators for vertical toolbars
                if( !isVertical )
                {
                    currentX += separatorSize;
                }
                break;

            case wxTOOL_STYLE_BUTTON:
                button = (Widget) 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( !tool->GetButtonWidget() )
                {
                    wxDoChangeBackgroundColour((WXWidget) button,
                                               m_backgroundColour, true);

                    tool->SetWidget(button);
                }
                else
                {
                    button = (Widget)tool->GetButtonWidget();
                    XtVaSetValues( button,
                                   XmNx, currentX, XmNy, currentY,
                                   NULL );
                }

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

                XtManageChild(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);

                break;
        }

        node = node->GetNext();
    }

    SetSize( -1, -1,
             isVertical ? buttonWidth + 2 * marginX : -1,
             isVertical ? -1 : buttonHeight +  2*marginY );

    return true;
}

wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x),
                                                  wxCoord WXUNUSED(y)) const
{
    wxFAIL_MSG( _T("TODO") );

    return (wxToolBarToolBase *)NULL;
}

bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
{
    tool->Attach(this);

    return true;
}

bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
{
    tool->Detach();

    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 *t = (wxToolBarTool*)node->GetData();

        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;

                XtVaGetValues( w,
                               XmNwidth, &width,
                               XmNheight, &height,
                               NULL );

                offset = isVertical ? height : width;
                offset += packing;
                break;
            }
            }
        }
        else if( offset )
        {
            switch ( t->GetStyle() )
            {
            case wxTOOL_STYLE_CONTROL:
            {
                wxPoint location = t->GetControl()->GetPosition();

                if( isVertical )
                    location.y -= offset;
                else
                    location.x -= offset;

                t->GetControl()->Move( location );
                break;
            }
            case wxTOOL_STYLE_SEPARATOR:
                break;
            case wxTOOL_STYLE_BUTTON:
            {
                Dimension x, y;
                XtVaGetValues( t->GetButtonWidget(),
                               XmNx, &x,
                               XmNy, &y,
                               NULL );

                if( isVertical )
                    y = (Dimension)(y - offset);
                else
                    x = (Dimension)(x - offset);

                XtVaSetValues( t->GetButtonWidget(),
                               XmNx, x,
                               XmNy, y,
                               NULL );
                break;
            }
            }
        }
    }

    return true;
}

void wxToolBar::DoEnableTool(wxToolBarToolBase *toolBase, bool enable)
{
    wxToolBarTool *tool = (wxToolBarTool *)toolBase;
    if (tool->GetButtonWidget()){
        XtSetSensitive(tool->GetButtonWidget(), (Boolean) enable);
    } else if (wxTOOL_STYLE_CONTROL == tool->GetStyle()){
        // Controls (such as wxChoice) do not have button widgets
        tool->GetControl()->Enable(enable);
    }
}

void wxToolBar::DoToggleTool(wxToolBarToolBase *toolBase, bool toggle)
{
    wxToolBarTool *tool = (wxToolBarTool *)toolBase;

    XmToggleButtonSetState(tool->GetButtonWidget(), (Boolean) toggle, False);
}

void wxToolBar::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
                            bool WXUNUSED(toggle))
{
    // nothing to do
}

void wxToolBar::DoSetSize(int x, int y, int width, int height, int sizeFlags)
{
    int old_width, old_height;
    GetSize(&old_width, &old_height);

    // Correct width and height if needed.
    if ( width == -1 || height == -1 )
    {
        wxSize defaultSize = GetSize();

        if ( width == -1 )
            width = defaultSize.x;
        if ( height == -1 )
            height = defaultSize.y;
    }

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

// ----------------------------------------------------------------------------
// Motif callbacks
// ----------------------------------------------------------------------------

wxToolBarToolBase *wxToolBar::FindToolByWidget(WXWidget w) const
{
    wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
    while ( node )
    {
        wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
        if ( tool->GetButtonWidget() == w)
        {
            return tool;
        }

        node = node->GetNext();
    }

    return (wxToolBarToolBase *)NULL;
}

static void wxToolButtonCallback(Widget w,
                                 XtPointer clientData,
                                 XtPointer WXUNUSED(ptr))
{
    wxToolBar *toolBar = (wxToolBar *) clientData;
    wxToolBarToolBase *tool = toolBar->FindToolByWidget((WXWidget) w);
    if ( !tool )
        return;

    if ( tool->CanBeToggled() )
        tool->Toggle();

    if ( !toolBar->OnLeftClick(tool->GetId(), tool->IsToggled()) )
    {
        // revert
        tool->Toggle();
    }
}


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

    wxToolBar* toolBar = (wxToolBar*) client_data;
    wxToolBarToolBase *tool = toolBar->FindToolByWidget((WXWidget) w);

    if ( !tool )
        return;

    wxString tooltip = tool->GetShortHelp();
    if ( !tooltip )
        return;

    if (!wxTheToolBarTimer)
        wxTheToolBarTimer = new wxToolBarTimer;

    wxToolBarTimer::buttonWidget = w;
    wxToolBarTimer::helpString = tooltip;

    /************************************************************/
    /* 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 = (Position)(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
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/motif/toolbar.cpp
	3	// Purpose: wxToolBar
	4	// Author: Julian Smart
	5	// Modified by: 13.12.99 by VZ during toolbar classes reorganization
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __VMS
	24	#define XtDisplay XTDISPLAY
	25	#endif
	26
	27	#include "wx/settings.h"
	28	#include "wx/app.h"
	29	#include "wx/timer.h"
	30	#include "wx/toolbar.h"
	31	#include "wx/frame.h"
	32
	33	#ifdef __VMS__
	34	#pragma message disable nosimpint
	35	#endif
	36	#include <Xm/Xm.h>
	37	#include <Xm/PushBG.h>
	38	#include <Xm/PushB.h>
	39	#include <Xm/Label.h>
	40	#include <Xm/ToggleB.h>
	41	#include <Xm/ToggleBG.h>
	42	#include <Xm/Form.h>
	43	#ifdef __VMS__
	44	#pragma message enable nosimpint
	45	#endif
	46
	47	#include "wx/motif/private.h"
	48	#include "wx/motif/bmpmotif.h"
	49
	50	// ----------------------------------------------------------------------------
	51	// wxWin macros
	52	// ----------------------------------------------------------------------------
	53
	54	IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
	55
	56	// ----------------------------------------------------------------------------
	57	// private functions
	58	// ----------------------------------------------------------------------------
	59
	60	static void wxToolButtonCallback (Widget w, XtPointer clientData,
	61	XtPointer ptr);
	62	static void wxToolButtonPopupCallback (Widget w, XtPointer client_data,
	63	XEvent event, Boolean continue_to_dispatch);
	64
	65	// ----------------------------------------------------------------------------
	66	// private classes
	67	// ----------------------------------------------------------------------------
	68
	69	class wxToolBarTimer : public wxTimer
	70	{
	71	public:
	72	virtual void Notify();
	73
	74	static Widget help_popup;
	75	static Widget buttonWidget;
	76	static wxString helpString;
	77	};
	78
	79	class wxToolBarTool : public wxToolBarToolBase
	80	{
	81	public:
	82	wxToolBarTool(wxToolBar *tbar,
	83	int id,
	84	const wxString& label,
	85	const wxBitmap& bmpNormal,
	86	const wxBitmap& bmpToggled,
	87	wxItemKind kind,
	88	wxObject *clientData,
	89	const wxString& shortHelp,
	90	const wxString& longHelp)
	91	: wxToolBarToolBase(tbar, id, label, bmpNormal, bmpToggled, kind,
	92	clientData, shortHelp, longHelp)
	93	{
	94	Init();
	95	}
	96
	97	wxToolBarTool(wxToolBar tbar, wxControl control)
	98	: wxToolBarToolBase(tbar, control)
	99	{
	100	Init();
	101	}
	102
	103	virtual ~wxToolBarTool();
	104
	105	// accessors
	106	void SetWidget(Widget widget) { m_widget = widget; }
	107	Widget GetButtonWidget() const { return m_widget; }
	108
	109	Pixmap GetArmPixmap()
	110	{
	111	m_bitmapCache.SetBitmap( GetNormalBitmap() );
	112	return (Pixmap)m_bitmapCache.GetArmPixmap( (WXWidget)m_widget );
	113	}
	114
	115	Pixmap GetInsensPixmap()
	116	{
	117	m_bitmapCache.SetBitmap( GetNormalBitmap() );
	118	return (Pixmap)m_bitmapCache.GetInsensPixmap( (WXWidget)m_widget );
	119	}
	120	protected:
	121	void Init();
	122
	123	Widget m_widget;
	124	wxBitmapCache m_bitmapCache;
	125	};
	126
	127	// ----------------------------------------------------------------------------
	128	// globals
	129	// ----------------------------------------------------------------------------
	130
	131	static wxToolBarTimer* wxTheToolBarTimer = (wxToolBarTimer*) NULL;
	132
	133	Widget wxToolBarTimer::help_popup = (Widget) 0;
	134	Widget wxToolBarTimer::buttonWidget = (Widget) 0;
	135	wxString wxToolBarTimer::helpString;
	136
	137	// ============================================================================
	138	// implementation
	139	// ============================================================================
	140
	141	// ----------------------------------------------------------------------------
	142	// wxToolBarTool
	143	// ----------------------------------------------------------------------------
	144
	145	wxToolBarToolBase *wxToolBar::CreateTool(int id,
	146	const wxString& label,
	147	const wxBitmap& bmpNormal,
	148	const wxBitmap& bmpToggled,
	149	wxItemKind kind,
	150	wxObject *clientData,
	151	const wxString& shortHelp,
	152	const wxString& longHelp)
	153	{
	154	return new wxToolBarTool(this, id, label, bmpNormal, bmpToggled, kind,
	155	clientData, shortHelp, longHelp);
	156	}
	157
	158
	159	wxToolBarToolBase wxToolBar::CreateTool(wxControl control)
	160	{
	161	return new wxToolBarTool(this, control);
	162	}
	163
	164	void wxToolBarTool::Init()
	165	{
	166	m_widget = (Widget)0;
	167	}
	168
	169	wxToolBarTool::~wxToolBarTool()
	170	{
	171	if ( m_widget )
	172	XtDestroyWidget(m_widget);
	173	}
	174
	175	// ----------------------------------------------------------------------------
	176	// wxToolBar construction
	177	// ----------------------------------------------------------------------------
	178
	179	void wxToolBar::Init()
	180	{
	181	m_maxWidth = -1;
	182	m_maxHeight = -1;
	183	m_defaultWidth = 24;
	184	m_defaultHeight = 22;
	185	m_toolPacking = 2;
	186	m_toolSeparation = 8;
	187	m_xMargin = 2;
	188	m_yMargin = 2;
	189	m_maxRows = 100;
	190	m_maxCols = 100;
	191	}
	192
	193	bool wxToolBar::Create(wxWindow *parent,
	194	wxWindowID id,
	195	const wxPoint& pos,
	196	const wxSize& size,
	197	long style,
	198	const wxString& name)
	199	{
	200	if( !wxControl::CreateControl( parent, id, pos, size, style,
	201	wxDefaultValidator, name ) )
	202	return false;
	203
	204	m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
	205
	206	Widget parentWidget = (Widget) parent->GetClientWidget();
	207
	208	Widget toolbar = XtVaCreateManagedWidget("toolbar",
	209	xmBulletinBoardWidgetClass, (Widget) parentWidget,
	210	XmNmarginWidth, 0,
	211	XmNmarginHeight, 0,
	212	XmNresizePolicy, XmRESIZE_NONE,
	213	NULL);
	214	/*
	215	Widget toolbar = XtVaCreateManagedWidget("toolbar",
	216	xmFormWidgetClass, (Widget) m_clientWidget,
	217	XmNtraversalOn, False,
	218	XmNhorizontalSpacing, 0,
	219	XmNverticalSpacing, 0,
	220	XmNleftOffset, 0,
	221	XmNrightOffset, 0,
	222	XmNmarginWidth, 0,
	223	XmNmarginHeight, 0,
	224	NULL);
	225	*/
	226
	227	m_mainWidget = (WXWidget) toolbar;
	228
	229	ChangeFont(false);
	230
	231	wxPoint rPos = pos;
	232	wxSize rSize = size;
	233
	234	if( rPos.x == -1 ) rPos.x = 0;
	235	if( rPos.y == -1 ) rPos.y = 0;
	236	if( rSize.x == -1 && GetParent() )
	237	rSize.x = GetParent()->GetSize().x;
	238
	239	AttachWidget (parent, m_mainWidget, (WXWidget) NULL,
	240	rPos.x, rPos.y, rSize.x, rSize.y);
	241
	242	ChangeBackgroundColour();
	243
	244	return true;
	245	}
	246
	247	wxToolBar::~wxToolBar()
	248	{
	249	delete wxTheToolBarTimer;
	250	wxTheToolBarTimer = NULL;
	251	}
	252
	253	bool wxToolBar::Realize()
	254	{
	255	if ( m_tools.GetCount() == 0 )
	256	{
	257	// nothing to do
	258	return true;
	259	}
	260
	261	bool isVertical = GetWindowStyle() & wxTB_VERTICAL;
	262
	263	// Separator spacing
	264	const int separatorSize = GetToolSeparation(); // 8;
	265	wxSize margins = GetToolMargins();
	266	int packing = GetToolPacking();
	267	int marginX = margins.x;
	268	int marginY = margins.y;
	269
	270	int currentX = marginX;
	271	int currentY = marginY;
	272
	273	int buttonHeight = 0, buttonWidth = 0;
	274
	275	Widget button;
	276	Pixmap pixmap, insensPixmap;
	277	wxBitmap bmp, insensBmp;
	278
	279	wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
	280	while ( node )
	281	{
	282	wxToolBarTool tool = (wxToolBarTool )node->GetData();
	283
	284	switch ( tool->GetStyle() )
	285	{
	286	case wxTOOL_STYLE_CONTROL:
	287	{
	288	wxControl* control = tool->GetControl();
	289	wxSize sz = control->GetSize();
	290	wxPoint pos = control->GetPosition();
	291	// Allow a control to specify a y[x]-offset by setting
	292	// its initial position, but still don't allow it to
	293	// position itself above the top[left] margin.
	294	int controlY = (pos.y > 0) ? pos.y : currentY;
	295	int controlX = (pos.x > 0) ? pos.x : currentX;
	296	control->Move( isVertical ? controlX : currentX,
	297	isVertical ? currentY : controlY );
	298	if ( isVertical )
	299	currentY += sz.y + packing;
	300	else
	301	currentX += sz.x + packing;
	302
	303	break;
	304	}
	305	case wxTOOL_STYLE_SEPARATOR:
	306	// skip separators for vertical toolbars
	307	if( !isVertical )
	308	{
	309	currentX += separatorSize;
	310	}
	311	break;
	312
	313	case wxTOOL_STYLE_BUTTON:
	314	button = (Widget) 0;
	315
	316	if ( tool->CanBeToggled() && !tool->GetButtonWidget() )
	317	{
	318	button = XtVaCreateWidget("toggleButton",
	319	xmToggleButtonWidgetClass, (Widget) m_mainWidget,
	320	XmNx, currentX, XmNy, currentY,
	321	XmNindicatorOn, False,
	322	XmNshadowThickness, 2,
	323	XmNborderWidth, 0,
	324	XmNspacing, 0,
	325	XmNmarginWidth, 0,
	326	XmNmarginHeight, 0,
	327	XmNmultiClick, XmMULTICLICK_KEEP,
	328	XmNlabelType, XmPIXMAP,
	329	NULL);
	330	XtAddCallback ((Widget) button,
	331	XmNvalueChangedCallback,
	332	(XtCallbackProc) wxToolButtonCallback,
	333	(XtPointer) this);
	334
	335	XtVaSetValues ((Widget) button,
	336	XmNselectColor,
	337	m_backgroundColour.AllocColour
	338	(XtDisplay((Widget) button)),
	339	NULL);
	340	}
	341	else if( !tool->GetButtonWidget() )
	342	{
	343	button = XtVaCreateWidget("button",
	344	xmPushButtonWidgetClass, (Widget) m_mainWidget,
	345	XmNx, currentX, XmNy, currentY,
	346	XmNpushButtonEnabled, True,
	347	XmNmultiClick, XmMULTICLICK_KEEP,
	348	XmNlabelType, XmPIXMAP,
	349	NULL);
	350	XtAddCallback (button,
	351	XmNactivateCallback,
	352	(XtCallbackProc) wxToolButtonCallback,
	353	(XtPointer) this);
	354	}
	355
	356	if( !tool->GetButtonWidget() )
	357	{
	358	wxDoChangeBackgroundColour((WXWidget) button,
	359	m_backgroundColour, true);
	360
	361	tool->SetWidget(button);
	362	}
	363	else
	364	{
	365	button = (Widget)tool->GetButtonWidget();
	366	XtVaSetValues( button,
	367	XmNx, currentX, XmNy, currentY,
	368	NULL );
	369	}
	370
	371	// For each button, if there is a mask, we must create
	372	// a new wxBitmap that has the correct background colour
	373	// for the button. Otherwise the background will just be
	374	// e.g. black if a transparent XPM has been loaded.
	375	bmp = tool->GetNormalBitmap();
	376	insensBmp = tool->GetDisabledBitmap();
	377	if ( bmp.GetMask() \|\| insensBmp.GetMask() )
	378	{
	379	int backgroundPixel;
	380	XtVaGetValues(button, XmNbackground, &backgroundPixel,
	381	NULL);
	382
	383	wxColour col;
	384	col.SetPixel(backgroundPixel);
	385
	386	if( bmp.Ok() && bmp.GetMask() )
	387	{
	388	bmp = wxCreateMaskedBitmap(bmp, col);
	389	tool->SetNormalBitmap(bmp);
	390	}
	391
	392	if( insensBmp.Ok() && insensBmp.GetMask() )
	393	{
	394	insensBmp = wxCreateMaskedBitmap(insensBmp, col);
	395	tool->SetDisabledBitmap(insensBmp);
	396	}
	397	}
	398
	399	// Create a selected/toggled bitmap. If there isn't a 2nd
	400	// bitmap, we need to create it (with a darker, selected
	401	// background)
	402	int backgroundPixel;
	403	if ( tool->CanBeToggled() )
	404	XtVaGetValues(button, XmNselectColor, &backgroundPixel,
	405	NULL);
	406	else
	407	XtVaGetValues(button, XmNarmColor, &backgroundPixel,
	408	NULL);
	409	wxColour col;
	410	col.SetPixel(backgroundPixel);
	411
	412	pixmap = (Pixmap) bmp.GetDrawable();
	413	{
	414	wxBitmap tmp = tool->GetDisabledBitmap();
	415
	416	insensPixmap = tmp.Ok() ?
	417	(Pixmap)tmp.GetDrawable() :
	418	tool->GetInsensPixmap();
	419	}
	420
	421	if (tool->CanBeToggled())
	422	{
	423	// Toggle button
	424	Pixmap pixmap2 = tool->GetArmPixmap();
	425	Pixmap insensPixmap2 = tool->GetInsensPixmap();
	426
	427	XtVaSetValues (button,
	428	XmNfillOnSelect, True,
	429	XmNlabelPixmap, pixmap,
	430	XmNselectPixmap, pixmap2,
	431	XmNlabelInsensitivePixmap, insensPixmap,
	432	XmNselectInsensitivePixmap, insensPixmap2,
	433	XmNlabelType, XmPIXMAP,
	434	NULL);
	435	}
	436	else
	437	{
	438	Pixmap pixmap2 = tool->GetArmPixmap();
	439
	440	// Normal button
	441	XtVaSetValues(button,
	442	XmNlabelPixmap, pixmap,
	443	XmNlabelInsensitivePixmap, insensPixmap,
	444	XmNarmPixmap, pixmap2,
	445	NULL);
	446	}
	447
	448	XtManageChild(button);
	449
	450	{
	451	Dimension width, height;
	452	XtVaGetValues(button,
	453	XmNwidth, &width,
	454	XmNheight, & height,
	455	NULL);
	456	if ( isVertical )
	457	currentY += height + packing;
	458	else
	459	currentX += width + packing;
	460	buttonHeight = wxMax(buttonHeight, height);
	461	buttonWidth = wxMax(buttonWidth, width);
	462	}
	463
	464	XtAddEventHandler (button, EnterWindowMask \| LeaveWindowMask,
	465	False, wxToolButtonPopupCallback, (XtPointer) this);
	466
	467	break;
	468	}
	469
	470	node = node->GetNext();
	471	}
	472
	473	SetSize( -1, -1,
	474	isVertical ? buttonWidth + 2 * marginX : -1,
	475	isVertical ? -1 : buttonHeight + 2*marginY );
	476
	477	return true;
	478	}
	479
	480	wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x),
	481	wxCoord WXUNUSED(y)) const
	482	{
	483	wxFAIL_MSG( _T("TODO") );
	484
	485	return (wxToolBarToolBase *)NULL;
	486	}
	487
	488	bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
	489	{
	490	tool->Attach(this);
	491
	492	return true;
	493	}
	494
	495	bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
	496	{
	497	tool->Detach();
	498
	499	bool isVertical = GetWindowStyle() & wxTB_VERTICAL;
	500	const int separatorSize = GetToolSeparation(); // 8;
	501	int packing = GetToolPacking();
	502	int offset = 0;
	503
	504	for( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
	505	node; node = node->GetNext() )
	506	{
	507	wxToolBarTool t = (wxToolBarTool)node->GetData();
	508
	509	if( t == tool )
	510	{
	511	switch ( t->GetStyle() )
	512	{
	513	case wxTOOL_STYLE_CONTROL:
	514	{
	515	wxSize size = t->GetControl()->GetSize();
	516	offset = isVertical ? size.y : size.x;
	517	offset += packing;
	518	break;
	519	}
	520	case wxTOOL_STYLE_SEPARATOR:
	521	offset = isVertical ? 0 : separatorSize;
	522	break;
	523	case wxTOOL_STYLE_BUTTON:
	524	{
	525	Widget w = t->GetButtonWidget();
	526	Dimension width, height;
	527
	528	XtVaGetValues( w,
	529	XmNwidth, &width,
	530	XmNheight, &height,
	531	NULL );
	532
	533	offset = isVertical ? height : width;
	534	offset += packing;
	535	break;
	536	}
	537	}
	538	}
	539	else if( offset )
	540	{
	541	switch ( t->GetStyle() )
	542	{
	543	case wxTOOL_STYLE_CONTROL:
	544	{
	545	wxPoint location = t->GetControl()->GetPosition();
	546
	547	if( isVertical )
	548	location.y -= offset;
	549	else
	550	location.x -= offset;
	551
	552	t->GetControl()->Move( location );
	553	break;
	554	}
	555	case wxTOOL_STYLE_SEPARATOR:
	556	break;
	557	case wxTOOL_STYLE_BUTTON:
	558	{
	559	Dimension x, y;
	560	XtVaGetValues( t->GetButtonWidget(),
	561	XmNx, &x,
	562	XmNy, &y,
	563	NULL );
	564
	565	if( isVertical )
	566	y = (Dimension)(y - offset);
	567	else
	568	x = (Dimension)(x - offset);
	569
	570	XtVaSetValues( t->GetButtonWidget(),
	571	XmNx, x,
	572	XmNy, y,
	573	NULL );
	574	break;
	575	}
	576	}
	577	}
	578	}
	579
	580	return true;
	581	}
	582
	583	void wxToolBar::DoEnableTool(wxToolBarToolBase *toolBase, bool enable)
	584	{
	585	wxToolBarTool tool = (wxToolBarTool )toolBase;
	586	if (tool->GetButtonWidget()){
	587	XtSetSensitive(tool->GetButtonWidget(), (Boolean) enable);
	588	} else if (wxTOOL_STYLE_CONTROL == tool->GetStyle()){
	589	// Controls (such as wxChoice) do not have button widgets
	590	tool->GetControl()->Enable(enable);
	591	}
	592	}
	593
	594	void wxToolBar::DoToggleTool(wxToolBarToolBase *toolBase, bool toggle)
	595	{
	596	wxToolBarTool tool = (wxToolBarTool )toolBase;
	597
	598	XmToggleButtonSetState(tool->GetButtonWidget(), (Boolean) toggle, False);
	599	}
	600
	601	void wxToolBar::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
	602	bool WXUNUSED(toggle))
	603	{
	604	// nothing to do
	605	}
	606
	607	void wxToolBar::DoSetSize(int x, int y, int width, int height, int sizeFlags)
	608	{
	609	int old_width, old_height;
	610	GetSize(&old_width, &old_height);
	611
	612	// Correct width and height if needed.
	613	if ( width == -1 \|\| height == -1 )
	614	{
	615	wxSize defaultSize = GetSize();
	616
	617	if ( width == -1 )
	618	width = defaultSize.x;
	619	if ( height == -1 )
	620	height = defaultSize.y;
	621	}
	622
	623	wxToolBarBase::DoSetSize(x, y, width, height, sizeFlags);
	624
	625	// We must refresh the frame size when the toolbar changes size
	626	// otherwise the toolbar can be shown incorrectly
	627	if ( old_width != width \|\| old_height != height )
	628	{
	629	// But before we send the size event check it
	630	// we have a frame that is not being deleted.
	631	wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
	632	if ( frame && !frame->IsBeingDeleted() )
	633	{
	634	frame->SendSizeEvent();
	635	}
	636	}
	637	}
	638
	639	// ----------------------------------------------------------------------------
	640	// Motif callbacks
	641	// ----------------------------------------------------------------------------
	642
	643	wxToolBarToolBase *wxToolBar::FindToolByWidget(WXWidget w) const
	644	{
	645	wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
	646	while ( node )
	647	{
	648	wxToolBarTool tool = (wxToolBarTool )node->GetData();
	649	if ( tool->GetButtonWidget() == w)
	650	{
	651	return tool;
	652	}
	653
	654	node = node->GetNext();
	655	}
	656
	657	return (wxToolBarToolBase *)NULL;
	658	}
	659
	660	static void wxToolButtonCallback(Widget w,
	661	XtPointer clientData,
	662	XtPointer WXUNUSED(ptr))
	663	{
	664	wxToolBar toolBar = (wxToolBar ) clientData;
	665	wxToolBarToolBase *tool = toolBar->FindToolByWidget((WXWidget) w);
	666	if ( !tool )
	667	return;
	668
	669	if ( tool->CanBeToggled() )
	670	tool->Toggle();
	671
	672	if ( !toolBar->OnLeftClick(tool->GetId(), tool->IsToggled()) )
	673	{
	674	// revert
	675	tool->Toggle();
	676	}
	677	}
	678
	679
	680	static void wxToolButtonPopupCallback(Widget w,
	681	XtPointer client_data,
	682	XEvent *event,
	683	Boolean *WXUNUSED(continue_to_dispatch))
	684	{
	685	// TODO: retrieve delay before popping up tooltip from wxSystemSettings.
	686	static const int delayMilli = 800;
	687
	688	wxToolBar* toolBar = (wxToolBar*) client_data;
	689	wxToolBarToolBase *tool = toolBar->FindToolByWidget((WXWidget) w);
	690
	691	if ( !tool )
	692	return;
	693
	694	wxString tooltip = tool->GetShortHelp();
	695	if ( !tooltip )
	696	return;
	697
	698	if (!wxTheToolBarTimer)
	699	wxTheToolBarTimer = new wxToolBarTimer;
	700
	701	wxToolBarTimer::buttonWidget = w;
	702	wxToolBarTimer::helpString = tooltip;
	703
	704	/************************************************************/
	705	/* Popup help label */
	706	/************************************************************/
	707	if (event->type == EnterNotify)
	708	{
	709	if (wxToolBarTimer::help_popup != (Widget) 0)
	710	{
	711	XtDestroyWidget (wxToolBarTimer::help_popup);
	712	XtPopdown (wxToolBarTimer::help_popup);
	713	}
	714	wxToolBarTimer::help_popup = (Widget) 0;
	715
	716	// One shot
	717	wxTheToolBarTimer->Start(delayMilli, true);
	718
	719	}
	720	/************************************************************/
	721	/* Popdown help label */
	722	/************************************************************/
	723	else if (event->type == LeaveNotify)
	724	{
	725	if (wxTheToolBarTimer)
	726	wxTheToolBarTimer->Stop();
	727	if (wxToolBarTimer::help_popup != (Widget) 0)
	728	{
	729	XtDestroyWidget (wxToolBarTimer::help_popup);
	730	XtPopdown (wxToolBarTimer::help_popup);
	731	}
	732	wxToolBarTimer::help_popup = (Widget) 0;
	733	}
	734	}
	735
	736	void wxToolBarTimer::Notify()
	737	{
	738	Position x, y;
	739
	740	/************************************************************/
	741	/* Create shell without window decorations */
	742	/************************************************************/
	743	help_popup = XtVaCreatePopupShell ("shell",
	744	overrideShellWidgetClass, (Widget) wxTheApp->GetTopLevelWidget(),
	745	NULL);
	746
	747	/************************************************************/
	748	/* Get absolute position on display of toolbar button */
	749	/************************************************************/
	750	XtTranslateCoords (buttonWidget,
	751	(Position) 0,
	752	(Position) 0,
	753	&x, &y);
	754
	755	// Move the tooltip more or less above the button
	756	int yOffset = 20; // TODO: What should be really?
	757	y = (Position)(y - yOffset);
	758	if (y < yOffset) y = 0;
	759
	760	/************************************************************/
	761	/* Set the position of the help popup */
	762	/************************************************************/
	763	XtVaSetValues (help_popup,
	764	XmNx, (Position) x,
	765	XmNy, (Position) y,
	766	NULL);
	767
	768	/************************************************************/
	769	/* Create help label */
	770	/************************************************************/
	771	XmString text = XmStringCreateSimple ((char) (const char) helpString);
	772	XtVaCreateManagedWidget ("help_label",
	773	xmLabelWidgetClass, help_popup,
	774	XmNlabelString, text,
	775	XtVaTypedArg,
	776	XmNforeground, XtRString, "black",
	777	strlen("black")+1,
	778	XtVaTypedArg,
	779	XmNbackground, XtRString, "LightGoldenrod",
	780	strlen("LightGoldenrod")+1,
	781	NULL);
	782	XmStringFree (text);
	783
	784	/************************************************************/
	785	/* Popup help label */
	786	/************************************************************/
	787	XtPopup (help_popup, XtGrabNone);
	788	}
	789