src/gtk/radiobox.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/gtk/radiobox.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_RADIOBOX

#include "wx/radiobox.h"

#if wxUSE_TOOLTIPS
    #include "wx/tooltip.h"
#endif

#include "wx/gtk/private.h"
#include <gdk/gdkkeysyms.h>

//-----------------------------------------------------------------------------
// wxGTKRadioButtonInfo
//-----------------------------------------------------------------------------
// structure internally used by wxRadioBox to store its child buttons

class wxGTKRadioButtonInfo : public wxObject
{
public:
    wxGTKRadioButtonInfo( GtkRadioButton * abutton, const wxRect & arect )
    : button( abutton ), rect( arect ) {}

    GtkRadioButton * button;
    wxRect           rect;
};

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

#include "wx/listimpl.cpp"
WX_DEFINE_LIST( wxRadioBoxButtonsInfoList )

extern bool          g_blockEventsOnDrag;

//-----------------------------------------------------------------------------
// "clicked"
//-----------------------------------------------------------------------------

extern "C" {
static void gtk_radiobutton_clicked_callback( GtkToggleButton *button, wxRadioBox *rb )
{
    if (!rb->m_hasVMT) return;
    if (g_blockEventsOnDrag) return;

    if (!button->active) return;

    wxCommandEvent event( wxEVT_COMMAND_RADIOBOX_SELECTED, rb->GetId() );
    event.SetInt( rb->GetSelection() );
    event.SetString( rb->GetStringSelection() );
    event.SetEventObject( rb );
    rb->HandleWindowEvent(event);
}
}

//-----------------------------------------------------------------------------
// "key_press_event"
//-----------------------------------------------------------------------------

