src/gtk/button.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/gtk/button.cpp
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#if wxUSE_BUTTON

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

#include "wx/stockitem.h"

#include "wx/gtk/private.h"

// ----------------------------------------------------------------------------
// GTK callbacks
// ----------------------------------------------------------------------------

extern "C"
{

static void
wxgtk_button_clicked_callback(GtkWidget *WXUNUSED(widget), wxButton *button)
{
    if ( button->GTKShouldIgnoreEvent() )
        return;

    wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, button->GetId());
    event.SetEventObject(button);
    button->HandleWindowEvent(event);
}

static void
wxgtk_button_enter_callback(GtkWidget *WXUNUSED(widget), wxButton *button)
{
    if ( button->GTKShouldIgnoreEvent() )
        return;

    button->GTKMouseEnters();
}

static void
wxgtk_button_leave_callback(GtkWidget *WXUNUSED(widget), wxButton *button)
{
    if ( button->GTKShouldIgnoreEvent() )
        return;

    button->GTKMouseLeaves();
}

static void
wxgtk_button_press_callback(GtkWidget *WXUNUSED(widget), wxButton *button)
{
    if ( button->GTKShouldIgnoreEvent() )
        return;

    button->GTKPressed();
}

static void
wxgtk_button_released_callback(GtkWidget *WXUNUSED(widget), wxButton *button)
{
    if ( button->GTKShouldIgnoreEvent() )
        return;

    button->GTKReleased();
}

//-----------------------------------------------------------------------------
// "style_set" from m_widget
//-----------------------------------------------------------------------------

static void
wxgtk_button_style_set_callback(GtkWidget* widget, GtkStyle*, wxButton* win)
{
    /* the default button has a border around it */
    wxWindow* parent = win->GetParent();
    if (parent && parent->m_wxwindow && gtk_widget_get_can_default(widget))
    {
        GtkBorder* border = NULL;
        gtk_widget_style_get(widget, "default_border", &border, NULL);
        if (border)
        {
            win->MoveWindow(
                win->m_x - border->left,
                win->m_y - border->top,
                win->m_width + border->left + border->right,
                win->m_height + border->top + border->bottom);
            gtk_border_free(border);
        }
    }
}

} // extern "C"

//-----------------------------------------------------------------------------
// wxButton
//-----------------------------------------------------------------------------

bool wxButton::Create(wxWindow *parent,
                      wxWindowID id,
                      const wxString &label,
                      const wxPoint& pos,
                      const wxSize& size,
                      long style,
                      const wxValidator& validator,
                      const wxString& name)
{
    if (!PreCreation( parent, pos, size ) ||
        !CreateBase( parent, id, pos, size, style, validator, name ))
    {
        wxFAIL_MSG( wxT("wxButton creation failed") );
        return false;
    }

    // create either a standard button with text label (which may still contain
    // an image under GTK+ 2.6+) or a bitmap-only button if we don't have any
    // label
    const bool
        useLabel = !(style & wxBU_NOTEXT) && (!label.empty() || wxIsStockID(id));
    if ( useLabel )
    {
        m_widget = gtk_button_new_with_mnemonic("");
    }
    else // no label, suppose we will have a bitmap
    {
        m_widget = gtk_button_new();

        GtkWidget *image = gtk_image_new();
        gtk_widget_show(image);
        gtk_container_add(GTK_CONTAINER(m_widget), image);
    }

    g_object_ref(m_widget);

    float x_alignment = 0.5;
    if (HasFlag(wxBU_LEFT))
        x_alignment = 0.0;
    else if (HasFlag(wxBU_RIGHT))
        x_alignment = 1.0;

    float y_alignment = 0.5;
    if (HasFlag(wxBU_TOP))
        y_alignment = 0.0;
    else if (HasFlag(wxBU_BOTTOM))
        y_alignment = 1.0;

    gtk_button_set_alignment(GTK_BUTTON(m_widget), x_alignment, y_alignment);

    if ( useLabel )
        SetLabel(label);

    if (style & wxNO_BORDER)
       gtk_button_set_relief( GTK_BUTTON(m_widget), GTK_RELIEF_NONE );

    g_signal_connect_after (m_widget, "clicked",
                            G_CALLBACK (wxgtk_button_clicked_callback),
                            this);

    g_signal_connect_after (m_widget, "style_set",
                            G_CALLBACK (wxgtk_button_style_set_callback),
                            this);

    m_parent->DoAddChild( this );

    PostCreation(size);

    return true;
}


wxWindow *wxButton::SetDefault()
{
    wxWindow *oldDefault = wxButtonBase::SetDefault();

    gtk_widget_set_can_default(m_widget, TRUE);
    gtk_widget_grab_default( m_widget );

    // resize for default border
    wxgtk_button_style_set_callback( m_widget, NULL, this );

    return oldDefault;
}

