src/gtk1/tbargtk.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        tbargtk.cpp
// Purpose:     GTK toolbar
// Author:      Robert Roebling
// RCS-ID:      $Id$
// Copyright:   (c) Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#include "wx/toolbar.h"

#if wxUSE_TOOLBAR

#include "wx/frame.h"

#include "glib.h"
#include "gdk/gdk.h"
#include "gtk/gtk.h"

//-----------------------------------------------------------------------------
// idle system
//-----------------------------------------------------------------------------

extern void wxapp_install_idle_handler();
extern bool g_isIdle;

//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------

extern bool       g_blockEventsOnDrag;
extern wxCursor   g_globalCursor;

//-----------------------------------------------------------------------------
// "clicked" (internal from gtk_toolbar)
//-----------------------------------------------------------------------------

static void gtk_toolbar_callback( GtkWidget *WXUNUSED(widget), wxToolBarTool *tool )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    if (tool->m_owner->m_blockNextEvent)
    {
        tool->m_owner->m_blockNextEvent = FALSE;
        return;
    }

    if (g_blockEventsOnDrag) return;
    if (!tool->m_enabled) return;

    if (tool->m_isToggle)
    {
        tool->m_toggleState = !tool->m_toggleState;

	if (tool->m_bitmap2.Ok())
	{
	    wxBitmap bitmap = tool->m_bitmap1;
	    if (tool->m_toggleState) bitmap = tool->m_bitmap2;

            GtkPixmap *pixmap = GTK_PIXMAP( tool->m_pixmap );

            GdkBitmap *mask = (GdkBitmap *) NULL;
            if (bitmap.GetMask()) mask = bitmap.GetMask()->GetBitmap();

            gtk_pixmap_set( pixmap, bitmap.GetPixmap(), mask );
	}
    }

    tool->m_owner->OnLeftClick( tool->m_index, tool->m_toggleState );
}

//-----------------------------------------------------------------------------
// "enter_notify_event"
//-----------------------------------------------------------------------------

static gint gtk_toolbar_enter_callback( GtkWidget *WXUNUSED(widget),
  GdkEventCrossing *WXUNUSED(gdk_event), wxToolBarTool *tool )
{
    if (g_isIdle) wxapp_install_idle_handler();

    if (g_blockEventsOnDrag) return TRUE;


    wxToolBar *tb = tool->m_owner;

#if (GTK_MINOR_VERSION == 0)
    /* we grey-out the tip text of disabled tool in GTK 1.0 */
    if (tool->m_enabled)
    {
        if (tb->m_fg->red != 0)
        {
            tb->m_fg->red = 0;
            tb->m_fg->green = 0;
            tb->m_fg->blue = 0;
            gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(tb->m_toolbar) ), tb->m_fg );

            gtk_tooltips_set_colors( GTK_TOOLBAR(tb->m_toolbar)->tooltips, tb->m_bg, tb->m_fg );
        }
    }
    else
    {
        if (tb->m_fg->red == 0)
        {
            tb->m_fg->red = 33000;
            tb->m_fg->green = 33000;
            tb->m_fg->blue = 33000;
            gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(tb->m_toolbar) ), tb->m_fg );
            gtk_tooltips_set_colors( GTK_TOOLBAR(tb->m_toolbar)->tooltips, tb->m_bg, tb->m_fg );
        }
    }
#endif

    /* emit the event */

    tb->OnMouseEnter( tool->m_index );

    return FALSE;
}

//-----------------------------------------------------------------------------
// InsertChild callback for wxToolBar
//-----------------------------------------------------------------------------

static void wxInsertChildInToolBar( wxToolBar* WXUNUSED(parent), wxWindow* WXUNUSED(child) )
{
    /* we don't do anything here but pray */
}

//-----------------------------------------------------------------------------
// wxToolBar
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxToolBar,wxControl)

BEGIN_EVENT_TABLE(wxToolBar, wxControl)
  EVT_IDLE(wxToolBar::OnIdle)
END_EVENT_TABLE()

wxToolBar::wxToolBar()
{
}

wxToolBar::wxToolBar( wxWindow *parent, wxWindowID id,
  const wxPoint& pos, const wxSize& size,
  long style, const wxString& name )
{
    Create( parent, id, pos, size, style, name );
}

wxToolBar::~wxToolBar()
{
    delete m_fg;
    delete m_bg;
}

bool wxToolBar::Create( wxWindow *parent, wxWindowID id,
  const wxPoint& pos, const wxSize& size,
  long style, const wxString& name )
{
    m_needParent = TRUE;
    m_blockNextEvent = FALSE;
    m_insertCallback = (wxInsertChildFunction)wxInsertChildInToolBar;

    if (!PreCreation( parent, pos, size ) ||
        !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
    {
        wxFAIL_MSG( wxT("wxToolBar creation failed") );
	return FALSE;
    }

    m_tools.DeleteContents( TRUE );

    m_toolbar = GTK_TOOLBAR( gtk_toolbar_new( GTK_ORIENTATION_HORIZONTAL,
                                              GTK_TOOLBAR_ICONS ) );

//    gtk_toolbar_set_space_style( m_toolbar, GTK_TOOLBAR_SPACE_LINE );
    m_separation = 5;
    gtk_toolbar_set_space_size( m_toolbar, m_separation );
    m_hasToolAlready = FALSE;

    if (style & wxTB_DOCKABLE)
    {
        m_widget = gtk_handle_box_new();
        gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
        gtk_widget_show( GTK_WIDGET(m_toolbar) );

#if (GTK_MINOR_VERSION > 0)
        if (style & wxTB_FLAT)
            gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
#endif
    }
    else
    {
        m_widget = GTK_WIDGET(m_toolbar);
    }

    gtk_toolbar_set_tooltips( GTK_TOOLBAR(m_toolbar), TRUE );

#if (GTK_MINOR_VERSION > 0)
    if (style & wxTB_FLAT)
        gtk_toolbar_set_button_relief( GTK_TOOLBAR(m_toolbar), GTK_RELIEF_NONE );
#endif

    m_fg = new GdkColor;
    m_fg->red = 0;
    m_fg->green = 0;
    m_fg->blue = 0;
    gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(m_toolbar) ), m_fg );

    m_bg = new GdkColor;
    m_bg->red = 65535;
    m_bg->green = 65535;
    m_bg->blue = 50000;
    gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(m_toolbar) ), m_bg );