extern "C" {
static gint gtk_radiobox_keypress_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxRadioBox *rb )
{
    if (!rb->m_hasVMT) return FALSE;
    if (g_blockEventsOnDrag) return FALSE;

    if ( ((gdk_event->keyval == GDK_Tab) ||
          (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
         rb->GetParent() && (rb->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
    {
        wxNavigationKeyEvent new_event;
        new_event.SetEventObject( rb->GetParent() );
        // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
        new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
        // CTRL-TAB changes the (parent) window, i.e. switch notebook page
        new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
        new_event.SetCurrentFocus( rb );
        return rb->GetParent()->HandleWindowEvent(new_event);
    }

    if ((gdk_event->keyval != GDK_Up) &&
        (gdk_event->keyval != GDK_Down) &&
        (gdk_event->keyval != GDK_Left) &&
        (gdk_event->keyval != GDK_Right))
    {
        return FALSE;
    }

    wxRadioBoxButtonsInfoList::compatibility_iterator node = rb->m_buttonsInfo.GetFirst();
    while( node && GTK_WIDGET( node->GetData()->button ) != widget )
    {
        node = node->GetNext();
    }
    if (!node)
    {
        return FALSE;
    }

    if ((gdk_event->keyval == GDK_Up) ||
        (gdk_event->keyval == GDK_Left))
    {
        if (node == rb->m_buttonsInfo.GetFirst())
            node = rb->m_buttonsInfo.GetLast();
        else
            node = node->GetPrevious();
    }
    else
    {
        if (node == rb->m_buttonsInfo.GetLast())
            node = rb->m_buttonsInfo.GetFirst();
        else
            node = node->GetNext();
    }

    GtkWidget *button = (GtkWidget*) node->GetData()->button;

    gtk_widget_grab_focus( button );

    return TRUE;
}
}

extern "C" {
static gint gtk_radiobutton_focus_out( GtkWidget * WXUNUSED(widget),
                                       GdkEventFocus *WXUNUSED(event),
                                       wxRadioBox *win )
{
    // NB: This control is composed of several GtkRadioButton widgets and
    //     when focus changes from one of them to another in the same
    //     wxRadioBox, we get a focus-out event followed by focus-in for
    //     another GtkRadioButton owned by the same control. We don't want
    //     to generate two spurious wxEVT_SET_FOCUS events in this case,
    //     so we defer sending wx events until idle time.
    win->GTKHandleFocusOut();

    // never stop the signal emission, it seems to break the kbd handling
    // inside the radiobox
    return FALSE;
}
}

extern "C" {
static gint gtk_radiobutton_focus_in( GtkWidget * WXUNUSED(widget),
                                      GdkEventFocus *WXUNUSED(event),
                                      wxRadioBox *win )
{
    win->GTKHandleFocusIn();

    // never stop the signal emission, it seems to break the kbd handling
    // inside the radiobox
    return FALSE;
}
}

extern "C" {
static void gtk_radiobutton_size_allocate( GtkWidget *widget,
                                           GtkAllocation * alloc,
                                           wxRadioBox *win )
{
    for ( wxRadioBoxButtonsInfoList::compatibility_iterator node = win->m_buttonsInfo.GetFirst();
          node;
          node = node->GetNext())
    {
        if (widget == GTK_WIDGET(node->GetData()->button))
        {
            const wxPoint origin = win->GetPosition();
            wxRect rect = wxRect( alloc->x - origin.x, alloc->y - origin.y,
                                  alloc->width, alloc->height );
            node->GetData()->rect = rect;
            break;
        }
    }
}
}


//-----------------------------------------------------------------------------
// wxRadioBox
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxRadioBox,wxControl)

bool wxRadioBox::Create( wxWindow *parent, wxWindowID id,
                         const wxString& title,
                         const wxPoint &pos, const wxSize &size,
                         const wxArrayString& choices, int majorDim,
                         long style, const wxValidator& validator,
                         const wxString &name )
{
    wxCArrayString chs(choices);

    return Create( parent, id, title, pos, size, chs.GetCount(),
                   chs.GetStrings(), majorDim, style, validator, name );
}

bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
                         const wxPoint &pos, const wxSize &size,
                         int n, const wxString choices[], int majorDim,
                         long style, const wxValidator& validator,
                         const wxString &name )
{
    if (!PreCreation( parent, pos, size ) ||
        !CreateBase( parent, id, pos, size, style, validator, name ))
    {
        wxFAIL_MSG( wxT("wxRadioBox creation failed") );
        return false;
    }

    m_widget = GTKCreateFrame(title);
    g_object_ref(m_widget);
    wxControl::SetLabel(title);
    if ( HasFlag(wxNO_BORDER) )
    {
        // If we don't do this here, the wxNO_BORDER style is ignored in Show()
        gtk_frame_set_shadow_type(GTK_FRAME(m_widget), GTK_SHADOW_NONE);
    }


    // majorDim may be 0 if all trailing parameters were omitted, so don't
    // assert here but just use the correct value for it
    SetMajorDim(majorDim == 0 ? n : majorDim, style);


    unsigned int num_of_cols = GetColumnCount();
    unsigned int num_of_rows = GetRowCount();

    GtkRadioButton *rbtn = NULL;

    GtkWidget *table = gtk_table_new( num_of_rows, num_of_cols, FALSE );
    gtk_table_set_col_spacings( GTK_TABLE(table), 1 );
    gtk_table_set_row_spacings( GTK_TABLE(table), 1 );
    gtk_widget_show( table );
    gtk_container_add( GTK_CONTAINER(m_widget), table );

    wxString label;
    GSList *radio_button_group = NULL;
    for (unsigned int i = 0; i < (unsigned int)n; i++)
    {
        if ( i != 0 )
            radio_button_group = gtk_radio_button_get_group( GTK_RADIO_BUTTON(rbtn) );

        label.Empty();
        for ( wxString::const_iterator pc = choices[i].begin();
              pc != choices[i].end(); ++pc )
        {
            if ( *pc != wxT('&') )
                label += *pc;
        }

        rbtn = GTK_RADIO_BUTTON( gtk_radio_button_new_with_label( radio_button_group, wxGTK_CONV( label ) ) );
        gtk_widget_show( GTK_WIDGET(rbtn) );

        g_signal_connect (rbtn, "key_press_event",
                          G_CALLBACK (gtk_radiobox_keypress_callback), this);

        m_buttonsInfo.Append( new wxGTKRadioButtonInfo( rbtn, wxRect() ) );

        if (HasFlag(wxRA_SPECIFY_COLS))
        {
            int left = i%num_of_cols;
            int right = (i%num_of_cols) + 1;
            int top = i/num_of_cols;
            int bottom = (i/num_of_cols)+1;
            gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(rbtn), left, right, top, bottom,
                  GTK_FILL, GTK_FILL, 1, 1 );
        }
        else
        {
            int left = i/num_of_rows;
            int right = (i/num_of_rows) + 1;
            int top = i%num_of_rows;
            int bottom = (i%num_of_rows)+1;
            gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(rbtn), left, right, top, bottom,
                  GTK_FILL, GTK_FILL, 1, 1 );
        }

        ConnectWidget( GTK_WIDGET(rbtn) );

        if (!i)
            gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(rbtn), TRUE );

        g_signal_connect (rbtn, "clicked",
                          G_CALLBACK (gtk_radiobutton_clicked_callback), this);
        g_signal_connect (rbtn, "focus_in_event",
                          G_CALLBACK (gtk_radiobutton_focus_in), this);
        g_signal_connect (rbtn, "focus_out_event",
                          G_CALLBACK (gtk_radiobutton_focus_out), this);
        g_signal_connect (rbtn, "size_allocate",
                          G_CALLBACK (gtk_radiobutton_size_allocate), this);
    }

    m_parent->DoAddChild( this );

    PostCreation(size);

    return true;
}

wxRadioBox::~wxRadioBox()
{
    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
    while (node)
    {
        GtkWidget *button = GTK_WIDGET( node->GetData()->button );
        gtk_widget_destroy( button );
        node = node->GetNext();
    }
    WX_CLEAR_LIST( wxRadioBoxButtonsInfoList, m_buttonsInfo );
}