/* static */
wxSize wxButtonBase::GetDefaultSize()
{
    static wxSize size = wxDefaultSize;
    if (size == wxDefaultSize)
    {
        // NB: Default size of buttons should be same as size of stock
        //     buttons as used in most GTK+ apps. Unfortunately it's a little
        //     tricky to obtain this size: stock button's size may be smaller
        //     than size of button in GtkButtonBox and vice versa,
        //     GtkButtonBox's minimal button size may be smaller than stock
        //     button's size. We have to retrieve both values and combine them.

        GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        GtkWidget *box = gtk_hbutton_box_new();
        GtkWidget *btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
        gtk_container_add(GTK_CONTAINER(box), btn);
        gtk_container_add(GTK_CONTAINER(wnd), box);
        GtkRequisition req;
        gtk_widget_size_request(btn, &req);

        gint minwidth, minheight;
        gtk_widget_style_get(box,
                             "child-min-width", &minwidth,
                             "child-min-height", &minheight,
                             NULL);

        size.x = wxMax(minwidth, req.width);
        size.y = wxMax(minheight, req.height);

        gtk_widget_destroy(wnd);
    }
    return size;
}

void wxButton::SetLabel( const wxString &lbl )
{
    wxCHECK_RET( m_widget != NULL, wxT("invalid button") );

    wxString label(lbl);

    if (label.empty() && wxIsStockID(m_windowId))
        label = wxGetStockLabel(m_windowId);

    wxControl::SetLabel(label);

    // don't use label if it was explicitly disabled
    if ( HasFlag(wxBU_NOTEXT) )
        return;

    if (wxIsStockID(m_windowId) && wxIsStockLabel(m_windowId, label))
    {
        const char *stock = wxGetStockGtkID(m_windowId);
        if (stock)
        {
            gtk_button_set_label(GTK_BUTTON(m_widget), stock);
            gtk_button_set_use_stock(GTK_BUTTON(m_widget), TRUE);
            return;
        }
    }

    // this call is necessary if the button had been initially created without
    // a (text) label -- then we didn't use gtk_button_new_with_mnemonic() and
    // so "use-underline" GtkButton property remained unset
    gtk_button_set_use_underline(GTK_BUTTON(m_widget), TRUE);
    const wxString labelGTK = GTKConvertMnemonics(label);
    gtk_button_set_label(GTK_BUTTON(m_widget), wxGTK_CONV(labelGTK));
    gtk_button_set_use_stock(GTK_BUTTON(m_widget), FALSE);

    GTKApplyWidgetStyle( false );
}

#if wxUSE_MARKUP
bool wxButton::DoSetLabelMarkup(const wxString& markup)
{
    wxCHECK_MSG( m_widget != NULL, false, "invalid button" );

    const wxString stripped = RemoveMarkup(markup);
    if ( stripped.empty() && !markup.empty() )
        return false;

    wxControl::SetLabel(stripped);

    GtkLabel * const label = GTKGetLabel();
    wxCHECK_MSG( label, false, "no label in this button?" );

    GTKSetLabelWithMarkupForLabel(label, markup);

    return true;
}
#endif // wxUSE_MARKUP

bool wxButton::Enable( bool enable )
{
    if (!base_type::Enable(enable))
        return false;

    gtk_widget_set_sensitive(gtk_bin_get_child(GTK_BIN(m_widget)), enable);

    if (enable)
        GTKFixSensitivity();

    GTKUpdateBitmap();

    return true;
}

GdkWindow *wxButton::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
{
    return GTK_BUTTON(m_widget)->event_window;
}

GtkLabel *wxButton::GTKGetLabel() const
{
    GtkWidget* child = gtk_bin_get_child(GTK_BIN(m_widget));
    if ( GTK_IS_ALIGNMENT(child) )
    {
        GtkWidget* box = gtk_bin_get_child(GTK_BIN(child));
        GtkLabel* label = NULL;
        GList* list = gtk_container_get_children(GTK_CONTAINER(box));
        for (GList* item = list; item; item = item->next)
        {
            GtkBoxChild* boxChild = static_cast<GtkBoxChild*>(item->data);
            if ( GTK_IS_LABEL(boxChild->widget) )
                label = GTK_LABEL(boxChild->widget);
        }
        g_list_free(list);

        return label;
    }

    return GTK_LABEL(child);
}

void wxButton::DoApplyWidgetStyle(GtkRcStyle *style)
{
    gtk_widget_modify_style(m_widget, style);
    GtkWidget* child = gtk_bin_get_child(GTK_BIN(m_widget));
    gtk_widget_modify_style(child, style);

    // for buttons with images, the path to the label is (at least in 2.12)
    // GtkButton -> GtkAlignment -> GtkHBox -> GtkLabel
    if ( GTK_IS_ALIGNMENT(child) )
    {
        GtkWidget* box = gtk_bin_get_child(GTK_BIN(child));
        if ( GTK_IS_BOX(box) )
        {
            GList* list = gtk_container_get_children(GTK_CONTAINER(box));
            for (GList* item = list; item; item = item->next)
            {
                GtkBoxChild* boxChild = static_cast<GtkBoxChild*>(item->data);
                gtk_widget_modify_style(boxChild->widget, style);
            }
            g_list_free(list);
        }
    }
}

wxSize wxButton::DoGetBestSize() const
{
    // the default button in wxGTK is bigger than the other ones because of an
    // extra border around it, but we don't want to take it into account in
    // our size calculations (otherwise the result is visually ugly), so
    // always return the size of non default button from here
    const bool isDefault = gtk_widget_has_default(m_widget);
    if ( isDefault )
    {
        // temporarily unset default flag
        gtk_widget_set_can_default(m_widget, FALSE);
    }

    wxSize ret( wxControl::DoGetBestSize() );

    if ( isDefault )
    {
        // set it back again
        gtk_widget_set_can_default(m_widget, TRUE);
    }

    if (!HasFlag(wxBU_EXACTFIT))
    {
        wxSize defaultSize = GetDefaultSize();
        if (ret.x < defaultSize.x)
            ret.x = defaultSize.x;
        if (ret.y < defaultSize.y)
            ret.y = defaultSize.y;
    }

    CacheBestSize(ret);
    return ret;
}

