src/common/tbarbase.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        common/tbarbase.cpp
// Purpose:     wxToolBarBase implementation
// Author:      Julian Smart
// Modified by: VZ at 11.12.99 (wxScrollableToolBar splitted off)
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

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

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
    #pragma implementation "tbarbase.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_TOOLBAR

#ifndef WX_PRECOMP
    #include "wx/control.h"
#endif

#include "wx/frame.h"
#include "wx/image.h"
#include "wx/settings.h"

#include "wx/toolbar.h"

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

wxToolBarToolBase::~wxToolBarToolBase()
{
}

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

wxToolBarBase::wxToolBarBase()
{
    // the list owns the pointers
    m_xMargin = m_yMargin = 0;

    m_maxRows = m_maxCols = 0;
}

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 *tool = nodeNext->GetData();

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

        tool->Toggle(false);

        nodeNext = nodeNext->GetNext();
    }

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

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

        tool->Toggle(false);

        nodePrev = nodePrev->GetPrevious();
    }
}

void wxToolBarBase::ClearTools()
{
    WX_CLEAR_LIST(wxToolBarToolsList, m_tools);
}

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

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

// ----------------------------------------------------------------------------
// 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, _T(""), _T("no such tool") );

    return tool->GetShortHelp();
}

wxString wxToolBarBase::GetToolLongHelp(int id) const
{
    wxToolBarToolBase *tool = FindById(id);
    wxCHECK_MSG( tool, _T(""), _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 -1 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 )
    {
        wxToolBarToolBase* tool = id == -1 ? (wxToolBarToolBase*)0 : FindById(id);
        wxString help = tool ? tool->GetLongHelp() : wxString();
        frame->DoGiveHelp( help, id != -1 );
    }

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

// Helper function, used by wxCreateGreyedImage

static void wxGreyOutImage( const wxImage& src,
                            wxImage& dest,
                            const wxColour& darkCol,
                            const wxColour& lightCol,
                            const wxColour& bgCol )
{
    // Second attempt, just making things monochrome
    int width = src.GetWidth();
    int height = src.GetHeight();

    int redCur, greenCur, blueCur;
    for ( int x = 0; x < width; x++ )
    {
        for ( int y = 1; y < height; y++ )
        {
            redCur = src.GetRed(x, y);
            greenCur = src.GetGreen(x, y);
            blueCur = src.GetBlue(x, y);

            // Change light things to the background colour
            if ( redCur >= (lightCol.Red() - 50) && greenCur >= (lightCol.Green() - 50) && blueCur >= (lightCol.Blue() - 50) )
            {
                dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
            }
            else if ( redCur == bgCol.Red() && greenCur == bgCol.Green() && blueCur == bgCol.Blue() )
            {
                // Leave the background colour as-is
                // dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
            }
            else // if ( redCur <= darkCol.Red() && greenCur <= darkCol.Green() && blueCur <= darkCol.Blue() )
            {
                // Change dark things to really dark
                dest.SetRGB(x,y, darkCol.Red(), darkCol.Green(), darkCol.Blue());
            }
        }
    }
}

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

bool wxCreateGreyedImage(const wxImage& in, wxImage& out)
{
    out = in.Copy();

    // assuming the pixels along the edges are of the background color
    wxColour bgCol(in.GetRed(0, 0), in.GetGreen(0, 0), in.GetBlue(0, 0));

    wxColour darkCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW) ;
    wxColour lightCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT) ;

    wxGreyOutImage(in, out, darkCol, lightCol, bgCol);

    return true;
}

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