bool wxRadioBox::Show( bool show )
{
    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );

    if (!wxControl::Show(show))
    {
        // nothing to do
        return false;
    }

    if ( HasFlag(wxNO_BORDER) )
        gtk_widget_hide( m_widget );

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
    while (node)
    {
        GtkWidget *button = GTK_WIDGET( node->GetData()->button );

        if (show)
            gtk_widget_show( button );
        else
            gtk_widget_hide( button );

        node = node->GetNext();
    }

    return true;
}

void wxRadioBox::SetSelection( int n )
{
    wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") );

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( n );

    wxCHECK_RET( node, wxT("radiobox wrong index") );

    GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData()->button );

    GtkDisableEvents();

    gtk_toggle_button_set_active( button, 1 );

    GtkEnableEvents();
}

int wxRadioBox::GetSelection(void) const
{
    wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid radiobox") );

    int count = 0;

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
    while (node)
    {
        GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData()->button );
        if (button->active) return count;
        count++;
        node = node->GetNext();
    }

    wxFAIL_MSG( wxT("wxRadioBox none selected") );

    return wxNOT_FOUND;
}

wxString wxRadioBox::GetString(unsigned int n) const
{
    wxCHECK_MSG( m_widget != NULL, wxEmptyString, wxT("invalid radiobox") );

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( n );

    wxCHECK_MSG( node, wxEmptyString, wxT("radiobox wrong index") );

    GtkLabel *label = GTK_LABEL(GTK_BIN(node->GetData()->button)->child);

    wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) );

    return str;
}

void wxRadioBox::SetLabel( const wxString& label )
{
    wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") );

    GTKSetLabelForFrame(GTK_FRAME(m_widget), label);
}

void wxRadioBox::SetString(unsigned int item, const wxString& label)
{
    wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") );

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );

    wxCHECK_RET( node, wxT("radiobox wrong index") );

    GtkLabel *g_label = GTK_LABEL(GTK_BIN(node->GetData()->button)->child);

    gtk_label_set_text( g_label, wxGTK_CONV( label ) );
}

bool wxRadioBox::Enable( bool enable )
{
    if ( !wxControl::Enable( enable ) )
        return false;

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
    while (node)
    {
        GtkButton *button = GTK_BUTTON( node->GetData()->button );
        GtkLabel *label = GTK_LABEL(GTK_BIN(button)->child);

        gtk_widget_set_sensitive( GTK_WIDGET(button), enable );
        gtk_widget_set_sensitive( GTK_WIDGET(label), enable );
        node = node->GetNext();
    }

    if (enable)
        GTKFixSensitivity();

    return true;
}

bool wxRadioBox::Enable(unsigned int item, bool enable)
{
    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );

    wxCHECK_MSG( node, false, wxT("radiobox wrong index") );

    GtkButton *button = GTK_BUTTON( node->GetData()->button );
    GtkLabel *label = GTK_LABEL(GTK_BIN(button)->child);

    gtk_widget_set_sensitive( GTK_WIDGET(button), enable );
    gtk_widget_set_sensitive( GTK_WIDGET(label), enable );

    return true;
}

bool wxRadioBox::IsItemEnabled(unsigned int item) const
{
    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );

    wxCHECK_MSG( node, false, wxT("radiobox wrong index") );

    GtkButton *button = GTK_BUTTON( node->GetData()->button );

    // don't use GTK_WIDGET_IS_SENSITIVE() here, we want to return true even if
    // the parent radiobox is disabled
    return GTK_WIDGET_SENSITIVE(GTK_WIDGET(button));
}

bool wxRadioBox::Show(unsigned int item, bool show)
{
    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );

    wxCHECK_MSG( node, false, wxT("radiobox wrong index") );

    GtkWidget *button = GTK_WIDGET( node->GetData()->button );

    if (show)
        gtk_widget_show( button );
    else
        gtk_widget_hide( button );

    return true;
}

bool wxRadioBox::IsItemShown(unsigned int item) const
{
    wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );

    wxCHECK_MSG( node, false, wxT("radiobox wrong index") );

    GtkButton *button = GTK_BUTTON( node->GetData()->button );

    return GTK_WIDGET_VISIBLE(GTK_WIDGET(button));
}

unsigned int wxRadioBox::GetCount() const
{
    return m_buttonsInfo.GetCount();
}

void wxRadioBox::GtkDisableEvents()
{
    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
    while (node)
    {
        g_signal_handlers_block_by_func(node->GetData()->button,
            (gpointer)gtk_radiobutton_clicked_callback, this);

        node = node->GetNext();
    }
}

void wxRadioBox::GtkEnableEvents()
{
    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
    while (node)
    {
        g_signal_handlers_unblock_by_func(node->GetData()->button,
            (gpointer)gtk_radiobutton_clicked_callback, this);

        node = node->GetNext();
    }
}

