src/common/tbarbase.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/tbarbase.cpp
// Purpose:     wxToolBarBase implementation
// Author:      Julian Smart
// Modified by: VZ at 11.12.99 (wxScrollableToolBar split off)
// 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 __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_TOOLBAR

#include "wx/toolbar.h"

#ifndef WX_PRECOMP
    #include "wx/control.h"
    #include "wx/frame.h"
    #include "wx/settings.h"
    #include "wx/image.h"
#endif

// ----------------------------------------------------------------------------
// wxWidgets macros
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
END_EVENT_TABLE()

#include "wx/listimpl.cpp"

WX_DEFINE_LIST(wxToolBarToolsList)

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxToolBarToolBase
// ----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxToolBarToolBase, wxObject)

bool wxToolBarToolBase::Enable(bool enable)
{
    if ( m_enabled == enable )
        return false;

    m_enabled = enable;

    return true;
}

bool wxToolBarToolBase::Toggle(bool toggle)
{
    wxASSERT_MSG( CanBeToggled(), _T("can't toggle this tool") );

    if ( m_toggled == toggle )
        return false;

    m_toggled = toggle;

    return true;
}

bool wxToolBarToolBase::SetToggle(bool toggle)
{
    wxItemKind kind = toggle ? wxITEM_CHECK : wxITEM_NORMAL;
    if ( m_kind == kind )
        return false;

    m_kind = kind;

    return true;
}

bool wxToolBarToolBase::SetShortHelp(const wxString& help)
{
    if ( m_shortHelpString == help )
        return false;

    m_shortHelpString = help;

    return true;
}

bool wxToolBarToolBase::SetLongHelp(const wxString& help)
{
    if ( m_longHelpString == help )
        return false;

    m_longHelpString = help;

    return true;
}

// ----------------------------------------------------------------------------
// wxToolBarBase adding/deleting items
// ----------------------------------------------------------------------------

wxToolBarBase::wxToolBarBase()
{
    // the list owns the pointers
    m_xMargin = m_yMargin = 0;
    m_maxRows = m_maxCols = 0;
    m_toolPacking = m_toolSeparation = 0;
    m_defaultWidth = 16;
    m_defaultHeight = 15;
}

void wxToolBarBase::FixupStyle()
{
    if ( !HasFlag(wxTB_TOP | wxTB_LEFT | wxTB_RIGHT | wxTB_BOTTOM) )
    {
        // this is the default
        m_windowStyle |= wxTB_TOP;
    }
}

wxToolBarToolBase *wxToolBarBase::DoAddTool(int id,
                                            const wxString& label,
                                            const wxBitmap& bitmap,
                                            const wxBitmap& bmpDisabled,
                                            wxItemKind kind,
                                            const wxString& shortHelp,
                                            const wxString& longHelp,
                                            wxObject *clientData,
                                            wxCoord WXUNUSED(xPos),
                                            wxCoord WXUNUSED(yPos))
{
    InvalidateBestSize();
    return InsertTool(GetToolsCount(), id, label, bitmap, bmpDisabled,
                      kind, shortHelp, longHelp, clientData);
}

wxToolBarToolBase *wxToolBarBase::InsertTool(size_t pos,
                                             int id,
                                             const wxString& label,
                                             const wxBitmap& bitmap,
                                             const wxBitmap& bmpDisabled,
                                             wxItemKind kind,
                                             const wxString& shortHelp,
                                             const wxString& longHelp,
                                             wxObject *clientData)
{
    wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
                 _T("invalid position in wxToolBar::InsertTool()") );

    wxToolBarToolBase *tool = CreateTool(id, label, bitmap, bmpDisabled, kind,
                                         clientData, shortHelp, longHelp);

    if ( !InsertTool(pos, tool) )
    {
        delete tool;

        return NULL;
    }

    return tool;
}

wxToolBarToolBase *wxToolBarBase::AddTool(wxToolBarToolBase *tool)
{
    return InsertTool(GetToolsCount(), tool);
}

wxToolBarToolBase *
wxToolBarBase::InsertTool(size_t pos, wxToolBarToolBase *tool)
{
    wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
                 _T("invalid position in wxToolBar::InsertTool()") );

    if ( !tool || !DoInsertTool(pos, tool) )
    {
        return NULL;
    }

    m_tools.Insert(pos, tool);

    return tool;
}

wxToolBarToolBase *wxToolBarBase::AddControl(wxControl *control)
{
    return InsertControl(GetToolsCount(), control);
}

wxToolBarToolBase *wxToolBarBase::InsertControl(size_t pos, wxControl *control)
{
    wxCHECK_MSG( control, (wxToolBarToolBase *)NULL,
                 _T("toolbar: can't insert NULL control") );

    wxCHECK_MSG( control->GetParent() == this, (wxToolBarToolBase *)NULL,
                 _T("control must have toolbar as parent") );

    wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
                 _T("invalid position in wxToolBar::InsertControl()") );

    wxToolBarToolBase *tool = CreateTool(control);

    if ( !InsertTool(pos, tool) )
    {
        delete tool;

        return NULL;
    }

    return tool;
}

