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"
    #if WXWIN_COMPATIBILITY_2_8
        #include "wx/image.h"
    #endif // WXWIN_COMPATIBILITY_2_8
    #include "wx/menu.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)

wxToolBarToolBase::~wxToolBarToolBase()
{
    delete m_dropdownMenu;
    if ( IsControl() )
        GetControl()->Destroy();
}


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;
}


void wxToolBarToolBase::SetDropdownMenu(wxMenu* menu)
{
    delete m_dropdownMenu;
    m_dropdownMenu = menu;
}


// ----------------------------------------------------------------------------
// 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);
    tool->Attach(this);

    return tool;
}

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

wxToolBarToolBase *
wxToolBarBase::InsertControl(size_t pos,
                             wxControl *control,
                             const wxString& label)
{
    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, label);

    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 NULL;
    }

    wxToolBarToolBase *tool = node->GetData();
    wxCHECK_MSG( tool, NULL, "NULL tool in the tools list?" );

    if ( !DoDeleteTool(pos, tool) )
        return NULL;

    m_tools.Erase(node);

    tool->Detach();

    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
}

bool wxToolBarBase::IsVertical() const
{
    return HasFlag(wxTB_LEFT | wxTB_RIGHT);
}


// ----------------------------------------------------------------------------
// 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;
        if ( id != wxID_ANY )
        {
           const wxToolBarToolBase * const tool = FindById(id);
           if ( tool )
               help = tool->GetLongHelp();
        }

        // call DoGiveHelp() even if help string is empty to avoid showing the
        // help for the previously selected tool when another one is selected
        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);

    // don't waste time updating state of tools in a hidden toolbar
    if ( !IsShown() )
        return;

    // 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() )
    {
        wxToolBarToolBase * const tool = node->GetData();
        if ( tool->IsSeparator() )
            continue;

        int id = tool->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
        }
    }
}

bool wxToolBarBase::SetDropdownMenu(int toolid, wxMenu* menu)
{
    wxToolBarToolBase * const tool = FindById(toolid);
    wxCHECK_MSG( tool, false, _T("invalid tool id") );

    wxCHECK_MSG( tool->GetKind() == wxITEM_DROPDOWN, false,
                    _T("menu can be only associated with drop down tools") );

    tool->SetDropdownMenu(menu);

    return true;
}

#if WXWIN_COMPATIBILITY_2_8

bool wxCreateGreyedImage(const wxImage& in, wxImage& out)
{
#if wxUSE_IMAGE
    out = in.ConvertToGreyscale();
    if ( out.Ok() )
        return true;
#endif // wxUSE_IMAGE
    return false;
}

#endif // WXWIN_COMPATIBILITY_2_8

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