// static
wxVisualAttributes
wxButton::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
{
    return GetDefaultAttributesFromGTKWidget(gtk_button_new);
}

// ----------------------------------------------------------------------------
// bitmaps support
// ----------------------------------------------------------------------------

void wxButton::GTKMouseEnters()
{
    m_isCurrent = true;

    GTKUpdateBitmap();
}

void wxButton::GTKMouseLeaves()
{
    m_isCurrent = false;

    GTKUpdateBitmap();
}

void wxButton::GTKPressed()
{
    m_isPressed = true;

    GTKUpdateBitmap();
}

void wxButton::GTKReleased()
{
    m_isPressed = false;

    GTKUpdateBitmap();
}

void wxButton::GTKOnFocus(wxFocusEvent& event)
{
    event.Skip();

    GTKUpdateBitmap();
}

wxButton::State wxButton::GTKGetCurrentState() const
{
    if ( !IsThisEnabled() )
        return m_bitmaps[State_Disabled].IsOk() ? State_Disabled : State_Normal;

    if ( m_isPressed && m_bitmaps[State_Pressed].IsOk() )
        return State_Pressed;

    if ( m_isCurrent && m_bitmaps[State_Current].IsOk() )
        return State_Current;

    if ( HasFocus() && m_bitmaps[State_Focused].IsOk() )
        return State_Focused;

    return State_Normal;
}

void wxButton::GTKUpdateBitmap()
{
    // if we don't show bitmaps at all, there is nothing to update
    if ( m_bitmaps[State_Normal].IsOk() )
    {
        // if we do show them, this will return a state for which we do have a
        // valid bitmap
        State state = GTKGetCurrentState();

        GTKDoShowBitmap(m_bitmaps[state]);
    }
}

void wxButton::GTKDoShowBitmap(const wxBitmap& bitmap)
{
    wxASSERT_MSG( bitmap.IsOk(), "invalid bitmap" );

    GtkWidget *image;
    if ( DontShowLabel() )
    {
        image = gtk_bin_get_child(GTK_BIN(m_widget));
    }
    else // have both label and bitmap
    {
#ifdef __WXGTK26__
        if ( !gtk_check_version(2,6,0) )
        {
            image = gtk_button_get_image(GTK_BUTTON(m_widget));
        }
        else
#endif // __WXGTK26__
        {
            // buttons with both label and bitmap are only supported with GTK+
            // 2.6 so far
            //
            // it shouldn't be difficult to implement them ourselves for the
            // previous GTK+ versions by stuffing a container with a label and
            // an image inside GtkButton but there doesn't seem to be much
            // point in doing this for ancient GTK+ versions
            return;
        }
    }

    wxCHECK_RET( image && GTK_IS_IMAGE(image), "must have image widget" );

    gtk_image_set_from_pixbuf(GTK_IMAGE(image), bitmap.GetPixbuf());
}

wxBitmap wxButton::DoGetBitmap(State which) const
{
    return m_bitmaps[which];
}