wxControl *wxToolBarBase::FindControl( int id )
{
    for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
          node;
          node = node->GetNext() )
    {
        const wxToolBarToolBase * const tool = node->GetData();
        if ( tool->IsControl() )
        {
            wxControl * const control = tool->GetControl();

            if ( !control )
            {
                wxFAIL_MSG( _T("NULL control in toolbar?") );
            }
            else if ( control->GetId() == id )
            {
                // found
                return control;
            }
        }
    }

   return NULL;
}

wxToolBarToolBase *wxToolBarBase::AddSeparator()
{
    return InsertSeparator(GetToolsCount());
}

wxToolBarToolBase *wxToolBarBase::InsertSeparator(size_t pos)
{
    wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
                 _T("invalid position in wxToolBar::InsertSeparator()") );

    wxToolBarToolBase *tool = CreateTool(wxID_SEPARATOR,
                                         wxEmptyString,
                                         wxNullBitmap, wxNullBitmap,
                                         wxITEM_SEPARATOR, (wxObject *)NULL,
                                         wxEmptyString, wxEmptyString);

    if ( !tool || !DoInsertTool(pos, tool) )
    {
        delete tool;

        return NULL;
    }

    m_tools.Insert(pos, tool);

    return tool;
}

wxToolBarToolBase *wxToolBarBase::RemoveTool(int id)
{
    size_t pos = 0;
    wxToolBarToolsList::compatibility_iterator node;
    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
    {
        if ( node->GetData()->GetId() == id )
            break;

        pos++;
    }

    if ( !node )
    {
        // don't give any error messages - sometimes we might call RemoveTool()
        // without knowing whether the tool is or not in the toolbar
        return (wxToolBarToolBase *)NULL;
    }

    wxToolBarToolBase *tool = node->GetData();
    if ( !DoDeleteTool(pos, tool) )
    {
        return (wxToolBarToolBase *)NULL;
    }

    m_tools.Erase(node);

    return tool;
}

bool wxToolBarBase::DeleteToolByPos(size_t pos)
{
    wxCHECK_MSG( pos < GetToolsCount(), false,
                 _T("invalid position in wxToolBar::DeleteToolByPos()") );

    wxToolBarToolsList::compatibility_iterator node = m_tools.Item(pos);

    if ( !DoDeleteTool(pos, node->GetData()) )
    {
        return false;
    }

    delete node->GetData();
    m_tools.Erase(node);

    return true;
}

bool wxToolBarBase::DeleteTool(int id)
{
    size_t pos = 0;
    wxToolBarToolsList::compatibility_iterator node;
    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
    {
        if ( node->GetData()->GetId() == id )
            break;

        pos++;
    }

    if ( !node || !DoDeleteTool(pos, node->GetData()) )
    {
        return false;
    }

    delete node->GetData();
    m_tools.Erase(node);

    return true;
}

wxToolBarToolBase *wxToolBarBase::FindById(int id) const
{
    wxToolBarToolBase *tool = (wxToolBarToolBase *)NULL;

    for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
          node;
          node = node->GetNext() )
    {
        tool = node->GetData();
        if ( tool->GetId() == id )
        {
            // found
            break;
        }

        tool = NULL;
    }

    return tool;
}

void wxToolBarBase::UnToggleRadioGroup(wxToolBarToolBase *tool)
{
    wxCHECK_RET( tool, _T("NULL tool in wxToolBarTool::UnToggleRadioGroup") );

    if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
        return;

    wxToolBarToolsList::compatibility_iterator node = m_tools.Find(tool);
    wxCHECK_RET( node, _T("invalid tool in wxToolBarTool::UnToggleRadioGroup") );

    wxToolBarToolsList::compatibility_iterator nodeNext = node->GetNext();
    while ( nodeNext )
    {
        wxToolBarToolBase *toolNext = nodeNext->GetData();

        if ( !toolNext->IsButton() || toolNext->GetKind() != wxITEM_RADIO )
            break;

        if ( toolNext->Toggle(false) )
        {
            DoToggleTool(toolNext, false);
        }

        nodeNext = nodeNext->GetNext();
    }

    wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
    while ( nodePrev )
    {
        wxToolBarToolBase *toolNext = nodePrev->GetData();

        if ( !toolNext->IsButton() || toolNext->GetKind() != wxITEM_RADIO )
            break;

        if ( toolNext->Toggle(false) )
        {
            DoToggleTool(toolNext, false);
        }

        nodePrev = nodePrev->GetPrevious();
    }
}

void wxToolBarBase::ClearTools()
{
    while ( GetToolsCount() )
    {
        DeleteToolByPos(0);
    }
}

bool wxToolBarBase::Realize()
{
    return true;
}

wxToolBarBase::~wxToolBarBase()
{
    WX_CLEAR_LIST(wxToolBarToolsList, m_tools);

    // notify the frame that it doesn't have a tool bar any longer to avoid
    // dangling pointers
    wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
    if ( frame && frame->GetToolBar() == this )
    {
        frame->SetToolBar(NULL);
    }
}

// ----------------------------------------------------------------------------
// wxToolBarBase tools state
// ----------------------------------------------------------------------------