#if (GTK_MINOR_VERSION > 0)
    gtk_tooltips_force_window( GTK_TOOLBAR(m_toolbar)->tooltips );

    GtkStyle *g_style =
      gtk_style_copy(
         gtk_widget_get_style(
            GTK_TOOLBAR(m_toolbar)->tooltips->tip_window ) );

    g_style->bg[GTK_STATE_NORMAL] = *m_bg;
    gtk_widget_set_style( GTK_TOOLBAR(m_toolbar)->tooltips->tip_window, g_style );
#else
    gtk_tooltips_set_colors( GTK_TOOLBAR(m_toolbar)->tooltips, m_bg, m_fg );
#endif

    m_xMargin = 0;
    m_yMargin = 0;

    m_parent->DoAddChild( this );

    PostCreation();

    Show( TRUE );

    return TRUE;
}

bool wxToolBar::OnLeftClick( int toolIndex, bool toggleDown )
{
    wxCommandEvent event( wxEVT_COMMAND_TOOL_CLICKED, toolIndex );
    event.SetEventObject(this);
    event.SetInt( toolIndex );
    event.SetExtraLong((long) toggleDown);

    GetEventHandler()->ProcessEvent(event);

    return TRUE;
}

void wxToolBar::OnRightClick( int toolIndex, float WXUNUSED(x), float WXUNUSED(y) )
{
    wxCommandEvent event( wxEVT_COMMAND_TOOL_RCLICKED, toolIndex );
    event.SetEventObject( this );
    event.SetInt( toolIndex );

    GetEventHandler()->ProcessEvent(event);
}

void wxToolBar::OnMouseEnter( int toolIndex )
{
    wxCommandEvent event( wxEVT_COMMAND_TOOL_ENTER, GetId() );
    event.SetEventObject(this);
    event.SetInt( toolIndex );

    GetEventHandler()->ProcessEvent(event);
}

wxToolBarTool *wxToolBar::AddTool( int toolIndex, const wxBitmap& bitmap,
  const wxBitmap& pushedBitmap, bool toggle,
  wxCoord WXUNUSED(xPos), wxCoord WXUNUSED(yPos), wxObject *clientData,
  const wxString& helpString1, const wxString& helpString2 )
{
    m_hasToolAlready = TRUE;

    wxCHECK_MSG( bitmap.Ok(), (wxToolBarTool *)NULL,
                 wxT("invalid bitmap for wxToolBar icon") );

    wxCHECK_MSG( bitmap.GetBitmap() == NULL, (wxToolBarTool *)NULL,
                 wxT("wxToolBar doesn't support GdkBitmap") );

    wxCHECK_MSG( bitmap.GetPixmap() != NULL, (wxToolBarTool *)NULL,
                 wxT("wxToolBar::Add needs a wxBitmap") );

    GtkWidget *tool_pixmap = (GtkWidget *)NULL;

    GdkPixmap *pixmap = bitmap.GetPixmap();

    GdkBitmap *mask = (GdkBitmap *)NULL;
    if ( bitmap.GetMask() )
      mask = bitmap.GetMask()->GetBitmap();

    tool_pixmap = gtk_pixmap_new( pixmap, mask );
#if (GTK_MINOR_VERSION > 0)
    gtk_pixmap_set_build_insensitive( GTK_PIXMAP(tool_pixmap), TRUE );
#endif

    gtk_misc_set_alignment( GTK_MISC(tool_pixmap), 0.5, 0.5 );

    wxToolBarTool *tool = new wxToolBarTool( this, toolIndex, bitmap, pushedBitmap,
                                             toggle, clientData,
                                             helpString1, helpString2,
                                             tool_pixmap );

    GtkToolbarChildType ctype = toggle ? GTK_TOOLBAR_CHILD_TOGGLEBUTTON
                                       : GTK_TOOLBAR_CHILD_BUTTON;

    GtkWidget *item = gtk_toolbar_append_element
                     (
                      m_toolbar,
                      ctype,
                      (GtkWidget *)NULL,
                      (const char *)NULL,
                      helpString1.mbc_str(),
                      "",
                      tool_pixmap,
                      (GtkSignalFunc)gtk_toolbar_callback,
                      (gpointer)tool
                     );

    tool->m_item = item;

    GtkRequisition req;
    (* GTK_WIDGET_CLASS( GTK_OBJECT(m_widget)->klass )->size_request ) (m_widget, &req );
    m_width = req.width;
    m_height = req.height;

    gtk_signal_connect( GTK_OBJECT(tool->m_item),
                        "enter_notify_event",
                        GTK_SIGNAL_FUNC(gtk_toolbar_enter_callback),
                        (gpointer)tool );

    m_tools.Append( tool );

    return tool;
}