void wxRadioBox::DoApplyWidgetStyle(GtkRcStyle *style)
{
    GTKFrameApplyWidgetStyle(GTK_FRAME(m_widget), style);

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
    while (node)
    {
        GtkWidget *widget = GTK_WIDGET( node->GetData()->button );

        gtk_widget_modify_style( widget, style );
        gtk_widget_modify_style(GTK_BIN(widget)->child, style);

        node = node->GetNext();
    }
}

bool wxRadioBox::GTKWidgetNeedsMnemonic() const
{
    return true;
}

void wxRadioBox::GTKWidgetDoSetMnemonic(GtkWidget* w)
{
    GTKFrameSetMnemonicWidget(GTK_FRAME(m_widget), w);
}

#if wxUSE_TOOLTIPS
void wxRadioBox::GTKApplyToolTip(GtkTooltips * WXUNUSED(tips), const gchar *tip)
{
    // set this tooltip for all radiobuttons which don't have their own tips
    unsigned n = 0;
    for ( wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
          node;
          node = node->GetNext(), n++ )
    {
        if ( !GetItemToolTip(n) )
        {
            wxToolTip::GTKApply(GTK_WIDGET(node->GetData()->button), tip);
        }
    }
}

void wxRadioBox::DoSetItemToolTip(unsigned int n, wxToolTip *tooltip)
{
    wxCharBuffer buf;
    if ( !tooltip )
        tooltip = GetToolTip();
    if ( tooltip )
        buf = wxGTK_CONV(tooltip->GetTip());

    wxToolTip::GTKApply(GTK_WIDGET(m_buttonsInfo[n]->button), buf);
}

#endif // wxUSE_TOOLTIPS

GdkWindow *wxRadioBox::GTKGetWindow(wxArrayGdkWindows& windows) const
{
    windows.push_back(m_widget->window);

    wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
    while (node)
    {
        GtkWidget *button = GTK_WIDGET( node->GetData()->button );

        // don't put NULL pointers in the 'windows' array!
        if (button->window)
            windows.push_back(button->window);

        node = node->GetNext();
    }

    return NULL;
}

// static
wxVisualAttributes
wxRadioBox::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
{
    wxVisualAttributes attr;
    // NB: we need toplevel window so that GTK+ can find the right style
    GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    GtkWidget* widget = gtk_radio_button_new_with_label(NULL, "");
    gtk_container_add(GTK_CONTAINER(wnd), widget);
    attr = GetDefaultAttributesFromGTKWidget(widget);
    gtk_widget_destroy(wnd);
    return attr;
}

int wxRadioBox::GetItemFromPoint(const wxPoint& point) const
{
    const wxPoint pt = ScreenToClient(point);
    unsigned n = 0;
    for ( wxRadioBoxButtonsInfoList::compatibility_iterator
            node = m_buttonsInfo.GetFirst(); node; node = node->GetNext(), n++ )
    {
        if ( m_buttonsInfo[n]->rect.Contains(pt) )
            return n;
    }

    return wxNOT_FOUND;
}