void wxToolBarBase::EnableTool(int id, bool enable)
{
    wxToolBarToolBase *tool = FindById(id);
    if ( tool )
    {
        if ( tool->Enable(enable) )
        {
            DoEnableTool(tool, enable);
        }
    }
}

void wxToolBarBase::ToggleTool(int id, bool toggle)
{
    wxToolBarToolBase *tool = FindById(id);
    if ( tool && tool->CanBeToggled() )
    {
        if ( tool->Toggle(toggle) )
        {
            UnToggleRadioGroup(tool);
            DoToggleTool(tool, toggle);
        }
    }
}

void wxToolBarBase::SetToggle(int id, bool toggle)
{
    wxToolBarToolBase *tool = FindById(id);
    if ( tool )
    {
        if ( tool->SetToggle(toggle) )
        {
            DoSetToggle(tool, toggle);
        }
    }
}

void wxToolBarBase::SetToolShortHelp(int id, const wxString& help)
{
    wxToolBarToolBase *tool = FindById(id);
    if ( tool )
    {
        (void)tool->SetShortHelp(help);
    }
}

void wxToolBarBase::SetToolLongHelp(int id, const wxString& help)
{
    wxToolBarToolBase *tool = FindById(id);
    if ( tool )
    {
        (void)tool->SetLongHelp(help);
    }
}

wxObject *wxToolBarBase::GetToolClientData(int id) const
{
    wxToolBarToolBase *tool = FindById(id);

    return tool ? tool->GetClientData() : (wxObject *)NULL;
}

void wxToolBarBase::SetToolClientData(int id, wxObject *clientData)
{
    wxToolBarToolBase *tool = FindById(id);

    wxCHECK_RET( tool, _T("no such tool in wxToolBar::SetToolClientData") );

    tool->SetClientData(clientData);
}

int wxToolBarBase::GetToolPos(int id) const
{
    size_t pos = 0;
    wxToolBarToolsList::compatibility_iterator node;

    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
    {
        if ( node->GetData()->GetId() == id )
            return pos;

        pos++;
    }

    return wxNOT_FOUND;
}

bool wxToolBarBase::GetToolState(int id) const
{
    wxToolBarToolBase *tool = FindById(id);
    wxCHECK_MSG( tool, false, _T("no such tool") );

    return tool->IsToggled();
}

bool wxToolBarBase::GetToolEnabled(int id) const
{
    wxToolBarToolBase *tool = FindById(id);
    wxCHECK_MSG( tool, false, _T("no such tool") );

    return tool->IsEnabled();
}

wxString wxToolBarBase::GetToolShortHelp(int id) const
{
    wxToolBarToolBase *tool = FindById(id);
    wxCHECK_MSG( tool, wxEmptyString, _T("no such tool") );

    return tool->GetShortHelp();
}

wxString wxToolBarBase::GetToolLongHelp(int id) const
{
    wxToolBarToolBase *tool = FindById(id);
    wxCHECK_MSG( tool, wxEmptyString, _T("no such tool") );

    return tool->GetLongHelp();
}

// ----------------------------------------------------------------------------
// wxToolBarBase geometry
// ----------------------------------------------------------------------------

void wxToolBarBase::SetMargins(int x, int y)
{
    m_xMargin = x;
    m_yMargin = y;
}

void wxToolBarBase::SetRows(int WXUNUSED(nRows))
{
    // nothing
}

// ----------------------------------------------------------------------------
// event processing
// ----------------------------------------------------------------------------

// Only allow toggle if returns true
bool wxToolBarBase::OnLeftClick(int id, bool toggleDown)
{
    wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, id);
    event.SetEventObject(this);

    // we use SetInt() to make wxCommandEvent::IsChecked() return toggleDown
    event.SetInt((int)toggleDown);

    // and SetExtraLong() for backwards compatibility
    event.SetExtraLong((long)toggleDown);

    // Send events to this toolbar instead (and thence up the window hierarchy)
    GetEventHandler()->ProcessEvent(event);

    return true;
}

// Call when right button down.
void wxToolBarBase::OnRightClick(int id,
                                 long WXUNUSED(x),
                                 long WXUNUSED(y))
{
    wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, id);
    event.SetEventObject(this);
    event.SetInt(id);

    GetEventHandler()->ProcessEvent(event);
}

// Called when the mouse cursor enters a tool bitmap (no button pressed).
// Argument is wxID_ANY if mouse is exiting the toolbar.
// Note that for this event, the id of the window is used,
// and the integer parameter of wxCommandEvent is used to retrieve
// the tool id.
void wxToolBarBase::OnMouseEnter(int id)
{
    wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId());
    event.SetEventObject(this);
    event.SetInt(id);

    wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
    if( frame )
    {
        wxString help;
        wxToolBarToolBase* tool = id == wxID_ANY ? (wxToolBarToolBase*)NULL : FindById(id);
        if(tool)
            help = tool->GetLongHelp();
        frame->DoGiveHelp( help, id != wxID_ANY );
    }

    (void)GetEventHandler()->ProcessEvent(event);
}

// ----------------------------------------------------------------------------
// UI updates
// ----------------------------------------------------------------------------

// Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
void wxToolBarBase::UpdateWindowUI(long flags)
{
    wxWindowBase::UpdateWindowUI(flags);

    // There is no sense in updating the toolbar UI
    // if the parent window is about to get destroyed
    wxWindow *tlw = wxGetTopLevelParent( this );
    if (tlw && wxPendingDelete.Member( tlw ))
        return;

    wxEvtHandler* evtHandler = GetEventHandler() ;

    for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
          node;
          node = node->GetNext() )
    {
        int id = node->GetData()->GetId();

        wxUpdateUIEvent event(id);
        event.SetEventObject(this);

        if ( evtHandler->ProcessEvent(event) )
        {
            if ( event.GetSetEnabled() )
                EnableTool(id, event.GetEnabled());
            if ( event.GetSetChecked() )
                ToggleTool(id, event.GetChecked());
#if 0
            if ( event.GetSetText() )
                // Set tooltip?
#endif // 0
        }
    }
}

#if wxUSE_IMAGE

/*
 * Make a greyed-out image suitable for disabled buttons.
 * This code is adapted from wxNewBitmapButton in FL.
 */

bool wxCreateGreyedImage(const wxImage& src, wxImage& dst)
{
    dst = src.Copy();

    unsigned char rBg, gBg, bBg;
    if ( src.HasMask() )
    {
        src.GetOrFindMaskColour(&rBg, &gBg, &bBg);
        dst.SetMaskColour(rBg, gBg, bBg);
    }
    else // assuming the pixels along the edges are of the background color
    {
        rBg = src.GetRed(0, 0);
        gBg = src.GetGreen(0, 0);
        bBg = src.GetBlue(0, 0);
    }

    const wxColour colBg(rBg, gBg, bBg);

    const wxColour colDark = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW);
    const wxColour colLight = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT);

    // Second attempt, just making things monochrome
    const int width = src.GetWidth();
    const int height = src.GetHeight();

    for ( int x = 0; x < width; x++ )
    {
        for ( int y = 0; y < height; y++ )
        {
            const int r = src.GetRed(x, y);
            const int g = src.GetGreen(x, y);
            const int b = src.GetBlue(x, y);

            if ( r == rBg && g == gBg && b == bBg )
            {
                // Leave the background colour as-is
                continue;
            }

            // Change light things to the background colour
            wxColour col;
            if ( r >= (colLight.Red() - 50) &&
                    g >= (colLight.Green() - 50) &&
                        b >= (colLight.Blue() - 50) )
            {
                col = colBg;
            }
            else // Change dark things to really dark
            {
                col = colDark;
            }

            dst.SetRGB(x, y, col.Red(), col.Green(), col.Blue());
        }
    }

    return true;
}

#endif // wxUSE_IMAGE