void wxButton::DoSetBitmap(const wxBitmap& bitmap, State which)
{
    switch ( which )
    {
        case State_Normal:
            if ( DontShowLabel() )
            {
                // we only have the bitmap in this button, never remove it but
                // do invalidate the best size when the bitmap (and presumably
                // its size) changes
                InvalidateBestSize();
            }
#ifdef __WXGTK26__
            // normal image is special: setting it enables images for the button and
            // resetting it to nothing disables all of them
            else if ( !gtk_check_version(2,6,0) )
            {
                GtkWidget *image = gtk_button_get_image(GTK_BUTTON(m_widget));
                if ( image && !bitmap.IsOk() )
                {
                    gtk_container_remove(GTK_CONTAINER(m_widget), image);
                }
                else if ( !image && bitmap.IsOk() )
                {
                    image = gtk_image_new();
                    gtk_button_set_image(GTK_BUTTON(m_widget), image);
                }
                else // image presence or absence didn't change
                {
                    // don't invalidate best size below
                    break;
                }

                InvalidateBestSize();
            }
#endif // GTK+ 2.6+
            break;

        case State_Pressed:
            if ( bitmap.IsOk() )
            {
                if ( !m_bitmaps[which].IsOk() )
                {
                    // we need to install the callbacks to be notified about
                    // the button pressed state change
                    g_signal_connect
                    (
                        m_widget,
                        "pressed",
                        G_CALLBACK(wxgtk_button_press_callback),
                        this
                    );

                    g_signal_connect
                    (
                        m_widget,
                        "released",
                        G_CALLBACK(wxgtk_button_released_callback),
                        this
                    );
                }
            }
            else // no valid bitmap
            {
                if ( m_bitmaps[which].IsOk() )
                {
                    // we don't need to be notified about the button pressed
                    // state changes any more
                    g_signal_handlers_disconnect_by_func
                    (
                        m_widget,
                        (gpointer)wxgtk_button_press_callback,
                        this
                    );

                    g_signal_handlers_disconnect_by_func
                    (
                        m_widget,
                        (gpointer)wxgtk_button_released_callback,
                        this
                    );

                    // also make sure we don't remain stuck in pressed state
                    if ( m_isPressed )
                    {
                        m_isPressed = false;
                        GTKUpdateBitmap();
                    }
                }
            }
            break;

        case State_Current:
            // the logic here is the same as above for State_Pressed: we need
            // to connect the handlers if we must be notified about the changes
            // in the button current state and we disconnect them when/if we
            // don't need them any more
            if ( bitmap.IsOk() )
            {
                if ( !m_bitmaps[which].IsOk() )
                {
                    g_signal_connect
                    (
                        m_widget,
                        "enter",
                        G_CALLBACK(wxgtk_button_enter_callback),
                        this
                    );

                    g_signal_connect
                    (
                        m_widget,
                        "leave",
                        G_CALLBACK(wxgtk_button_leave_callback),
                        this
                    );
                }
            }
            else // no valid bitmap
            {
                if ( m_bitmaps[which].IsOk() )
                {
                    g_signal_handlers_disconnect_by_func
                    (
                        m_widget,
                        (gpointer)wxgtk_button_enter_callback,
                        this
                    );

                    g_signal_handlers_disconnect_by_func
                    (
                        m_widget,
                        (gpointer)wxgtk_button_leave_callback,
                        this
                    );

                    if ( m_isCurrent )
                    {
                        m_isCurrent = false;
                        GTKUpdateBitmap();
                    }
                }
            }
            break;

        case State_Focused:
            if ( bitmap.IsOk() )
            {
                Connect(wxEVT_SET_FOCUS,
                        wxFocusEventHandler(wxButton::GTKOnFocus));
                Connect(wxEVT_KILL_FOCUS,
                        wxFocusEventHandler(wxButton::GTKOnFocus));
            }
            else // no valid focused bitmap
            {
                Disconnect(wxEVT_SET_FOCUS,
                           wxFocusEventHandler(wxButton::GTKOnFocus));
                Disconnect(wxEVT_KILL_FOCUS,
                           wxFocusEventHandler(wxButton::GTKOnFocus));
            }
            break;

        default:
            // no callbacks to connect/disconnect
            ;
    }

    m_bitmaps[which] = bitmap;

    // update the bitmap immediately if necessary, otherwise it will be done
    // when the bitmap for the corresponding state is needed the next time by
    // GTKUpdateBitmap()
    if ( bitmap.IsOk() && which == GTKGetCurrentState() )
    {
        GTKDoShowBitmap(bitmap);
    }
}

void wxButton::DoSetBitmapPosition(wxDirection dir)
{
#ifdef __WXGTK210__
    if ( !gtk_check_version(2,10,0) )
    {
        GtkPositionType gtkpos;
        switch ( dir )
        {
            default:
                wxFAIL_MSG( "invalid position" );
                // fall through

            case wxLEFT:
                gtkpos = GTK_POS_LEFT;
                break;

            case wxRIGHT:
                gtkpos = GTK_POS_RIGHT;
                break;

            case wxTOP:
                gtkpos = GTK_POS_TOP;
                break;

            case wxBOTTOM:
                gtkpos = GTK_POS_BOTTOM;
                break;
        }

        gtk_button_set_image_position(GTK_BUTTON(m_widget), gtkpos);
        InvalidateBestSize();
    }
#endif // GTK+ 2.10+
}