bool wxToolBar::AddControl(wxControl *control)
{
    wxCHECK_MSG( control, FALSE, wxT("toolbar: can't insert NULL control") );

    wxCHECK_MSG( control->GetParent() == this, FALSE,
                 wxT("control must have toolbar as parent") );

    m_hasToolAlready = TRUE;

    wxToolBarTool *tool = new wxToolBarTool(control);

    gtk_toolbar_append_widget( m_toolbar, control->m_widget, (const char *) NULL, (const char *) NULL );

    GtkRequisition req;
    (* GTK_WIDGET_CLASS( GTK_OBJECT(m_widget)->klass )->size_request ) (m_widget, &req );
    m_width = req.width;
    m_height = req.height;

    m_tools.Append( tool );

    return TRUE;
}

void wxToolBar::AddSeparator()
{
    gtk_toolbar_append_space( m_toolbar );
}

bool wxToolBar::DeleteTool(int toolIndex)
{
    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_index == toolIndex)
        {
            if (tool->m_control)
                tool->m_control->Destroy();
            else
                gtk_widget_destroy( tool->m_item );
            m_tools.DeleteNode( node );

            return TRUE;
        }
        node = node->Next();
    }

    return FALSE;
}

void wxToolBar::ClearTools()
{
    wxFAIL_MSG( wxT("wxToolBar::ClearTools not implemented") );
}

bool wxToolBar::Realize()
{
    m_x = 0;
    m_y = 0;
    m_width = 100;
    m_height = 0;

    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_bitmap1.Ok())
        {
            int tool_height = tool->m_bitmap1.GetHeight();
            if (tool_height > m_height) m_height = tool_height;
        }

        node = node->Next();
    }

    m_height += 5 + 2*m_yMargin;

    return TRUE;
}

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

#if (GTK_MINOR_VERSION > 0)
            /* we don't disable the tools for GTK 1.0 as the bitmaps don't get
               greyed anyway and this also disables tooltips */
            if (tool->m_item)
                gtk_widget_set_sensitive( tool->m_item, enable );
#endif

            return;
        }
        node = node->Next();
    }

    wxFAIL_MSG( wxT("wrong toolbar index") );
}

void wxToolBar::ToggleTool( int toolIndex, bool toggle )
{
    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_index == toolIndex)
        {
            if ((tool->m_item) && (GTK_IS_TOGGLE_BUTTON(tool->m_item)))
	    {
                tool->m_toggleState = toggle;

	        if (tool->m_bitmap2.Ok())
	        {
	            wxBitmap bitmap = tool->m_bitmap1;
	            if (tool->m_toggleState) bitmap = tool->m_bitmap2;

                    GtkPixmap *pixmap = GTK_PIXMAP( tool->m_pixmap );

                    GdkBitmap *mask = (GdkBitmap *) NULL;
                    if (bitmap.GetMask()) mask = bitmap.GetMask()->GetBitmap();

                    gtk_pixmap_set( pixmap, bitmap.GetPixmap(), mask );
	        }

                m_blockNextEvent = TRUE;  // we cannot use gtk_signal_disconnect here

                gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(tool->m_item), toggle );
	    }

            return;
        }
        node = node->Next();
    }

    wxFAIL_MSG( wxT("wrong toolbar index") );
}

wxObject *wxToolBar::GetToolClientData( int index ) const
{
    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_index == index) return tool->m_clientData;;
        node = node->Next();
    }

    wxFAIL_MSG( wxT("wrong toolbar index") );

    return (wxObject*)NULL;
}

bool wxToolBar::GetToolState(int toolIndex) const
{
    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_index == toolIndex) return tool->m_toggleState;
        node = node->Next();
    }

    wxFAIL_MSG( wxT("wrong toolbar index") );

    return FALSE;
}

bool wxToolBar::GetToolEnabled(int toolIndex) const
{
    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_index == toolIndex) return tool->m_enabled;
        node = node->Next();
    }

    wxFAIL_MSG( wxT("wrong toolbar index") );

    return FALSE;
}

void wxToolBar::SetMargins( int x, int y )
{
    wxCHECK_RET( !m_hasToolAlready, wxT("wxToolBar::SetMargins must be called before adding tool.") );

    if (x > 2) gtk_toolbar_append_space( m_toolbar );  // oh well

    m_xMargin = x;
    m_yMargin = y;
}

void wxToolBar::SetToolPacking( int WXUNUSED(packing) )
{
    wxFAIL_MSG( wxT("wxToolBar::SetToolPacking not implemented") );
}

void wxToolBar::SetToolSeparation( int separation )
{
    gtk_toolbar_set_space_size( m_toolbar, separation );
    m_separation = separation;
}

int wxToolBar::GetToolPacking()
{
    return 0;
}

int wxToolBar::GetToolSeparation()
{
    return m_separation;
}

wxString wxToolBar::GetToolLongHelp(int toolIndex)
{
    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_index == toolIndex)
        {
            return tool->m_longHelpString;
        }
        node = node->Next();
    }

    wxFAIL_MSG( wxT("wrong toolbar index") );

    return wxT("");
}

wxString wxToolBar::GetToolShortHelp(int toolIndex)
{
    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_index == toolIndex)
        {
            return tool->m_shortHelpString;
        }
        node = node->Next();
    }

    wxFAIL_MSG( wxT("wrong toolbar index") );

    return wxT("");
}

void wxToolBar::SetToolLongHelp(int toolIndex, const wxString& helpString)
{
    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_index == toolIndex)
        {
            tool->m_longHelpString = helpString;
            return;
        }
        node = node->Next();
    }

    wxFAIL_MSG( wxT("wrong toolbar index") );

    return;
}