#endif // wxUSE_TOOLBAR
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/tbarbase.cpp
	3	// Purpose: wxToolBarBase implementation
	4	// Author: Julian Smart
	5	// Modified by: VZ at 11.12.99 (wxScrollableToolBar split off)
	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 __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	#if wxUSE_TOOLBAR
	28
	29	#include "wx/toolbar.h"
	30
	31	#ifndef WX_PRECOMP
	32	#include "wx/control.h"
	33	#include "wx/frame.h"
	34	#include "wx/settings.h"
	35	#include "wx/image.h"
	36	#endif
	37
	38	// ----------------------------------------------------------------------------
	39	// wxWidgets macros
	40	// ----------------------------------------------------------------------------
	41
	42	BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
	43	END_EVENT_TABLE()
	44
	45	#include "wx/listimpl.cpp"
	46
	47	WX_DEFINE_LIST(wxToolBarToolsList)
	48
	49	// ============================================================================
	50	// implementation
	51	// ============================================================================
	52
	53	// ----------------------------------------------------------------------------
	54	// wxToolBarToolBase
	55	// ----------------------------------------------------------------------------
	56
	57	IMPLEMENT_DYNAMIC_CLASS(wxToolBarToolBase, wxObject)
	58
	59	bool wxToolBarToolBase::Enable(bool enable)
	60	{
	61	if ( m_enabled == enable )
	62	return false;
	63
	64	m_enabled = enable;
	65
	66	return true;
	67	}
	68
	69	bool wxToolBarToolBase::Toggle(bool toggle)
	70	{
	71	wxASSERT_MSG( CanBeToggled(), _T("can't toggle this tool") );
	72
	73	if ( m_toggled == toggle )
	74	return false;
	75
	76	m_toggled = toggle;
	77
	78	return true;
	79	}
	80
	81	bool wxToolBarToolBase::SetToggle(bool toggle)
	82	{
	83	wxItemKind kind = toggle ? wxITEM_CHECK : wxITEM_NORMAL;
	84	if ( m_kind == kind )
	85	return false;
	86
	87	m_kind = kind;
	88
	89	return true;
	90	}
	91
	92	bool wxToolBarToolBase::SetShortHelp(const wxString& help)
	93	{
	94	if ( m_shortHelpString == help )
	95	return false;
	96
	97	m_shortHelpString = help;
	98
	99	return true;
	100	}
	101
	102	bool wxToolBarToolBase::SetLongHelp(const wxString& help)
	103	{
	104	if ( m_longHelpString == help )
	105	return false;
	106
	107	m_longHelpString = help;
	108
	109	return true;
	110	}
	111
	112	// ----------------------------------------------------------------------------
	113	// wxToolBarBase adding/deleting items
	114	// ----------------------------------------------------------------------------
	115
	116	wxToolBarBase::wxToolBarBase()
	117	{
	118	// the list owns the pointers
	119	m_xMargin = m_yMargin = 0;
	120	m_maxRows = m_maxCols = 0;
	121	m_toolPacking = m_toolSeparation = 0;
	122	m_defaultWidth = 16;
	123	m_defaultHeight = 15;
	124	}
	125
	126	void wxToolBarBase::FixupStyle()
	127	{
	128	if ( !HasFlag(wxTB_TOP \| wxTB_LEFT \| wxTB_RIGHT \| wxTB_BOTTOM) )
	129	{
	130	// this is the default
	131	m_windowStyle \|= wxTB_TOP;
	132	}
	133	}
	134
	135	wxToolBarToolBase *wxToolBarBase::DoAddTool(int id,
	136	const wxString& label,
	137	const wxBitmap& bitmap,
	138	const wxBitmap& bmpDisabled,
	139	wxItemKind kind,
	140	const wxString& shortHelp,
	141	const wxString& longHelp,
	142	wxObject *clientData,
	143	wxCoord WXUNUSED(xPos),
	144	wxCoord WXUNUSED(yPos))
	145	{
	146	InvalidateBestSize();
	147	return InsertTool(GetToolsCount(), id, label, bitmap, bmpDisabled,
	148	kind, shortHelp, longHelp, clientData);
	149	}
	150
	151	wxToolBarToolBase *wxToolBarBase::InsertTool(size_t pos,
	152	int id,
	153	const wxString& label,
	154	const wxBitmap& bitmap,
	155	const wxBitmap& bmpDisabled,
	156	wxItemKind kind,
	157	const wxString& shortHelp,
	158	const wxString& longHelp,
	159	wxObject *clientData)
	160	{
	161	wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
	162	_T("invalid position in wxToolBar::InsertTool()") );
	163
	164	wxToolBarToolBase *tool = CreateTool(id, label, bitmap, bmpDisabled, kind,
	165	clientData, shortHelp, longHelp);
	166
	167	if ( !InsertTool(pos, tool) )
	168	{
	169	delete tool;
	170
	171	return NULL;
	172	}
	173
	174	return tool;
	175	}
	176
	177	wxToolBarToolBase wxToolBarBase::AddTool(wxToolBarToolBase tool)
	178	{
	179	return InsertTool(GetToolsCount(), tool);
	180	}
	181
	182	wxToolBarToolBase *
	183	wxToolBarBase::InsertTool(size_t pos, wxToolBarToolBase *tool)
	184	{
	185	wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
	186	_T("invalid position in wxToolBar::InsertTool()") );
	187
	188	if ( !tool \|\| !DoInsertTool(pos, tool) )
	189	{
	190	return NULL;
	191	}
	192
	193	m_tools.Insert(pos, tool);
	194
	195	return tool;
	196	}
	197
	198	wxToolBarToolBase wxToolBarBase::AddControl(wxControl control)
	199	{
	200	return InsertControl(GetToolsCount(), control);
	201	}
	202
	203	wxToolBarToolBase wxToolBarBase::InsertControl(size_t pos, wxControl control)
	204	{
	205	wxCHECK_MSG( control, (wxToolBarToolBase *)NULL,
	206	_T("toolbar: can't insert NULL control") );
	207
	208	wxCHECK_MSG( control->GetParent() == this, (wxToolBarToolBase *)NULL,
	209	_T("control must have toolbar as parent") );
	210
	211	wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
	212	_T("invalid position in wxToolBar::InsertControl()") );
	213
	214	wxToolBarToolBase *tool = CreateTool(control);
	215
	216	if ( !InsertTool(pos, tool) )
	217	{
	218	delete tool;
	219
	220	return NULL;
	221	}
	222
	223	return tool;
	224	}
	225
	226	wxControl *wxToolBarBase::FindControl( int id )
	227	{
	228	for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
	229	node;
	230	node = node->GetNext() )
	231	{
	232	const wxToolBarToolBase * const tool = node->GetData();
	233	if ( tool->IsControl() )
	234	{
	235	wxControl * const control = tool->GetControl();
	236
	237	if ( !control )
	238	{
	239	wxFAIL_MSG( _T("NULL control in toolbar?") );
	240	}
	241	else if ( control->GetId() == id )
	242	{
	243	// found
	244	return control;
	245	}
	246	}
	247	}
	248
	249	return NULL;
	250	}
	251
	252	wxToolBarToolBase *wxToolBarBase::AddSeparator()
	253	{
	254	return InsertSeparator(GetToolsCount());
	255	}
	256
	257	wxToolBarToolBase *wxToolBarBase::InsertSeparator(size_t pos)
	258	{
	259	wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
	260	_T("invalid position in wxToolBar::InsertSeparator()") );
	261
	262	wxToolBarToolBase *tool = CreateTool(wxID_SEPARATOR,
	263	wxEmptyString,
	264	wxNullBitmap, wxNullBitmap,
	265	wxITEM_SEPARATOR, (wxObject *)NULL,
	266	wxEmptyString, wxEmptyString);
	267
	268	if ( !tool \|\| !DoInsertTool(pos, tool) )
	269	{
	270	delete tool;
	271
	272	return NULL;
	273	}
	274
	275	m_tools.Insert(pos, tool);
	276
	277	return tool;
	278	}
	279
	280	wxToolBarToolBase *wxToolBarBase::RemoveTool(int id)
	281	{
	282	size_t pos = 0;
	283	wxToolBarToolsList::compatibility_iterator node;
	284	for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
	285	{
	286	if ( node->GetData()->GetId() == id )
	287	break;
	288
	289	pos++;
	290	}
	291
	292	if ( !node )
	293	{
	294	// don't give any error messages - sometimes we might call RemoveTool()
	295	// without knowing whether the tool is or not in the toolbar
	296	return (wxToolBarToolBase *)NULL;
	297	}
	298
	299	wxToolBarToolBase *tool = node->GetData();
	300	if ( !DoDeleteTool(pos, tool) )
	301	{
	302	return (wxToolBarToolBase *)NULL;
	303	}
	304
	305	m_tools.Erase(node);
	306
	307	return tool;
	308	}
	309
	310	bool wxToolBarBase::DeleteToolByPos(size_t pos)
	311	{
	312	wxCHECK_MSG( pos < GetToolsCount(), false,
	313	_T("invalid position in wxToolBar::DeleteToolByPos()") );
	314
	315	wxToolBarToolsList::compatibility_iterator node = m_tools.Item(pos);
	316
	317	if ( !DoDeleteTool(pos, node->GetData()) )
	318	{
	319	return false;
	320	}
	321
	322	delete node->GetData();
	323	m_tools.Erase(node);
	324
	325	return true;
	326	}
	327
	328	bool wxToolBarBase::DeleteTool(int id)
	329	{
	330	size_t pos = 0;
	331	wxToolBarToolsList::compatibility_iterator node;
	332	for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
	333	{
	334	if ( node->GetData()->GetId() == id )
	335	break;
	336
	337	pos++;
	338	}
	339
	340	if ( !node \|\| !DoDeleteTool(pos, node->GetData()) )
	341	{
	342	return false;
	343	}
	344
	345	delete node->GetData();
	346	m_tools.Erase(node);
	347
	348	return true;
	349	}
	350
	351	wxToolBarToolBase *wxToolBarBase::FindById(int id) const
	352	{
	353	wxToolBarToolBase tool = (wxToolBarToolBase )NULL;
	354
	355	for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
	356	node;
	357	node = node->GetNext() )
	358	{
	359	tool = node->GetData();
	360	if ( tool->GetId() == id )
	361	{
	362	// found
	363	break;
	364	}
	365
	366	tool = NULL;
	367	}
	368
	369	return tool;
	370	}
	371
	372	void wxToolBarBase::UnToggleRadioGroup(wxToolBarToolBase *tool)
	373	{
	374	wxCHECK_RET( tool, _T("NULL tool in wxToolBarTool::UnToggleRadioGroup") );
	375
	376	if ( !tool->IsButton() \|\| tool->GetKind() != wxITEM_RADIO )
	377	return;
	378
	379	wxToolBarToolsList::compatibility_iterator node = m_tools.Find(tool);
	380	wxCHECK_RET( node, _T("invalid tool in wxToolBarTool::UnToggleRadioGroup") );
	381
	382	wxToolBarToolsList::compatibility_iterator nodeNext = node->GetNext();
	383	while ( nodeNext )
	384	{
	385	wxToolBarToolBase *toolNext = nodeNext->GetData();
	386
	387	if ( !toolNext->IsButton() \|\| toolNext->GetKind() != wxITEM_RADIO )
	388	break;
	389
	390	if ( toolNext->Toggle(false) )
	391	{
	392	DoToggleTool(toolNext, false);
	393	}
	394
	395	nodeNext = nodeNext->GetNext();
	396	}
	397
	398	wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
	399	while ( nodePrev )
	400	{
	401	wxToolBarToolBase *toolNext = nodePrev->GetData();
	402
	403	if ( !toolNext->IsButton() \|\| toolNext->GetKind() != wxITEM_RADIO )
	404	break;
	405
	406	if ( toolNext->Toggle(false) )
	407	{
	408	DoToggleTool(toolNext, false);
	409	}
	410
	411	nodePrev = nodePrev->GetPrevious();
	412	}
	413	}
	414
	415	void wxToolBarBase::ClearTools()
	416	{
	417	while ( GetToolsCount() )
	418	{
	419	DeleteToolByPos(0);
	420	}
	421	}
	422
	423	bool wxToolBarBase::Realize()
	424	{
	425	return true;
	426	}
	427
	428	wxToolBarBase::~wxToolBarBase()
	429	{
	430	WX_CLEAR_LIST(wxToolBarToolsList, m_tools);
	431
	432	// notify the frame that it doesn't have a tool bar any longer to avoid
	433	// dangling pointers
	434	wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
	435	if ( frame && frame->GetToolBar() == this )
	436	{
	437	frame->SetToolBar(NULL);
	438	}
	439	}
	440
	441	// ----------------------------------------------------------------------------
	442	// wxToolBarBase tools state
	443	// ----------------------------------------------------------------------------
	444
	445	void wxToolBarBase::EnableTool(int id, bool enable)
	446	{
	447	wxToolBarToolBase *tool = FindById(id);
	448	if ( tool )
	449	{
	450	if ( tool->Enable(enable) )
	451	{
	452	DoEnableTool(tool, enable);
	453	}
	454	}
	455	}
	456
	457	void wxToolBarBase::ToggleTool(int id, bool toggle)
	458	{
	459	wxToolBarToolBase *tool = FindById(id);
	460	if ( tool && tool->CanBeToggled() )
	461	{
	462	if ( tool->Toggle(toggle) )
	463	{
	464	UnToggleRadioGroup(tool);
	465	DoToggleTool(tool, toggle);
	466	}
	467	}
	468	}
	469
	470	void wxToolBarBase::SetToggle(int id, bool toggle)
	471	{
	472	wxToolBarToolBase *tool = FindById(id);
	473	if ( tool )
	474	{
	475	if ( tool->SetToggle(toggle) )
	476	{
	477	DoSetToggle(tool, toggle);
	478	}
	479	}
	480	}
	481
	482	void wxToolBarBase::SetToolShortHelp(int id, const wxString& help)
	483	{
	484	wxToolBarToolBase *tool = FindById(id);
	485	if ( tool )
	486	{
	487	(void)tool->SetShortHelp(help);
	488	}
	489	}
	490
	491	void wxToolBarBase::SetToolLongHelp(int id, const wxString& help)
	492	{
	493	wxToolBarToolBase *tool = FindById(id);
	494	if ( tool )
	495	{
	496	(void)tool->SetLongHelp(help);
	497	}
	498	}
	499
	500	wxObject *wxToolBarBase::GetToolClientData(int id) const
	501	{
	502	wxToolBarToolBase *tool = FindById(id);
	503
	504	return tool ? tool->GetClientData() : (wxObject *)NULL;
	505	}
	506
	507	void wxToolBarBase::SetToolClientData(int id, wxObject *clientData)
	508	{
	509	wxToolBarToolBase *tool = FindById(id);
	510
	511	wxCHECK_RET( tool, _T("no such tool in wxToolBar::SetToolClientData") );
	512
	513	tool->SetClientData(clientData);
	514	}
	515
	516	int wxToolBarBase::GetToolPos(int id) const
	517	{
	518	size_t pos = 0;
	519	wxToolBarToolsList::compatibility_iterator node;
	520
	521	for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
	522	{
	523	if ( node->GetData()->GetId() == id )
	524	return pos;
	525
	526	pos++;
	527	}
	528
	529	return wxNOT_FOUND;
	530	}
	531
	532	bool wxToolBarBase::GetToolState(int id) const
	533	{
	534	wxToolBarToolBase *tool = FindById(id);
	535	wxCHECK_MSG( tool, false, _T("no such tool") );
	536
	537	return tool->IsToggled();
	538	}
	539
	540	bool wxToolBarBase::GetToolEnabled(int id) const
	541	{
	542	wxToolBarToolBase *tool = FindById(id);
	543	wxCHECK_MSG( tool, false, _T("no such tool") );
	544
	545	return tool->IsEnabled();
	546	}
	547
	548	wxString wxToolBarBase::GetToolShortHelp(int id) const
	549	{
	550	wxToolBarToolBase *tool = FindById(id);
	551	wxCHECK_MSG( tool, wxEmptyString, _T("no such tool") );
	552
	553	return tool->GetShortHelp();
	554	}
	555
	556	wxString wxToolBarBase::GetToolLongHelp(int id) const
	557	{
	558	wxToolBarToolBase *tool = FindById(id);
	559	wxCHECK_MSG( tool, wxEmptyString, _T("no such tool") );
	560
	561	return tool->GetLongHelp();
	562	}
	563
	564	// ----------------------------------------------------------------------------
	565	// wxToolBarBase geometry
	566	// ----------------------------------------------------------------------------
	567
	568	void wxToolBarBase::SetMargins(int x, int y)
	569	{
	570	m_xMargin = x;
	571	m_yMargin = y;
	572	}
	573
	574	void wxToolBarBase::SetRows(int WXUNUSED(nRows))
	575	{
	576	// nothing
	577	}
	578
	579	// ----------------------------------------------------------------------------
	580	// event processing
	581	// ----------------------------------------------------------------------------
	582
	583	// Only allow toggle if returns true
	584	bool wxToolBarBase::OnLeftClick(int id, bool toggleDown)
	585	{
	586	wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, id);
	587	event.SetEventObject(this);
	588
	589	// we use SetInt() to make wxCommandEvent::IsChecked() return toggleDown
	590	event.SetInt((int)toggleDown);
	591
	592	// and SetExtraLong() for backwards compatibility
	593	event.SetExtraLong((long)toggleDown);
	594
	595	// Send events to this toolbar instead (and thence up the window hierarchy)
	596	GetEventHandler()->ProcessEvent(event);
	597
	598	return true;
	599	}
	600
	601	// Call when right button down.
	602	void wxToolBarBase::OnRightClick(int id,
	603	long WXUNUSED(x),
	604	long WXUNUSED(y))
	605	{
	606	wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, id);
	607	event.SetEventObject(this);
	608	event.SetInt(id);
	609
	610	GetEventHandler()->ProcessEvent(event);
	611	}
	612
	613	// Called when the mouse cursor enters a tool bitmap (no button pressed).
	614	// Argument is wxID_ANY if mouse is exiting the toolbar.
	615	// Note that for this event, the id of the window is used,
	616	// and the integer parameter of wxCommandEvent is used to retrieve
	617	// the tool id.
	618	void wxToolBarBase::OnMouseEnter(int id)
	619	{
	620	wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId());
	621	event.SetEventObject(this);
	622	event.SetInt(id);
	623
	624	wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
	625	if( frame )
	626	{
	627	wxString help;
	628	wxToolBarToolBase* tool = id == wxID_ANY ? (wxToolBarToolBase*)NULL : FindById(id);
	629	if(tool)
	630	help = tool->GetLongHelp();
	631	frame->DoGiveHelp( help, id != wxID_ANY );
	632	}
	633
	634	(void)GetEventHandler()->ProcessEvent(event);
	635	}
	636
	637	// ----------------------------------------------------------------------------
	638	// UI updates
	639	// ----------------------------------------------------------------------------
	640
	641	// Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
	642	void wxToolBarBase::UpdateWindowUI(long flags)
	643	{
	644	wxWindowBase::UpdateWindowUI(flags);
	645
	646	// There is no sense in updating the toolbar UI
	647	// if the parent window is about to get destroyed
	648	wxWindow *tlw = wxGetTopLevelParent( this );
	649	if (tlw && wxPendingDelete.Member( tlw ))
	650	return;
	651
	652	wxEvtHandler* evtHandler = GetEventHandler() ;
	653
	654	for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
	655	node;
	656	node = node->GetNext() )
	657	{
	658	int id = node->GetData()->GetId();
	659
	660	wxUpdateUIEvent event(id);
	661	event.SetEventObject(this);
	662
	663	if ( evtHandler->ProcessEvent(event) )
	664	{
	665	if ( event.GetSetEnabled() )
	666	EnableTool(id, event.GetEnabled());
	667	if ( event.GetSetChecked() )
	668	ToggleTool(id, event.GetChecked());
	669	#if 0
	670	if ( event.GetSetText() )
	671	// Set tooltip?
	672	#endif // 0
	673	}
	674	}
	675	}
	676
	677	#if wxUSE_IMAGE
	678
	679	/*
	680	* Make a greyed-out image suitable for disabled buttons.
	681	* This code is adapted from wxNewBitmapButton in FL.
	682	*/
	683
	684	bool wxCreateGreyedImage(const wxImage& src, wxImage& dst)
	685	{
	686	dst = src.Copy();
	687
	688	unsigned char rBg, gBg, bBg;
	689	if ( src.HasMask() )
	690	{
	691	src.GetOrFindMaskColour(&rBg, &gBg, &bBg);
	692	dst.SetMaskColour(rBg, gBg, bBg);
	693	}
	694	else // assuming the pixels along the edges are of the background color
	695	{
	696	rBg = src.GetRed(0, 0);
	697	gBg = src.GetGreen(0, 0);
	698	bBg = src.GetBlue(0, 0);
	699	}
	700
	701	const wxColour colBg(rBg, gBg, bBg);
	702
	703	const wxColour colDark = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW);
	704	const wxColour colLight = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT);
	705
	706	// Second attempt, just making things monochrome
	707	const int width = src.GetWidth();
	708	const int height = src.GetHeight();
	709
	710	for ( int x = 0; x < width; x++ )
	711	{
	712	for ( int y = 0; y < height; y++ )
	713	{
	714	const int r = src.GetRed(x, y);
	715	const int g = src.GetGreen(x, y);
	716	const int b = src.GetBlue(x, y);
	717
	718	if ( r == rBg && g == gBg && b == bBg )
	719	{
	720	// Leave the background colour as-is
	721	continue;
	722	}
	723
	724	// Change light things to the background colour
	725	wxColour col;
	726	if ( r >= (colLight.Red() - 50) &&
	727	g >= (colLight.Green() - 50) &&
	728	b >= (colLight.Blue() - 50) )
	729	{
	730	col = colBg;
	731	}
	732	else // Change dark things to really dark
	733	{
	734	col = colDark;
	735	}
	736
	737	dst.SetRGB(x, y, col.Red(), col.Green(), col.Blue());
	738	}
	739	}
	740
	741	return true;
	742	}
	743
	744	#endif // wxUSE_IMAGE
	745
	746	#endif // wxUSE_TOOLBAR