#endif // wxUSE_BUTTON
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/gtk/button.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	// For compilers that support precompilation, includes "wx.h".
	11	#include "wx/wxprec.h"
	12
	13	#if wxUSE_BUTTON
	14
	15	#ifndef WX_PRECOMP
	16	#include "wx/button.h"
	17	#endif
	18
	19	#include "wx/stockitem.h"
	20
	21	#include "wx/gtk/private.h"
	22
	23	// ----------------------------------------------------------------------------
	24	// GTK callbacks
	25	// ----------------------------------------------------------------------------
	26
	27	extern "C"
	28	{
	29
	30	static void
	31	wxgtk_button_clicked_callback(GtkWidget WXUNUSED(widget), wxButton button)
	32	{
	33	if ( button->GTKShouldIgnoreEvent() )
	34	return;
	35
	36	wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, button->GetId());
	37	event.SetEventObject(button);
	38	button->HandleWindowEvent(event);
	39	}
	40
	41	static void
	42	wxgtk_button_enter_callback(GtkWidget WXUNUSED(widget), wxButton button)
	43	{
	44	if ( button->GTKShouldIgnoreEvent() )
	45	return;
	46
	47	button->GTKMouseEnters();
	48	}
	49
	50	static void
	51	wxgtk_button_leave_callback(GtkWidget WXUNUSED(widget), wxButton button)
	52	{
	53	if ( button->GTKShouldIgnoreEvent() )
	54	return;
	55
	56	button->GTKMouseLeaves();
	57	}
	58
	59	static void
	60	wxgtk_button_press_callback(GtkWidget WXUNUSED(widget), wxButton button)
	61	{
	62	if ( button->GTKShouldIgnoreEvent() )
	63	return;
	64
	65	button->GTKPressed();
	66	}
	67
	68	static void
	69	wxgtk_button_released_callback(GtkWidget WXUNUSED(widget), wxButton button)
	70	{
	71	if ( button->GTKShouldIgnoreEvent() )
	72	return;
	73
	74	button->GTKReleased();
	75	}
	76
	77	//-----------------------------------------------------------------------------
	78	// "style_set" from m_widget
	79	//-----------------------------------------------------------------------------
	80
	81	static void
	82	wxgtk_button_style_set_callback(GtkWidget* widget, GtkStyle, wxButton win)
	83	{
	84	/* the default button has a border around it */
	85	wxWindow* parent = win->GetParent();
	86	if (parent && parent->m_wxwindow && gtk_widget_get_can_default(widget))
	87	{
	88	GtkBorder* border = NULL;
	89	gtk_widget_style_get(widget, "default_border", &border, NULL);
	90	if (border)
	91	{
	92	win->MoveWindow(
	93	win->m_x - border->left,
	94	win->m_y - border->top,
	95	win->m_width + border->left + border->right,
	96	win->m_height + border->top + border->bottom);
	97	gtk_border_free(border);
	98	}
	99	}
	100	}
	101
	102	} // extern "C"
	103
	104	//-----------------------------------------------------------------------------
	105	// wxButton
	106	//-----------------------------------------------------------------------------
	107
	108	bool wxButton::Create(wxWindow *parent,
	109	wxWindowID id,
	110	const wxString &label,
	111	const wxPoint& pos,
	112	const wxSize& size,
	113	long style,
	114	const wxValidator& validator,
	115	const wxString& name)
	116	{
	117	if (!PreCreation( parent, pos, size ) \|\|
	118	!CreateBase( parent, id, pos, size, style, validator, name ))
	119	{
	120	wxFAIL_MSG( wxT("wxButton creation failed") );
	121	return false;
	122	}
	123
	124	// create either a standard button with text label (which may still contain
	125	// an image under GTK+ 2.6+) or a bitmap-only button if we don't have any
	126	// label
	127	const bool
	128	useLabel = !(style & wxBU_NOTEXT) && (!label.empty() \|\| wxIsStockID(id));
	129	if ( useLabel )
	130	{
	131	m_widget = gtk_button_new_with_mnemonic("");
	132	}
	133	else // no label, suppose we will have a bitmap
	134	{
	135	m_widget = gtk_button_new();
	136
	137	GtkWidget *image = gtk_image_new();
	138	gtk_widget_show(image);
	139	gtk_container_add(GTK_CONTAINER(m_widget), image);
	140	}
	141
	142	g_object_ref(m_widget);
	143
	144	float x_alignment = 0.5;
	145	if (HasFlag(wxBU_LEFT))
	146	x_alignment = 0.0;
	147	else if (HasFlag(wxBU_RIGHT))
	148	x_alignment = 1.0;
	149
	150	float y_alignment = 0.5;
	151	if (HasFlag(wxBU_TOP))
	152	y_alignment = 0.0;
	153	else if (HasFlag(wxBU_BOTTOM))
	154	y_alignment = 1.0;
	155
	156	gtk_button_set_alignment(GTK_BUTTON(m_widget), x_alignment, y_alignment);
	157
	158	if ( useLabel )
	159	SetLabel(label);
	160
	161	if (style & wxNO_BORDER)
	162	gtk_button_set_relief( GTK_BUTTON(m_widget), GTK_RELIEF_NONE );
	163
	164	g_signal_connect_after (m_widget, "clicked",
	165	G_CALLBACK (wxgtk_button_clicked_callback),
	166	this);
	167
	168	g_signal_connect_after (m_widget, "style_set",
	169	G_CALLBACK (wxgtk_button_style_set_callback),
	170	this);
	171
	172	m_parent->DoAddChild( this );
	173
	174	PostCreation(size);
	175
	176	return true;
	177	}
	178
	179
	180	wxWindow *wxButton::SetDefault()
	181	{
	182	wxWindow *oldDefault = wxButtonBase::SetDefault();
	183
	184	gtk_widget_set_can_default(m_widget, TRUE);
	185	gtk_widget_grab_default( m_widget );
	186
	187	// resize for default border
	188	wxgtk_button_style_set_callback( m_widget, NULL, this );
	189
	190	return oldDefault;
	191	}
	192
	193	/* static */
	194	wxSize wxButtonBase::GetDefaultSize()
	195	{
	196	static wxSize size = wxDefaultSize;
	197	if (size == wxDefaultSize)
	198	{
	199	// NB: Default size of buttons should be same as size of stock
	200	// buttons as used in most GTK+ apps. Unfortunately it's a little
	201	// tricky to obtain this size: stock button's size may be smaller
	202	// than size of button in GtkButtonBox and vice versa,
	203	// GtkButtonBox's minimal button size may be smaller than stock
	204	// button's size. We have to retrieve both values and combine them.
	205
	206	GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	207	GtkWidget *box = gtk_hbutton_box_new();
	208	GtkWidget *btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
	209	gtk_container_add(GTK_CONTAINER(box), btn);
	210	gtk_container_add(GTK_CONTAINER(wnd), box);
	211	GtkRequisition req;
	212	gtk_widget_size_request(btn, &req);
	213
	214	gint minwidth, minheight;
	215	gtk_widget_style_get(box,
	216	"child-min-width", &minwidth,
	217	"child-min-height", &minheight,
	218	NULL);
	219
	220	size.x = wxMax(minwidth, req.width);
	221	size.y = wxMax(minheight, req.height);
	222
	223	gtk_widget_destroy(wnd);
	224	}
	225	return size;
	226	}
	227
	228	void wxButton::SetLabel( const wxString &lbl )
	229	{
	230	wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
	231
	232	wxString label(lbl);
	233
	234	if (label.empty() && wxIsStockID(m_windowId))
	235	label = wxGetStockLabel(m_windowId);
	236
	237	wxControl::SetLabel(label);
	238
	239	// don't use label if it was explicitly disabled
	240	if ( HasFlag(wxBU_NOTEXT) )
	241	return;
	242
	243	if (wxIsStockID(m_windowId) && wxIsStockLabel(m_windowId, label))
	244	{
	245	const char *stock = wxGetStockGtkID(m_windowId);
	246	if (stock)
	247	{
	248	gtk_button_set_label(GTK_BUTTON(m_widget), stock);
	249	gtk_button_set_use_stock(GTK_BUTTON(m_widget), TRUE);
	250	return;
	251	}
	252	}
	253
	254	// this call is necessary if the button had been initially created without
	255	// a (text) label -- then we didn't use gtk_button_new_with_mnemonic() and
	256	// so "use-underline" GtkButton property remained unset
	257	gtk_button_set_use_underline(GTK_BUTTON(m_widget), TRUE);
	258	const wxString labelGTK = GTKConvertMnemonics(label);
	259	gtk_button_set_label(GTK_BUTTON(m_widget), wxGTK_CONV(labelGTK));
	260	gtk_button_set_use_stock(GTK_BUTTON(m_widget), FALSE);
	261
	262	GTKApplyWidgetStyle( false );
	263	}
	264
	265	#if wxUSE_MARKUP
	266	bool wxButton::DoSetLabelMarkup(const wxString& markup)
	267	{
	268	wxCHECK_MSG( m_widget != NULL, false, "invalid button" );
	269
	270	const wxString stripped = RemoveMarkup(markup);
	271	if ( stripped.empty() && !markup.empty() )
	272	return false;
	273
	274	wxControl::SetLabel(stripped);
	275
	276	GtkLabel * const label = GTKGetLabel();
	277	wxCHECK_MSG( label, false, "no label in this button?" );
	278
	279	GTKSetLabelWithMarkupForLabel(label, markup);
	280
	281	return true;
	282	}
	283	#endif // wxUSE_MARKUP
	284
	285	bool wxButton::Enable( bool enable )
	286	{
	287	if (!base_type::Enable(enable))
	288	return false;
	289
	290	gtk_widget_set_sensitive(gtk_bin_get_child(GTK_BIN(m_widget)), enable);
	291
	292	if (enable)
	293	GTKFixSensitivity();
	294
	295	GTKUpdateBitmap();
	296
	297	return true;
	298	}
	299
	300	GdkWindow *wxButton::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
	301	{
	302	return GTK_BUTTON(m_widget)->event_window;
	303	}
	304
	305	GtkLabel *wxButton::GTKGetLabel() const
	306	{
	307	GtkWidget* child = gtk_bin_get_child(GTK_BIN(m_widget));
	308	if ( GTK_IS_ALIGNMENT(child) )
	309	{
	310	GtkWidget* box = gtk_bin_get_child(GTK_BIN(child));
	311	GtkLabel* label = NULL;
	312	GList* list = gtk_container_get_children(GTK_CONTAINER(box));
	313	for (GList* item = list; item; item = item->next)
	314	{
	315	GtkBoxChild* boxChild = static_cast<GtkBoxChild*>(item->data);
	316	if ( GTK_IS_LABEL(boxChild->widget) )
	317	label = GTK_LABEL(boxChild->widget);
	318	}
	319	g_list_free(list);
	320
	321	return label;
	322	}
	323
	324	return GTK_LABEL(child);
	325	}
	326
	327	void wxButton::DoApplyWidgetStyle(GtkRcStyle *style)
	328	{
	329	gtk_widget_modify_style(m_widget, style);
	330	GtkWidget* child = gtk_bin_get_child(GTK_BIN(m_widget));
	331	gtk_widget_modify_style(child, style);
	332
	333	// for buttons with images, the path to the label is (at least in 2.12)
	334	// GtkButton -> GtkAlignment -> GtkHBox -> GtkLabel
	335	if ( GTK_IS_ALIGNMENT(child) )
	336	{
	337	GtkWidget* box = gtk_bin_get_child(GTK_BIN(child));
	338	if ( GTK_IS_BOX(box) )
	339	{
	340	GList* list = gtk_container_get_children(GTK_CONTAINER(box));
	341	for (GList* item = list; item; item = item->next)
	342	{
	343	GtkBoxChild* boxChild = static_cast<GtkBoxChild*>(item->data);
	344	gtk_widget_modify_style(boxChild->widget, style);
	345	}
	346	g_list_free(list);
	347	}
	348	}
	349	}
	350
	351	wxSize wxButton::DoGetBestSize() const
	352	{
	353	// the default button in wxGTK is bigger than the other ones because of an
	354	// extra border around it, but we don't want to take it into account in
	355	// our size calculations (otherwise the result is visually ugly), so
	356	// always return the size of non default button from here
	357	const bool isDefault = gtk_widget_has_default(m_widget);
	358	if ( isDefault )
	359	{
	360	// temporarily unset default flag
	361	gtk_widget_set_can_default(m_widget, FALSE);
	362	}
	363
	364	wxSize ret( wxControl::DoGetBestSize() );
	365
	366	if ( isDefault )
	367	{
	368	// set it back again
	369	gtk_widget_set_can_default(m_widget, TRUE);
	370	}
	371
	372	if (!HasFlag(wxBU_EXACTFIT))
	373	{
	374	wxSize defaultSize = GetDefaultSize();
	375	if (ret.x < defaultSize.x)
	376	ret.x = defaultSize.x;
	377	if (ret.y < defaultSize.y)
	378	ret.y = defaultSize.y;
	379	}
	380
	381	CacheBestSize(ret);
	382	return ret;
	383	}
	384
	385	// static
	386	wxVisualAttributes
	387	wxButton::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
	388	{
	389	return GetDefaultAttributesFromGTKWidget(gtk_button_new);
	390	}
	391
	392	// ----------------------------------------------------------------------------
	393	// bitmaps support
	394	// ----------------------------------------------------------------------------
	395
	396	void wxButton::GTKMouseEnters()
	397	{
	398	m_isCurrent = true;
	399
	400	GTKUpdateBitmap();
	401	}
	402
	403	void wxButton::GTKMouseLeaves()
	404	{
	405	m_isCurrent = false;
	406
	407	GTKUpdateBitmap();
	408	}
	409
	410	void wxButton::GTKPressed()
	411	{
	412	m_isPressed = true;
	413
	414	GTKUpdateBitmap();
	415	}
	416
	417	void wxButton::GTKReleased()
	418	{
	419	m_isPressed = false;
	420
	421	GTKUpdateBitmap();
	422	}
	423
	424	void wxButton::GTKOnFocus(wxFocusEvent& event)
	425	{
	426	event.Skip();
	427
	428	GTKUpdateBitmap();
	429	}
	430
	431	wxButton::State wxButton::GTKGetCurrentState() const
	432	{
	433	if ( !IsThisEnabled() )
	434	return m_bitmaps[State_Disabled].IsOk() ? State_Disabled : State_Normal;
	435
	436	if ( m_isPressed && m_bitmaps[State_Pressed].IsOk() )
	437	return State_Pressed;
	438
	439	if ( m_isCurrent && m_bitmaps[State_Current].IsOk() )
	440	return State_Current;
	441
	442	if ( HasFocus() && m_bitmaps[State_Focused].IsOk() )
	443	return State_Focused;
	444
	445	return State_Normal;
	446	}
	447
	448	void wxButton::GTKUpdateBitmap()
	449	{
	450	// if we don't show bitmaps at all, there is nothing to update
	451	if ( m_bitmaps[State_Normal].IsOk() )
	452	{
	453	// if we do show them, this will return a state for which we do have a
	454	// valid bitmap
	455	State state = GTKGetCurrentState();
	456
	457	GTKDoShowBitmap(m_bitmaps[state]);
	458	}
	459	}
	460
	461	void wxButton::GTKDoShowBitmap(const wxBitmap& bitmap)
	462	{
	463	wxASSERT_MSG( bitmap.IsOk(), "invalid bitmap" );
	464
	465	GtkWidget *image;
	466	if ( DontShowLabel() )
	467	{
	468	image = gtk_bin_get_child(GTK_BIN(m_widget));
	469	}
	470	else // have both label and bitmap
	471	{
	472	#ifdef __WXGTK26__
	473	if ( !gtk_check_version(2,6,0) )
	474	{
	475	image = gtk_button_get_image(GTK_BUTTON(m_widget));
	476	}
	477	else
	478	#endif // __WXGTK26__
	479	{
	480	// buttons with both label and bitmap are only supported with GTK+
	481	// 2.6 so far
	482	//
	483	// it shouldn't be difficult to implement them ourselves for the
	484	// previous GTK+ versions by stuffing a container with a label and
	485	// an image inside GtkButton but there doesn't seem to be much
	486	// point in doing this for ancient GTK+ versions
	487	return;
	488	}
	489	}
	490
	491	wxCHECK_RET( image && GTK_IS_IMAGE(image), "must have image widget" );
	492
	493	gtk_image_set_from_pixbuf(GTK_IMAGE(image), bitmap.GetPixbuf());
	494	}
	495
	496	wxBitmap wxButton::DoGetBitmap(State which) const
	497	{
	498	return m_bitmaps[which];
	499	}
	500
	501	void wxButton::DoSetBitmap(const wxBitmap& bitmap, State which)
	502	{
	503	switch ( which )
	504	{
	505	case State_Normal:
	506	if ( DontShowLabel() )
	507	{
	508	// we only have the bitmap in this button, never remove it but
	509	// do invalidate the best size when the bitmap (and presumably
	510	// its size) changes
	511	InvalidateBestSize();
	512	}
	513	#ifdef __WXGTK26__
	514	// normal image is special: setting it enables images for the button and
	515	// resetting it to nothing disables all of them
	516	else if ( !gtk_check_version(2,6,0) )
	517	{
	518	GtkWidget *image = gtk_button_get_image(GTK_BUTTON(m_widget));
	519	if ( image && !bitmap.IsOk() )
	520	{
	521	gtk_container_remove(GTK_CONTAINER(m_widget), image);
	522	}
	523	else if ( !image && bitmap.IsOk() )
	524	{
	525	image = gtk_image_new();
	526	gtk_button_set_image(GTK_BUTTON(m_widget), image);
	527	}
	528	else // image presence or absence didn't change
	529	{
	530	// don't invalidate best size below
	531	break;
	532	}
	533
	534	InvalidateBestSize();
	535	}
	536	#endif // GTK+ 2.6+
	537	break;
	538
	539	case State_Pressed:
	540	if ( bitmap.IsOk() )
	541	{
	542	if ( !m_bitmaps[which].IsOk() )
	543	{
	544	// we need to install the callbacks to be notified about
	545	// the button pressed state change
	546	g_signal_connect
	547	(
	548	m_widget,
	549	"pressed",
	550	G_CALLBACK(wxgtk_button_press_callback),
	551	this
	552	);
	553
	554	g_signal_connect
	555	(
	556	m_widget,
	557	"released",
	558	G_CALLBACK(wxgtk_button_released_callback),
	559	this
	560	);
	561	}
	562	}
	563	else // no valid bitmap
	564	{
	565	if ( m_bitmaps[which].IsOk() )
	566	{
	567	// we don't need to be notified about the button pressed
	568	// state changes any more
	569	g_signal_handlers_disconnect_by_func
	570	(
	571	m_widget,
	572	(gpointer)wxgtk_button_press_callback,
	573	this
	574	);
	575
	576	g_signal_handlers_disconnect_by_func
	577	(
	578	m_widget,
	579	(gpointer)wxgtk_button_released_callback,
	580	this
	581	);
	582
	583	// also make sure we don't remain stuck in pressed state
	584	if ( m_isPressed )
	585	{
	586	m_isPressed = false;
	587	GTKUpdateBitmap();
	588	}
	589	}
	590	}
	591	break;
	592
	593	case State_Current:
	594	// the logic here is the same as above for State_Pressed: we need
	595	// to connect the handlers if we must be notified about the changes
	596	// in the button current state and we disconnect them when/if we
	597	// don't need them any more
	598	if ( bitmap.IsOk() )
	599	{
	600	if ( !m_bitmaps[which].IsOk() )
	601	{
	602	g_signal_connect
	603	(
	604	m_widget,
	605	"enter",
	606	G_CALLBACK(wxgtk_button_enter_callback),
	607	this
	608	);
	609
	610	g_signal_connect
	611	(
	612	m_widget,
	613	"leave",
	614	G_CALLBACK(wxgtk_button_leave_callback),
	615	this
	616	);
	617	}
	618	}
	619	else // no valid bitmap
	620	{
	621	if ( m_bitmaps[which].IsOk() )
	622	{
	623	g_signal_handlers_disconnect_by_func
	624	(
	625	m_widget,
	626	(gpointer)wxgtk_button_enter_callback,
	627	this
	628	);
	629
	630	g_signal_handlers_disconnect_by_func
	631	(
	632	m_widget,
	633	(gpointer)wxgtk_button_leave_callback,
	634	this
	635	);
	636
	637	if ( m_isCurrent )
	638	{
	639	m_isCurrent = false;
	640	GTKUpdateBitmap();
	641	}
	642	}
	643	}
	644	break;
	645
	646	case State_Focused:
	647	if ( bitmap.IsOk() )
	648	{
	649	Connect(wxEVT_SET_FOCUS,
	650	wxFocusEventHandler(wxButton::GTKOnFocus));
	651	Connect(wxEVT_KILL_FOCUS,
	652	wxFocusEventHandler(wxButton::GTKOnFocus));
	653	}
	654	else // no valid focused bitmap
	655	{
	656	Disconnect(wxEVT_SET_FOCUS,
	657	wxFocusEventHandler(wxButton::GTKOnFocus));
	658	Disconnect(wxEVT_KILL_FOCUS,
	659	wxFocusEventHandler(wxButton::GTKOnFocus));
	660	}
	661	break;
	662
	663	default:
	664	// no callbacks to connect/disconnect
	665	;
	666	}
	667
	668	m_bitmaps[which] = bitmap;
	669
	670	// update the bitmap immediately if necessary, otherwise it will be done
	671	// when the bitmap for the corresponding state is needed the next time by
	672	// GTKUpdateBitmap()
	673	if ( bitmap.IsOk() && which == GTKGetCurrentState() )
	674	{
	675	GTKDoShowBitmap(bitmap);
	676	}
	677	}
	678
	679	void wxButton::DoSetBitmapPosition(wxDirection dir)
	680	{
	681	#ifdef __WXGTK210__
	682	if ( !gtk_check_version(2,10,0) )
	683	{
	684	GtkPositionType gtkpos;
	685	switch ( dir )
	686	{
	687	default:
	688	wxFAIL_MSG( "invalid position" );
	689	// fall through
	690
	691	case wxLEFT:
	692	gtkpos = GTK_POS_LEFT;
	693	break;
	694
	695	case wxRIGHT:
	696	gtkpos = GTK_POS_RIGHT;
	697	break;
	698
	699	case wxTOP:
	700	gtkpos = GTK_POS_TOP;
	701	break;
	702
	703	case wxBOTTOM:
	704	gtkpos = GTK_POS_BOTTOM;
	705	break;
	706	}
	707
	708	gtk_button_set_image_position(GTK_BUTTON(m_widget), gtkpos);
	709	InvalidateBestSize();
	710	}
	711	#endif // GTK+ 2.10+
	712	}
	713
	714	#endif // wxUSE_BUTTON