void wxToolBar::SetToolShortHelp(int toolIndex, const wxString& helpString)
{
    wxNode *node = m_tools.First();
    while (node)
    {
        wxToolBarTool *tool = (wxToolBarTool*)node->Data();
        if (tool->m_index == toolIndex)
        {
            tool->m_shortHelpString = helpString;
            return;
        }
        node = node->Next();
    }

    wxFAIL_MSG( wxT("wrong toolbar index") );

    return;
}

void wxToolBar::OnIdle( wxIdleEvent &WXUNUSED(ievent) )
{
    wxEvtHandler* evtHandler = GetEventHandler();

    wxNode* node = m_tools.First();
    while (node)
    {
        wxToolBarTool* tool = (wxToolBarTool*) node->Data();

        wxUpdateUIEvent event( tool->m_index );
        event.SetEventObject(this);

        if (evtHandler->ProcessEvent( event ))
        {
            if (event.GetSetEnabled())
                EnableTool(tool->m_index, event.GetEnabled());
            if (event.GetSetChecked())
                ToggleTool(tool->m_index, event.GetChecked());
/*
            if (event.GetSetText())
                // Set tooltip?
*/
        }

        node = node->Next();
    }
}

void wxToolBar::OnInternalIdle()
{
    wxCursor cursor = m_cursor;
    if (g_globalCursor.Ok()) cursor = g_globalCursor;

    if (cursor.Ok())
    {
        /* I now set the cursor the anew in every OnInternalIdle call
	   as setting the cursor in a parent window also effects the
	   windows above so that checking for the current cursor is
	   not possible. */

        if (HasFlag(wxTB_DOCKABLE))
	{
	    /* if the toolbar is dockable, then m_widget stands for the
	       GtkHandleBox widget, which uses its own window so that we
	       can set the cursor for it. if the toolbar is not dockable,
	       m_widget comes from m_toolbar which uses its parent's
	       window ("windowless windows") and thus we cannot set the
	       cursor. */
	    gdk_window_set_cursor( m_widget->window, cursor.GetCursor() );
	}

        wxNode *node = m_tools.First();
	while (node)
        {
	    wxToolBarTool *tool = (wxToolBarTool*)node->Data();
	    node = node->Next();

	    if (!tool->m_item || !tool->m_item->window)
		continue;
	    else
	        gdk_window_set_cursor( tool->m_item->window, cursor.GetCursor() );
        }
    }

    UpdateWindowUI();
}