#endif // wxUSE_RADIOBOX
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/gtk/radiobox.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_RADIOBOX
	14
	15	#include "wx/radiobox.h"
	16
	17	#if wxUSE_TOOLTIPS
	18	#include "wx/tooltip.h"
	19	#endif
	20
	21	#include "wx/gtk/private.h"
	22	#include <gdk/gdkkeysyms.h>
	23
	24	//-----------------------------------------------------------------------------
	25	// wxGTKRadioButtonInfo
	26	//-----------------------------------------------------------------------------
	27	// structure internally used by wxRadioBox to store its child buttons
	28
	29	class wxGTKRadioButtonInfo : public wxObject
	30	{
	31	public:
	32	wxGTKRadioButtonInfo( GtkRadioButton * abutton, const wxRect & arect )
	33	: button( abutton ), rect( arect ) {}
	34
	35	GtkRadioButton * button;
	36	wxRect rect;
	37	};
	38
	39	//-----------------------------------------------------------------------------
	40	// data
	41	//-----------------------------------------------------------------------------
	42
	43	#include "wx/listimpl.cpp"
	44	WX_DEFINE_LIST( wxRadioBoxButtonsInfoList )
	45
	46	extern bool g_blockEventsOnDrag;
	47
	48	//-----------------------------------------------------------------------------
	49	// "clicked"
	50	//-----------------------------------------------------------------------------
	51
	52	extern "C" {
	53	static void gtk_radiobutton_clicked_callback( GtkToggleButton button, wxRadioBox rb )
	54	{
	55	if (!rb->m_hasVMT) return;
	56	if (g_blockEventsOnDrag) return;
	57
	58	if (!button->active) return;
	59
	60	wxCommandEvent event( wxEVT_COMMAND_RADIOBOX_SELECTED, rb->GetId() );
	61	event.SetInt( rb->GetSelection() );
	62	event.SetString( rb->GetStringSelection() );
	63	event.SetEventObject( rb );
	64	rb->HandleWindowEvent(event);
	65	}
	66	}
	67
	68	//-----------------------------------------------------------------------------
	69	// "key_press_event"
	70	//-----------------------------------------------------------------------------
	71
	72	extern "C" {
	73	static gint gtk_radiobox_keypress_callback( GtkWidget widget, GdkEventKey gdk_event, wxRadioBox *rb )
	74	{
	75	if (!rb->m_hasVMT) return FALSE;
	76	if (g_blockEventsOnDrag) return FALSE;
	77
	78	if ( ((gdk_event->keyval == GDK_Tab) \|\|
	79	(gdk_event->keyval == GDK_ISO_Left_Tab)) &&
	80	rb->GetParent() && (rb->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
	81	{
	82	wxNavigationKeyEvent new_event;
	83	new_event.SetEventObject( rb->GetParent() );
	84	// GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
	85	new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
	86	// CTRL-TAB changes the (parent) window, i.e. switch notebook page
	87	new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
	88	new_event.SetCurrentFocus( rb );
	89	return rb->GetParent()->HandleWindowEvent(new_event);
	90	}
	91
	92	if ((gdk_event->keyval != GDK_Up) &&
	93	(gdk_event->keyval != GDK_Down) &&
	94	(gdk_event->keyval != GDK_Left) &&
	95	(gdk_event->keyval != GDK_Right))
	96	{
	97	return FALSE;
	98	}
	99
	100	wxRadioBoxButtonsInfoList::compatibility_iterator node = rb->m_buttonsInfo.GetFirst();
	101	while( node && GTK_WIDGET( node->GetData()->button ) != widget )
	102	{
	103	node = node->GetNext();
	104	}
	105	if (!node)
	106	{
	107	return FALSE;
	108	}
	109
	110	if ((gdk_event->keyval == GDK_Up) \|\|
	111	(gdk_event->keyval == GDK_Left))
	112	{
	113	if (node == rb->m_buttonsInfo.GetFirst())
	114	node = rb->m_buttonsInfo.GetLast();
	115	else
	116	node = node->GetPrevious();
	117	}
	118	else
	119	{
	120	if (node == rb->m_buttonsInfo.GetLast())
	121	node = rb->m_buttonsInfo.GetFirst();
	122	else
	123	node = node->GetNext();
	124	}
	125
	126	GtkWidget button = (GtkWidget) node->GetData()->button;
	127
	128	gtk_widget_grab_focus( button );
	129
	130	return TRUE;
	131	}
	132	}
	133
	134	extern "C" {
	135	static gint gtk_radiobutton_focus_out( GtkWidget * WXUNUSED(widget),
	136	GdkEventFocus *WXUNUSED(event),
	137	wxRadioBox *win )
	138	{
	139	// NB: This control is composed of several GtkRadioButton widgets and
	140	// when focus changes from one of them to another in the same
	141	// wxRadioBox, we get a focus-out event followed by focus-in for
	142	// another GtkRadioButton owned by the same control. We don't want
	143	// to generate two spurious wxEVT_SET_FOCUS events in this case,
	144	// so we defer sending wx events until idle time.
	145	win->GTKHandleFocusOut();
	146
	147	// never stop the signal emission, it seems to break the kbd handling
	148	// inside the radiobox
	149	return FALSE;
	150	}
	151	}
	152
	153	extern "C" {
	154	static gint gtk_radiobutton_focus_in( GtkWidget * WXUNUSED(widget),
	155	GdkEventFocus *WXUNUSED(event),
	156	wxRadioBox *win )
	157	{
	158	win->GTKHandleFocusIn();
	159
	160	// never stop the signal emission, it seems to break the kbd handling
	161	// inside the radiobox
	162	return FALSE;
	163	}
	164	}
	165
	166	extern "C" {
	167	static void gtk_radiobutton_size_allocate( GtkWidget *widget,
	168	GtkAllocation * alloc,
	169	wxRadioBox *win )
	170	{
	171	for ( wxRadioBoxButtonsInfoList::compatibility_iterator node = win->m_buttonsInfo.GetFirst();
	172	node;
	173	node = node->GetNext())
	174	{
	175	if (widget == GTK_WIDGET(node->GetData()->button))
	176	{
	177	const wxPoint origin = win->GetPosition();
	178	wxRect rect = wxRect( alloc->x - origin.x, alloc->y - origin.y,
	179	alloc->width, alloc->height );
	180	node->GetData()->rect = rect;
	181	break;
	182	}
	183	}
	184	}
	185	}
	186
	187
	188	//-----------------------------------------------------------------------------
	189	// wxRadioBox
	190	//-----------------------------------------------------------------------------
	191
	192	IMPLEMENT_DYNAMIC_CLASS(wxRadioBox,wxControl)
	193
	194	bool wxRadioBox::Create( wxWindow *parent, wxWindowID id,
	195	const wxString& title,
	196	const wxPoint &pos, const wxSize &size,
	197	const wxArrayString& choices, int majorDim,
	198	long style, const wxValidator& validator,
	199	const wxString &name )
	200	{
	201	wxCArrayString chs(choices);
	202
	203	return Create( parent, id, title, pos, size, chs.GetCount(),
	204	chs.GetStrings(), majorDim, style, validator, name );
	205	}
	206
	207	bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
	208	const wxPoint &pos, const wxSize &size,
	209	int n, const wxString choices[], int majorDim,
	210	long style, const wxValidator& validator,
	211	const wxString &name )
	212	{
	213	if (!PreCreation( parent, pos, size ) \|\|
	214	!CreateBase( parent, id, pos, size, style, validator, name ))
	215	{
	216	wxFAIL_MSG( wxT("wxRadioBox creation failed") );
	217	return false;
	218	}
	219
	220	m_widget = GTKCreateFrame(title);
	221	g_object_ref(m_widget);
	222	wxControl::SetLabel(title);
	223	if ( HasFlag(wxNO_BORDER) )
	224	{
	225	// If we don't do this here, the wxNO_BORDER style is ignored in Show()
	226	gtk_frame_set_shadow_type(GTK_FRAME(m_widget), GTK_SHADOW_NONE);
	227	}
	228
	229
	230	// majorDim may be 0 if all trailing parameters were omitted, so don't
	231	// assert here but just use the correct value for it
	232	SetMajorDim(majorDim == 0 ? n : majorDim, style);
	233
	234
	235	unsigned int num_of_cols = GetColumnCount();
	236	unsigned int num_of_rows = GetRowCount();
	237
	238	GtkRadioButton *rbtn = NULL;
	239
	240	GtkWidget *table = gtk_table_new( num_of_rows, num_of_cols, FALSE );
	241	gtk_table_set_col_spacings( GTK_TABLE(table), 1 );
	242	gtk_table_set_row_spacings( GTK_TABLE(table), 1 );
	243	gtk_widget_show( table );
	244	gtk_container_add( GTK_CONTAINER(m_widget), table );
	245
	246	wxString label;
	247	GSList *radio_button_group = NULL;
	248	for (unsigned int i = 0; i < (unsigned int)n; i++)
	249	{
	250	if ( i != 0 )
	251	radio_button_group = gtk_radio_button_get_group( GTK_RADIO_BUTTON(rbtn) );
	252
	253	label.Empty();
	254	for ( wxString::const_iterator pc = choices[i].begin();
	255	pc != choices[i].end(); ++pc )
	256	{
	257	if ( *pc != wxT('&') )
	258	label += *pc;
	259	}
	260
	261	rbtn = GTK_RADIO_BUTTON( gtk_radio_button_new_with_label( radio_button_group, wxGTK_CONV( label ) ) );
	262	gtk_widget_show( GTK_WIDGET(rbtn) );
	263
	264	g_signal_connect (rbtn, "key_press_event",
	265	G_CALLBACK (gtk_radiobox_keypress_callback), this);
	266
	267	m_buttonsInfo.Append( new wxGTKRadioButtonInfo( rbtn, wxRect() ) );
	268
	269	if (HasFlag(wxRA_SPECIFY_COLS))
	270	{
	271	int left = i%num_of_cols;
	272	int right = (i%num_of_cols) + 1;
	273	int top = i/num_of_cols;
	274	int bottom = (i/num_of_cols)+1;
	275	gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(rbtn), left, right, top, bottom,
	276	GTK_FILL, GTK_FILL, 1, 1 );
	277	}
	278	else
	279	{
	280	int left = i/num_of_rows;
	281	int right = (i/num_of_rows) + 1;
	282	int top = i%num_of_rows;
	283	int bottom = (i%num_of_rows)+1;
	284	gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(rbtn), left, right, top, bottom,
	285	GTK_FILL, GTK_FILL, 1, 1 );
	286	}
	287
	288	ConnectWidget( GTK_WIDGET(rbtn) );
	289
	290	if (!i)
	291	gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(rbtn), TRUE );
	292
	293	g_signal_connect (rbtn, "clicked",
	294	G_CALLBACK (gtk_radiobutton_clicked_callback), this);
	295	g_signal_connect (rbtn, "focus_in_event",
	296	G_CALLBACK (gtk_radiobutton_focus_in), this);
	297	g_signal_connect (rbtn, "focus_out_event",
	298	G_CALLBACK (gtk_radiobutton_focus_out), this);
	299	g_signal_connect (rbtn, "size_allocate",
	300	G_CALLBACK (gtk_radiobutton_size_allocate), this);
	301	}
	302
	303	m_parent->DoAddChild( this );
	304
	305	PostCreation(size);
	306
	307	return true;
	308	}
	309
	310	wxRadioBox::~wxRadioBox()
	311	{
	312	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
	313	while (node)
	314	{
	315	GtkWidget *button = GTK_WIDGET( node->GetData()->button );
	316	gtk_widget_destroy( button );
	317	node = node->GetNext();
	318	}
	319	WX_CLEAR_LIST( wxRadioBoxButtonsInfoList, m_buttonsInfo );
	320	}
	321
	322	bool wxRadioBox::Show( bool show )
	323	{
	324	wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );
	325
	326	if (!wxControl::Show(show))
	327	{
	328	// nothing to do
	329	return false;
	330	}
	331
	332	if ( HasFlag(wxNO_BORDER) )
	333	gtk_widget_hide( m_widget );
	334
	335	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
	336	while (node)
	337	{
	338	GtkWidget *button = GTK_WIDGET( node->GetData()->button );
	339
	340	if (show)
	341	gtk_widget_show( button );
	342	else
	343	gtk_widget_hide( button );
	344
	345	node = node->GetNext();
	346	}
	347
	348	return true;
	349	}
	350
	351	void wxRadioBox::SetSelection( int n )
	352	{
	353	wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") );
	354
	355	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( n );
	356
	357	wxCHECK_RET( node, wxT("radiobox wrong index") );
	358
	359	GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData()->button );
	360
	361	GtkDisableEvents();
	362
	363	gtk_toggle_button_set_active( button, 1 );
	364
	365	GtkEnableEvents();
	366	}
	367
	368	int wxRadioBox::GetSelection(void) const
	369	{
	370	wxCHECK_MSG( m_widget != NULL, wxNOT_FOUND, wxT("invalid radiobox") );
	371
	372	int count = 0;
	373
	374	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
	375	while (node)
	376	{
	377	GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData()->button );
	378	if (button->active) return count;
	379	count++;
	380	node = node->GetNext();
	381	}
	382
	383	wxFAIL_MSG( wxT("wxRadioBox none selected") );
	384
	385	return wxNOT_FOUND;
	386	}
	387
	388	wxString wxRadioBox::GetString(unsigned int n) const
	389	{
	390	wxCHECK_MSG( m_widget != NULL, wxEmptyString, wxT("invalid radiobox") );
	391
	392	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( n );
	393
	394	wxCHECK_MSG( node, wxEmptyString, wxT("radiobox wrong index") );
	395
	396	GtkLabel *label = GTK_LABEL(GTK_BIN(node->GetData()->button)->child);
	397
	398	wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) );
	399
	400	return str;
	401	}
	402
	403	void wxRadioBox::SetLabel( const wxString& label )
	404	{
	405	wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") );
	406
	407	GTKSetLabelForFrame(GTK_FRAME(m_widget), label);
	408	}
	409
	410	void wxRadioBox::SetString(unsigned int item, const wxString& label)
	411	{
	412	wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") );
	413
	414	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );
	415
	416	wxCHECK_RET( node, wxT("radiobox wrong index") );
	417
	418	GtkLabel *g_label = GTK_LABEL(GTK_BIN(node->GetData()->button)->child);
	419
	420	gtk_label_set_text( g_label, wxGTK_CONV( label ) );
	421	}
	422
	423	bool wxRadioBox::Enable( bool enable )
	424	{
	425	if ( !wxControl::Enable( enable ) )
	426	return false;
	427
	428	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
	429	while (node)
	430	{
	431	GtkButton *button = GTK_BUTTON( node->GetData()->button );
	432	GtkLabel *label = GTK_LABEL(GTK_BIN(button)->child);
	433
	434	gtk_widget_set_sensitive( GTK_WIDGET(button), enable );
	435	gtk_widget_set_sensitive( GTK_WIDGET(label), enable );
	436	node = node->GetNext();
	437	}
	438
	439	if (enable)
	440	GTKFixSensitivity();
	441
	442	return true;
	443	}
	444
	445	bool wxRadioBox::Enable(unsigned int item, bool enable)
	446	{
	447	wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );
	448
	449	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );
	450
	451	wxCHECK_MSG( node, false, wxT("radiobox wrong index") );
	452
	453	GtkButton *button = GTK_BUTTON( node->GetData()->button );
	454	GtkLabel *label = GTK_LABEL(GTK_BIN(button)->child);
	455
	456	gtk_widget_set_sensitive( GTK_WIDGET(button), enable );
	457	gtk_widget_set_sensitive( GTK_WIDGET(label), enable );
	458
	459	return true;
	460	}
	461
	462	bool wxRadioBox::IsItemEnabled(unsigned int item) const
	463	{
	464	wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );
	465
	466	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );
	467
	468	wxCHECK_MSG( node, false, wxT("radiobox wrong index") );
	469
	470	GtkButton *button = GTK_BUTTON( node->GetData()->button );
	471
	472	// don't use GTK_WIDGET_IS_SENSITIVE() here, we want to return true even if
	473	// the parent radiobox is disabled
	474	return GTK_WIDGET_SENSITIVE(GTK_WIDGET(button));
	475	}
	476
	477	bool wxRadioBox::Show(unsigned int item, bool show)
	478	{
	479	wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );
	480
	481	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );
	482
	483	wxCHECK_MSG( node, false, wxT("radiobox wrong index") );
	484
	485	GtkWidget *button = GTK_WIDGET( node->GetData()->button );
	486
	487	if (show)
	488	gtk_widget_show( button );
	489	else
	490	gtk_widget_hide( button );
	491
	492	return true;
	493	}
	494
	495	bool wxRadioBox::IsItemShown(unsigned int item) const
	496	{
	497	wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobox") );
	498
	499	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.Item( item );
	500
	501	wxCHECK_MSG( node, false, wxT("radiobox wrong index") );
	502
	503	GtkButton *button = GTK_BUTTON( node->GetData()->button );
	504
	505	return GTK_WIDGET_VISIBLE(GTK_WIDGET(button));
	506	}
	507
	508	unsigned int wxRadioBox::GetCount() const
	509	{
	510	return m_buttonsInfo.GetCount();
	511	}
	512
	513	void wxRadioBox::GtkDisableEvents()
	514	{
	515	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
	516	while (node)
	517	{
	518	g_signal_handlers_block_by_func(node->GetData()->button,
	519	(gpointer)gtk_radiobutton_clicked_callback, this);
	520
	521	node = node->GetNext();
	522	}
	523	}
	524
	525	void wxRadioBox::GtkEnableEvents()
	526	{
	527	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
	528	while (node)
	529	{
	530	g_signal_handlers_unblock_by_func(node->GetData()->button,
	531	(gpointer)gtk_radiobutton_clicked_callback, this);
	532
	533	node = node->GetNext();
	534	}
	535	}
	536
	537	void wxRadioBox::DoApplyWidgetStyle(GtkRcStyle *style)
	538	{
	539	GTKFrameApplyWidgetStyle(GTK_FRAME(m_widget), style);
	540
	541	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
	542	while (node)
	543	{
	544	GtkWidget *widget = GTK_WIDGET( node->GetData()->button );
	545
	546	gtk_widget_modify_style( widget, style );
	547	gtk_widget_modify_style(GTK_BIN(widget)->child, style);
	548
	549	node = node->GetNext();
	550	}
	551	}
	552
	553	bool wxRadioBox::GTKWidgetNeedsMnemonic() const
	554	{
	555	return true;
	556	}
	557
	558	void wxRadioBox::GTKWidgetDoSetMnemonic(GtkWidget* w)
	559	{
	560	GTKFrameSetMnemonicWidget(GTK_FRAME(m_widget), w);
	561	}
	562
	563	#if wxUSE_TOOLTIPS
	564	void wxRadioBox::GTKApplyToolTip(GtkTooltips * WXUNUSED(tips), const gchar *tip)
	565	{
	566	// set this tooltip for all radiobuttons which don't have their own tips
	567	unsigned n = 0;
	568	for ( wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
	569	node;
	570	node = node->GetNext(), n++ )
	571	{
	572	if ( !GetItemToolTip(n) )
	573	{
	574	wxToolTip::GTKApply(GTK_WIDGET(node->GetData()->button), tip);
	575	}
	576	}
	577	}
	578
	579	void wxRadioBox::DoSetItemToolTip(unsigned int n, wxToolTip *tooltip)
	580	{
	581	wxCharBuffer buf;
	582	if ( !tooltip )
	583	tooltip = GetToolTip();
	584	if ( tooltip )
	585	buf = wxGTK_CONV(tooltip->GetTip());
	586
	587	wxToolTip::GTKApply(GTK_WIDGET(m_buttonsInfo[n]->button), buf);
	588	}
	589
	590	#endif // wxUSE_TOOLTIPS
	591
	592	GdkWindow *wxRadioBox::GTKGetWindow(wxArrayGdkWindows& windows) const
	593	{
	594	windows.push_back(m_widget->window);
	595
	596	wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
	597	while (node)
	598	{
	599	GtkWidget *button = GTK_WIDGET( node->GetData()->button );
	600
	601	// don't put NULL pointers in the 'windows' array!
	602	if (button->window)
	603	windows.push_back(button->window);
	604
	605	node = node->GetNext();
	606	}
	607
	608	return NULL;
	609	}
	610
	611	// static
	612	wxVisualAttributes
	613	wxRadioBox::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
	614	{
	615	wxVisualAttributes attr;
	616	// NB: we need toplevel window so that GTK+ can find the right style
	617	GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	618	GtkWidget* widget = gtk_radio_button_new_with_label(NULL, "");
	619	gtk_container_add(GTK_CONTAINER(wnd), widget);
	620	attr = GetDefaultAttributesFromGTKWidget(widget);
	621	gtk_widget_destroy(wnd);
	622	return attr;
	623	}
	624
	625	int wxRadioBox::GetItemFromPoint(const wxPoint& point) const
	626	{
	627	const wxPoint pt = ScreenToClient(point);
	628	unsigned n = 0;
	629	for ( wxRadioBoxButtonsInfoList::compatibility_iterator
	630	node = m_buttonsInfo.GetFirst(); node; node = node->GetNext(), n++ )
	631	{
	632	if ( m_buttonsInfo[n]->rect.Contains(pt) )
	633	return n;
	634	}
	635
	636	return wxNOT_FOUND;
	637	}
	638
	639	#endif // wxUSE_RADIOBOX