#endif
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: tbargtk.cpp
	3	// Purpose: GTK toolbar
	4	// Author: Robert Roebling
	5	// RCS-ID: $Id$
	6	// Copyright: (c) Robert Roebling
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	#ifdef __GNUG__
	11	#pragma implementation "tbargtk.h"
	12	#endif
	13
	14	#include "wx/toolbar.h"
	15
	16	#if wxUSE_TOOLBAR
	17
	18	#include "wx/frame.h"
	19
	20	#include "glib.h"
	21	#include "gdk/gdk.h"
	22	#include "gtk/gtk.h"
	23
	24	//-----------------------------------------------------------------------------
	25	// idle system
	26	//-----------------------------------------------------------------------------
	27
	28	extern void wxapp_install_idle_handler();
	29	extern bool g_isIdle;
	30
	31	//-----------------------------------------------------------------------------
	32	// data
	33	//-----------------------------------------------------------------------------
	34
	35	extern bool g_blockEventsOnDrag;
	36	extern wxCursor g_globalCursor;
	37
	38	//-----------------------------------------------------------------------------
	39	// "clicked" (internal from gtk_toolbar)
	40	//-----------------------------------------------------------------------------
	41
	42	static void gtk_toolbar_callback( GtkWidget WXUNUSED(widget), wxToolBarTool tool )
	43	{
	44	if (g_isIdle)
	45	wxapp_install_idle_handler();
	46
	47	if (tool->m_owner->m_blockNextEvent)
	48	{
	49	tool->m_owner->m_blockNextEvent = FALSE;
	50	return;
	51	}
	52
	53	if (g_blockEventsOnDrag) return;
	54	if (!tool->m_enabled) return;
	55
	56	if (tool->m_isToggle)
	57	{
	58	tool->m_toggleState = !tool->m_toggleState;
	59
	60	if (tool->m_bitmap2.Ok())
	61	{
	62	wxBitmap bitmap = tool->m_bitmap1;
	63	if (tool->m_toggleState) bitmap = tool->m_bitmap2;
	64
	65	GtkPixmap *pixmap = GTK_PIXMAP( tool->m_pixmap );
	66
	67	GdkBitmap mask = (GdkBitmap ) NULL;
	68	if (bitmap.GetMask()) mask = bitmap.GetMask()->GetBitmap();
	69
	70	gtk_pixmap_set( pixmap, bitmap.GetPixmap(), mask );
	71	}
	72	}
	73
	74	tool->m_owner->OnLeftClick( tool->m_index, tool->m_toggleState );
	75	}
	76
	77	//-----------------------------------------------------------------------------
	78	// "enter_notify_event"
	79	//-----------------------------------------------------------------------------
	80
	81	static gint gtk_toolbar_enter_callback( GtkWidget *WXUNUSED(widget),
	82	GdkEventCrossing WXUNUSED(gdk_event), wxToolBarTool tool )
	83	{
	84	if (g_isIdle) wxapp_install_idle_handler();
	85
	86	if (g_blockEventsOnDrag) return TRUE;
	87
	88
	89	wxToolBar *tb = tool->m_owner;
	90
	91	#if (GTK_MINOR_VERSION == 0)
	92	/* we grey-out the tip text of disabled tool in GTK 1.0 */
	93	if (tool->m_enabled)
	94	{
	95	if (tb->m_fg->red != 0)
	96	{
	97	tb->m_fg->red = 0;
	98	tb->m_fg->green = 0;
	99	tb->m_fg->blue = 0;
	100	gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(tb->m_toolbar) ), tb->m_fg );
	101
	102	gtk_tooltips_set_colors( GTK_TOOLBAR(tb->m_toolbar)->tooltips, tb->m_bg, tb->m_fg );
	103	}
	104	}
	105	else
	106	{
	107	if (tb->m_fg->red == 0)
	108	{
	109	tb->m_fg->red = 33000;
	110	tb->m_fg->green = 33000;
	111	tb->m_fg->blue = 33000;
	112	gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(tb->m_toolbar) ), tb->m_fg );
	113	gtk_tooltips_set_colors( GTK_TOOLBAR(tb->m_toolbar)->tooltips, tb->m_bg, tb->m_fg );
	114	}
	115	}
	116	#endif
	117
	118	/* emit the event */
	119
	120	tb->OnMouseEnter( tool->m_index );
	121
	122	return FALSE;
	123	}
	124
	125	//-----------------------------------------------------------------------------
	126	// InsertChild callback for wxToolBar
	127	//-----------------------------------------------------------------------------
	128
	129	static void wxInsertChildInToolBar( wxToolBar* WXUNUSED(parent), wxWindow* WXUNUSED(child) )
	130	{
	131	/* we don't do anything here but pray */
	132	}
	133
	134	//-----------------------------------------------------------------------------
	135	// wxToolBar
	136	//-----------------------------------------------------------------------------
	137
	138	IMPLEMENT_DYNAMIC_CLASS(wxToolBar,wxControl)
	139
	140	BEGIN_EVENT_TABLE(wxToolBar, wxControl)
	141	EVT_IDLE(wxToolBar::OnIdle)
	142	END_EVENT_TABLE()
	143
	144	wxToolBar::wxToolBar()
	145	{
	146	}
	147
	148	wxToolBar::wxToolBar( wxWindow *parent, wxWindowID id,
	149	const wxPoint& pos, const wxSize& size,
	150	long style, const wxString& name )
	151	{
	152	Create( parent, id, pos, size, style, name );
	153	}
	154
	155	wxToolBar::~wxToolBar()
	156	{
	157	delete m_fg;
	158	delete m_bg;
	159	}
	160
	161	bool wxToolBar::Create( wxWindow *parent, wxWindowID id,
	162	const wxPoint& pos, const wxSize& size,
	163	long style, const wxString& name )
	164	{
	165	m_needParent = TRUE;
	166	m_blockNextEvent = FALSE;
	167	m_insertCallback = (wxInsertChildFunction)wxInsertChildInToolBar;
	168
	169	if (!PreCreation( parent, pos, size ) \|\|
	170	!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
	171	{
	172	wxFAIL_MSG( wxT("wxToolBar creation failed") );
	173	return FALSE;
	174	}
	175
	176	m_tools.DeleteContents( TRUE );
	177
	178	m_toolbar = GTK_TOOLBAR( gtk_toolbar_new( GTK_ORIENTATION_HORIZONTAL,
	179	GTK_TOOLBAR_ICONS ) );
	180
	181	// gtk_toolbar_set_space_style( m_toolbar, GTK_TOOLBAR_SPACE_LINE );
	182	m_separation = 5;
	183	gtk_toolbar_set_space_size( m_toolbar, m_separation );
	184	m_hasToolAlready = FALSE;
	185
	186	if (style & wxTB_DOCKABLE)
	187	{
	188	m_widget = gtk_handle_box_new();
	189	gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
	190	gtk_widget_show( GTK_WIDGET(m_toolbar) );
	191
	192	#if (GTK_MINOR_VERSION > 0)
	193	if (style & wxTB_FLAT)
	194	gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
	195	#endif
	196	}
	197	else
	198	{
	199	m_widget = GTK_WIDGET(m_toolbar);
	200	}
	201
	202	gtk_toolbar_set_tooltips( GTK_TOOLBAR(m_toolbar), TRUE );
	203
	204	#if (GTK_MINOR_VERSION > 0)
	205	if (style & wxTB_FLAT)
	206	gtk_toolbar_set_button_relief( GTK_TOOLBAR(m_toolbar), GTK_RELIEF_NONE );
	207	#endif
	208
	209	m_fg = new GdkColor;
	210	m_fg->red = 0;
	211	m_fg->green = 0;
	212	m_fg->blue = 0;
	213	gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(m_toolbar) ), m_fg );
	214
	215	m_bg = new GdkColor;
	216	m_bg->red = 65535;
	217	m_bg->green = 65535;
	218	m_bg->blue = 50000;
	219	gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(m_toolbar) ), m_bg );
	220
	221	#if (GTK_MINOR_VERSION > 0)
	222	gtk_tooltips_force_window( GTK_TOOLBAR(m_toolbar)->tooltips );
	223
	224	GtkStyle *g_style =
	225	gtk_style_copy(
	226	gtk_widget_get_style(
	227	GTK_TOOLBAR(m_toolbar)->tooltips->tip_window ) );
	228
	229	g_style->bg[GTK_STATE_NORMAL] = *m_bg;
	230	gtk_widget_set_style( GTK_TOOLBAR(m_toolbar)->tooltips->tip_window, g_style );
	231	#else
	232	gtk_tooltips_set_colors( GTK_TOOLBAR(m_toolbar)->tooltips, m_bg, m_fg );
	233	#endif
	234
	235	m_xMargin = 0;
	236	m_yMargin = 0;
	237
	238	m_parent->DoAddChild( this );
	239
	240	PostCreation();
	241
	242	Show( TRUE );
	243
	244	return TRUE;
	245	}
	246
	247	bool wxToolBar::OnLeftClick( int toolIndex, bool toggleDown )
	248	{
	249	wxCommandEvent event( wxEVT_COMMAND_TOOL_CLICKED, toolIndex );
	250	event.SetEventObject(this);
	251	event.SetInt( toolIndex );
	252	event.SetExtraLong((long) toggleDown);
	253
	254	GetEventHandler()->ProcessEvent(event);
	255
	256	return TRUE;
	257	}
	258
	259	void wxToolBar::OnRightClick( int toolIndex, float WXUNUSED(x), float WXUNUSED(y) )
	260	{
	261	wxCommandEvent event( wxEVT_COMMAND_TOOL_RCLICKED, toolIndex );
	262	event.SetEventObject( this );
	263	event.SetInt( toolIndex );
	264
	265	GetEventHandler()->ProcessEvent(event);
	266	}
	267
	268	void wxToolBar::OnMouseEnter( int toolIndex )
	269	{
	270	wxCommandEvent event( wxEVT_COMMAND_TOOL_ENTER, GetId() );
	271	event.SetEventObject(this);
	272	event.SetInt( toolIndex );
	273
	274	GetEventHandler()->ProcessEvent(event);
	275	}
	276
	277	wxToolBarTool *wxToolBar::AddTool( int toolIndex, const wxBitmap& bitmap,
	278	const wxBitmap& pushedBitmap, bool toggle,
	279	wxCoord WXUNUSED(xPos), wxCoord WXUNUSED(yPos), wxObject *clientData,
	280	const wxString& helpString1, const wxString& helpString2 )
	281	{
	282	m_hasToolAlready = TRUE;
	283
	284	wxCHECK_MSG( bitmap.Ok(), (wxToolBarTool *)NULL,
	285	wxT("invalid bitmap for wxToolBar icon") );
	286
	287	wxCHECK_MSG( bitmap.GetBitmap() == NULL, (wxToolBarTool *)NULL,
	288	wxT("wxToolBar doesn't support GdkBitmap") );
	289
	290	wxCHECK_MSG( bitmap.GetPixmap() != NULL, (wxToolBarTool *)NULL,
	291	wxT("wxToolBar::Add needs a wxBitmap") );
	292
	293	GtkWidget tool_pixmap = (GtkWidget )NULL;
	294
	295	GdkPixmap *pixmap = bitmap.GetPixmap();
	296
	297	GdkBitmap mask = (GdkBitmap )NULL;
	298	if ( bitmap.GetMask() )
	299	mask = bitmap.GetMask()->GetBitmap();
	300
	301	tool_pixmap = gtk_pixmap_new( pixmap, mask );
	302	#if (GTK_MINOR_VERSION > 0)
	303	gtk_pixmap_set_build_insensitive( GTK_PIXMAP(tool_pixmap), TRUE );
	304	#endif
	305
	306	gtk_misc_set_alignment( GTK_MISC(tool_pixmap), 0.5, 0.5 );
	307
	308	wxToolBarTool *tool = new wxToolBarTool( this, toolIndex, bitmap, pushedBitmap,
	309	toggle, clientData,
	310	helpString1, helpString2,
	311	tool_pixmap );
	312
	313	GtkToolbarChildType ctype = toggle ? GTK_TOOLBAR_CHILD_TOGGLEBUTTON
	314	: GTK_TOOLBAR_CHILD_BUTTON;
	315
	316	GtkWidget *item = gtk_toolbar_append_element
	317	(
	318	m_toolbar,
	319	ctype,
	320	(GtkWidget *)NULL,
	321	(const char *)NULL,
	322	helpString1.mbc_str(),
	323	"",
	324	tool_pixmap,
	325	(GtkSignalFunc)gtk_toolbar_callback,
	326	(gpointer)tool
	327	);
	328
	329	tool->m_item = item;
	330
	331	GtkRequisition req;
	332	(* GTK_WIDGET_CLASS( GTK_OBJECT(m_widget)->klass )->size_request ) (m_widget, &req );
	333	m_width = req.width;
	334	m_height = req.height;
	335
	336	gtk_signal_connect( GTK_OBJECT(tool->m_item),
	337	"enter_notify_event",
	338	GTK_SIGNAL_FUNC(gtk_toolbar_enter_callback),
	339	(gpointer)tool );
	340
	341	m_tools.Append( tool );
	342
	343	return tool;
	344	}
	345
	346	bool wxToolBar::AddControl(wxControl *control)
	347	{
	348	wxCHECK_MSG( control, FALSE, wxT("toolbar: can't insert NULL control") );
	349
	350	wxCHECK_MSG( control->GetParent() == this, FALSE,
	351	wxT("control must have toolbar as parent") );
	352
	353	m_hasToolAlready = TRUE;
	354
	355	wxToolBarTool *tool = new wxToolBarTool(control);
	356
	357	gtk_toolbar_append_widget( m_toolbar, control->m_widget, (const char ) NULL, (const char ) NULL );
	358
	359	GtkRequisition req;
	360	(* GTK_WIDGET_CLASS( GTK_OBJECT(m_widget)->klass )->size_request ) (m_widget, &req );
	361	m_width = req.width;
	362	m_height = req.height;
	363
	364	m_tools.Append( tool );
	365
	366	return TRUE;
	367	}
	368
	369	void wxToolBar::AddSeparator()
	370	{
	371	gtk_toolbar_append_space( m_toolbar );
	372	}
	373
	374	bool wxToolBar::DeleteTool(int toolIndex)
	375	{
	376	wxNode *node = m_tools.First();
	377	while (node)
	378	{
	379	wxToolBarTool tool = (wxToolBarTool)node->Data();
	380	if (tool->m_index == toolIndex)
	381	{
	382	if (tool->m_control)
	383	tool->m_control->Destroy();
	384	else
	385	gtk_widget_destroy( tool->m_item );
	386	m_tools.DeleteNode( node );
	387
	388	return TRUE;
	389	}
	390	node = node->Next();
	391	}
	392
	393	return FALSE;
	394	}
	395
	396	void wxToolBar::ClearTools()
	397	{
	398	wxFAIL_MSG( wxT("wxToolBar::ClearTools not implemented") );
	399	}
	400
	401	bool wxToolBar::Realize()
	402	{
	403	m_x = 0;
	404	m_y = 0;
	405	m_width = 100;
	406	m_height = 0;
	407
	408	wxNode *node = m_tools.First();
	409	while (node)
	410	{
	411	wxToolBarTool tool = (wxToolBarTool)node->Data();
	412	if (tool->m_bitmap1.Ok())
	413	{
	414	int tool_height = tool->m_bitmap1.GetHeight();
	415	if (tool_height > m_height) m_height = tool_height;
	416	}
	417
	418	node = node->Next();
	419	}
	420
	421	m_height += 5 + 2*m_yMargin;
	422
	423	return TRUE;
	424	}
	425
	426	void wxToolBar::EnableTool(int toolIndex, bool enable)
	427	{
	428	wxNode *node = m_tools.First();
	429	while (node)
	430	{
	431	wxToolBarTool tool = (wxToolBarTool)node->Data();
	432	if (tool->m_index == toolIndex)
	433	{
	434	tool->m_enabled = enable;
	435
	436	#if (GTK_MINOR_VERSION > 0)
	437	/* we don't disable the tools for GTK 1.0 as the bitmaps don't get
	438	greyed anyway and this also disables tooltips */
	439	if (tool->m_item)
	440	gtk_widget_set_sensitive( tool->m_item, enable );
	441	#endif
	442
	443	return;
	444	}
	445	node = node->Next();
	446	}
	447
	448	wxFAIL_MSG( wxT("wrong toolbar index") );
	449	}
	450
	451	void wxToolBar::ToggleTool( int toolIndex, bool toggle )
	452	{
	453	wxNode *node = m_tools.First();
	454	while (node)
	455	{
	456	wxToolBarTool tool = (wxToolBarTool)node->Data();
	457	if (tool->m_index == toolIndex)
	458	{
	459	if ((tool->m_item) && (GTK_IS_TOGGLE_BUTTON(tool->m_item)))
	460	{
	461	tool->m_toggleState = toggle;
	462
	463	if (tool->m_bitmap2.Ok())
	464	{
	465	wxBitmap bitmap = tool->m_bitmap1;
	466	if (tool->m_toggleState) bitmap = tool->m_bitmap2;
	467
	468	GtkPixmap *pixmap = GTK_PIXMAP( tool->m_pixmap );
	469
	470	GdkBitmap mask = (GdkBitmap ) NULL;
	471	if (bitmap.GetMask()) mask = bitmap.GetMask()->GetBitmap();
	472
	473	gtk_pixmap_set( pixmap, bitmap.GetPixmap(), mask );
	474	}
	475
	476	m_blockNextEvent = TRUE; // we cannot use gtk_signal_disconnect here
	477
	478	gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(tool->m_item), toggle );
	479	}
	480
	481	return;
	482	}
	483	node = node->Next();
	484	}
	485
	486	wxFAIL_MSG( wxT("wrong toolbar index") );
	487	}
	488
	489	wxObject *wxToolBar::GetToolClientData( int index ) const
	490	{
	491	wxNode *node = m_tools.First();
	492	while (node)
	493	{
	494	wxToolBarTool tool = (wxToolBarTool)node->Data();
	495	if (tool->m_index == index) return tool->m_clientData;;
	496	node = node->Next();
	497	}
	498
	499	wxFAIL_MSG( wxT("wrong toolbar index") );
	500
	501	return (wxObject*)NULL;
	502	}
	503
	504	bool wxToolBar::GetToolState(int toolIndex) const
	505	{
	506	wxNode *node = m_tools.First();
	507	while (node)
	508	{
	509	wxToolBarTool tool = (wxToolBarTool)node->Data();
	510	if (tool->m_index == toolIndex) return tool->m_toggleState;
	511	node = node->Next();
	512	}
	513
	514	wxFAIL_MSG( wxT("wrong toolbar index") );
	515
	516	return FALSE;
	517	}
	518
	519	bool wxToolBar::GetToolEnabled(int toolIndex) const
	520	{
	521	wxNode *node = m_tools.First();
	522	while (node)
	523	{
	524	wxToolBarTool tool = (wxToolBarTool)node->Data();
	525	if (tool->m_index == toolIndex) return tool->m_enabled;
	526	node = node->Next();
	527	}
	528
	529	wxFAIL_MSG( wxT("wrong toolbar index") );
	530
	531	return FALSE;
	532	}
	533
	534	void wxToolBar::SetMargins( int x, int y )
	535	{
	536	wxCHECK_RET( !m_hasToolAlready, wxT("wxToolBar::SetMargins must be called before adding tool.") );
	537
	538	if (x > 2) gtk_toolbar_append_space( m_toolbar ); // oh well
	539
	540	m_xMargin = x;
	541	m_yMargin = y;
	542	}
	543
	544	void wxToolBar::SetToolPacking( int WXUNUSED(packing) )
	545	{
	546	wxFAIL_MSG( wxT("wxToolBar::SetToolPacking not implemented") );
	547	}
	548
	549	void wxToolBar::SetToolSeparation( int separation )
	550	{
	551	gtk_toolbar_set_space_size( m_toolbar, separation );
	552	m_separation = separation;
	553	}
	554
	555	int wxToolBar::GetToolPacking()
	556	{
	557	return 0;
	558	}
	559
	560	int wxToolBar::GetToolSeparation()
	561	{
	562	return m_separation;
	563	}
	564
	565	wxString wxToolBar::GetToolLongHelp(int toolIndex)
	566	{
	567	wxNode *node = m_tools.First();
	568	while (node)
	569	{
	570	wxToolBarTool tool = (wxToolBarTool)node->Data();
	571	if (tool->m_index == toolIndex)
	572	{
	573	return tool->m_longHelpString;
	574	}
	575	node = node->Next();
	576	}
	577
	578	wxFAIL_MSG( wxT("wrong toolbar index") );
	579
	580	return wxT("");
	581	}
	582
	583	wxString wxToolBar::GetToolShortHelp(int toolIndex)
	584	{
	585	wxNode *node = m_tools.First();
	586	while (node)
	587	{
	588	wxToolBarTool tool = (wxToolBarTool)node->Data();
	589	if (tool->m_index == toolIndex)
	590	{
	591	return tool->m_shortHelpString;
	592	}
	593	node = node->Next();
	594	}
	595
	596	wxFAIL_MSG( wxT("wrong toolbar index") );
	597
	598	return wxT("");
	599	}
	600
	601	void wxToolBar::SetToolLongHelp(int toolIndex, const wxString& helpString)
	602	{
	603	wxNode *node = m_tools.First();
	604	while (node)
	605	{
	606	wxToolBarTool tool = (wxToolBarTool)node->Data();
	607	if (tool->m_index == toolIndex)
	608	{
	609	tool->m_longHelpString = helpString;
	610	return;
	611	}
	612	node = node->Next();
	613	}
	614
	615	wxFAIL_MSG( wxT("wrong toolbar index") );
	616
	617	return;
	618	}
	619
	620	void wxToolBar::SetToolShortHelp(int toolIndex, const wxString& helpString)
	621	{
	622	wxNode *node = m_tools.First();
	623	while (node)
	624	{
	625	wxToolBarTool tool = (wxToolBarTool)node->Data();
	626	if (tool->m_index == toolIndex)
	627	{
	628	tool->m_shortHelpString = helpString;
	629	return;
	630	}
	631	node = node->Next();
	632	}
	633
	634	wxFAIL_MSG( wxT("wrong toolbar index") );
	635
	636	return;
	637	}
	638
	639	void wxToolBar::OnIdle( wxIdleEvent &WXUNUSED(ievent) )
	640	{
	641	wxEvtHandler* evtHandler = GetEventHandler();
	642
	643	wxNode* node = m_tools.First();
	644	while (node)
	645	{
	646	wxToolBarTool* tool = (wxToolBarTool*) node->Data();
	647
	648	wxUpdateUIEvent event( tool->m_index );
	649	event.SetEventObject(this);
	650
	651	if (evtHandler->ProcessEvent( event ))
	652	{
	653	if (event.GetSetEnabled())
	654	EnableTool(tool->m_index, event.GetEnabled());
	655	if (event.GetSetChecked())
	656	ToggleTool(tool->m_index, event.GetChecked());
	657	/*
	658	if (event.GetSetText())
	659	// Set tooltip?
	660	*/
	661	}
	662
	663	node = node->Next();
	664	}
	665	}
	666
	667	void wxToolBar::OnInternalIdle()
	668	{
	669	wxCursor cursor = m_cursor;
	670	if (g_globalCursor.Ok()) cursor = g_globalCursor;
	671
	672	if (cursor.Ok())
	673	{
	674	/* I now set the cursor the anew in every OnInternalIdle call
	675	as setting the cursor in a parent window also effects the
	676	windows above so that checking for the current cursor is
	677	not possible. */
	678
	679	if (HasFlag(wxTB_DOCKABLE))
	680	{
	681	/* if the toolbar is dockable, then m_widget stands for the
	682	GtkHandleBox widget, which uses its own window so that we
	683	can set the cursor for it. if the toolbar is not dockable,
	684	m_widget comes from m_toolbar which uses its parent's
	685	window ("windowless windows") and thus we cannot set the
	686	cursor. */
	687	gdk_window_set_cursor( m_widget->window, cursor.GetCursor() );
	688	}
	689
	690	wxNode *node = m_tools.First();
	691	while (node)
	692	{
	693	wxToolBarTool tool = (wxToolBarTool)node->Data();
	694	node = node->Next();
	695
	696	if (!tool->m_item \|\| !tool->m_item->window)
	697	continue;
	698	else
	699	gdk_window_set_cursor( tool->m_item->window, cursor.GetCursor() );
	700	}
	701	}
	702
	703	UpdateWindowUI();
	704	}
	705
	706	#endif