src/gtk/choice.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        choice.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #include "wx/defs.h"
  11
  12 #if wxUSE_CHOICE
  13
  14 #include "wx/choice.h"
  15 #include "wx/arrstr.h"
  16
  17 #include "wx/gtk/private.h"
  18
  19 //-----------------------------------------------------------------------------
  20 // idle system
  21 //-----------------------------------------------------------------------------
  22
  23 extern void wxapp_install_idle_handler();
  24 extern bool g_isIdle;
  25
  26 //-----------------------------------------------------------------------------
  27 // data
  28 //-----------------------------------------------------------------------------
  29
  30 extern bool   g_blockEventsOnDrag;
  31
  32 //-----------------------------------------------------------------------------
  33 // "activate"
  34 //-----------------------------------------------------------------------------
  35
  36 extern "C" {
  37 static void gtk_choice_clicked_callback( GtkWidget *WXUNUSED(widget), wxChoice *choice )
  38 {
  39     if (g_isIdle)
  40       wxapp_install_idle_handler();
  41
  42     if (!choice->m_hasVMT) return;
  43
  44     if (g_blockEventsOnDrag) return;
  45
  46     int selection = wxNOT_FOUND;
  47
  48 #ifdef __WXGTK20__
  49     selection = gtk_option_menu_get_history( GTK_OPTION_MENU(choice->GetHandle()) );
  50 #else
  51     GtkMenuShell *menu_shell = GTK_MENU_SHELL( gtk_option_menu_get_menu( GTK_OPTION_MENU(choice->GetHandle()) ) );
  52     int count = 0;
  53
  54     GList *child = menu_shell->children;
  55     while (child)
  56     {
  57         GtkBin *bin = GTK_BIN( child->data );
  58         if (!bin->child)
  59         {
  60             selection = count;
  61             break;
  62         }
  63         child = child->next;
  64         count++;
  65     }
  66 #endif
  67     choice->m_selection_hack = selection;
  68
  69     wxCommandEvent event(wxEVT_COMMAND_CHOICE_SELECTED, choice->GetId() );
  70     int n = choice->GetSelection();
  71
  72     event.SetInt( n );
  73     event.SetString( choice->GetStringSelection() );
  74     event.SetEventObject(choice);
  75
  76     if ( choice->HasClientObjectData() )
  77         event.SetClientObject( choice->GetClientObject(n) );
  78     else if ( choice->HasClientUntypedData() )
  79         event.SetClientData( choice->GetClientData(n) );
  80
  81     choice->GetEventHandler()->ProcessEvent(event);
  82 }
  83 }
  84
  85 //-----------------------------------------------------------------------------
  86 // wxChoice
  87 //-----------------------------------------------------------------------------
  88
  89 IMPLEMENT_DYNAMIC_CLASS(wxChoice,wxControl)
  90
  91 wxChoice::wxChoice()
  92 {
  93     m_strings = (wxSortedArrayString *)NULL;
  94 }
  95
  96 bool wxChoice::Create( wxWindow *parent, wxWindowID id,
  97                        const wxPoint &pos, const wxSize &size,
  98                        const wxArrayString& choices,
  99                        long style, const wxValidator& validator,
 100                        const wxString &name )
 101 {
 102     wxCArrayString chs(choices);
 103
 104     return Create( parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
 105                    style, validator, name );
 106 }
 107
 108 bool wxChoice::Create( wxWindow *parent, wxWindowID id,
 109                        const wxPoint &pos, const wxSize &size,
 110                        int n, const wxString choices[],
 111                        long style, const wxValidator& validator, const wxString &name )
 112 {
 113     m_needParent = true;
 114 #if (GTK_MINOR_VERSION > 0)
 115     m_acceptsFocus = true;
 116 #endif
 117
 118     if (!PreCreation( parent, pos, size ) ||
 119         !CreateBase( parent, id, pos, size, style, validator, name ))
 120     {
 121         wxFAIL_MSG( wxT("wxChoice creation failed") );
 122         return false;
 123     }
 124
 125     m_widget = gtk_option_menu_new();
 126
 127     if ( style & wxCB_SORT )
 128     {
 129         // if our m_strings != NULL, DoAppend() will check for it and insert
 130         // items in the correct order
 131         m_strings = new wxSortedArrayString;
 132     }
 133
 134     // begin with no selection
 135     m_selection_hack = wxNOT_FOUND;
 136
 137     GtkWidget *menu = gtk_menu_new();
 138
 139     for (int i = 0; i < n; i++)
 140     {
 141         GtkAddHelper(menu, i, choices[i]);
 142     }
 143
 144     gtk_option_menu_set_menu( GTK_OPTION_MENU(m_widget), menu );
 145
 146     m_parent->DoAddChild( this );
 147
 148     PostCreation(size);
 149     SetBestSize(size); // need this too because this is a wxControlWithItems
 150
 151     return true;
 152 }
 153
 154 wxChoice::~wxChoice()
 155 {
 156     Clear();
 157
 158     delete m_strings;
 159 }
 160
 161 int wxChoice::DoAppend( const wxString &item )
 162 {
 163     wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid choice control") );
 164
 165     GtkWidget *menu = gtk_option_menu_get_menu( GTK_OPTION_MENU(m_widget) );
 166
 167     return GtkAddHelper(menu, GetCount(), item);
 168 }
 169
 170 int wxChoice::DoInsert( const wxString &item, int pos )
 171 {
 172     wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid choice control") );
 173     wxCHECK_MSG( (pos>=0) && (pos<=GetCount()), -1, wxT("invalid index"));
 174
 175     if (pos == GetCount())
 176         return DoAppend(item);
 177
 178     GtkWidget *menu = gtk_option_menu_get_menu( GTK_OPTION_MENU(m_widget) );
 179
 180     // if the item to insert is at or before the selection, and the selection is valid
 181     if ((pos <= m_selection_hack) && (m_selection_hack != wxNOT_FOUND))
 182     {
 183         // move the selection forward one
 184         m_selection_hack++;
 185     }
 186
 187     return GtkAddHelper(menu, pos, item);
 188 }
 189
 190 void wxChoice::DoSetItemClientData( int n, void* clientData )
 191 {
 192     wxCHECK_RET( m_widget != NULL, wxT("invalid choice control") );
 193
 194     wxList::compatibility_iterator node = m_clientList.Item( n );
 195     wxCHECK_RET( node, wxT("invalid index in wxChoice::DoSetItemClientData") );
 196
 197     node->SetData( (wxObject*) clientData );
 198 }
 199
 200 void* wxChoice::DoGetItemClientData( int n ) const
 201 {
 202     wxCHECK_MSG( m_widget != NULL, NULL, wxT("invalid choice control") );
 203
 204     wxList::compatibility_iterator node = m_clientList.Item( n );
 205     wxCHECK_MSG( node, NULL, wxT("invalid index in wxChoice::DoGetItemClientData") );
 206
 207     return node->GetData();
 208 }
 209
 210 void wxChoice::DoSetItemClientObject( int n, wxClientData* clientData )
 211 {
 212     wxCHECK_RET( m_widget != NULL, wxT("invalid choice control") );
 213
 214     wxList::compatibility_iterator node = m_clientList.Item( n );
 215     wxCHECK_RET( node, wxT("invalid index in wxChoice::DoSetItemClientObject") );
 216
 217     // wxItemContainer already deletes data for us
 218
 219     node->SetData( (wxObject*) clientData );
 220 }
 221
 222 wxClientData* wxChoice::DoGetItemClientObject( int n ) const
 223 {
 224     wxCHECK_MSG( m_widget != NULL, (wxClientData*) NULL, wxT("invalid choice control") );
 225
 226     wxList::compatibility_iterator node = m_clientList.Item( n );
 227     wxCHECK_MSG( node, (wxClientData *)NULL,
 228                  wxT("invalid index in wxChoice::DoGetItemClientObject") );
 229
 230     return (wxClientData*) node->GetData();
 231 }
 232
 233 void wxChoice::Clear()
 234 {
 235     wxCHECK_RET( m_widget != NULL, wxT("invalid choice") );
 236
 237     gtk_option_menu_remove_menu( GTK_OPTION_MENU(m_widget) );
 238     GtkWidget *menu = gtk_menu_new();
 239     gtk_option_menu_set_menu( GTK_OPTION_MENU(m_widget), menu );
 240
 241     if ( HasClientObjectData() )
 242     {
 243         // destroy the data (due to Robert's idea of using wxList<wxObject>
 244         // and not wxList<wxClientData> we can't just say
 245         // m_clientList.DeleteContents(true) - this would crash!
 246         wxList::compatibility_iterator node = m_clientList.GetFirst();
 247         while ( node )
 248         {
 249             delete (wxClientData *)node->GetData();
 250             node = node->GetNext();
 251         }
 252     }
 253     m_clientList.Clear();
 254
 255     if ( m_strings )
 256         m_strings->Clear();
 257
 258     // begin with no selection
 259     m_selection_hack = wxNOT_FOUND;
 260 }
 261
 262 void wxChoice::Delete( int n )
 263 {
 264     wxCHECK_RET( m_widget != NULL, wxT("invalid choice") );
 265
 266     // VZ: apparently GTK+ doesn't have a built-in function to do it (not even
 267     //     in 2.0), hence this dumb implementation -- still better than nothing
 268     int i,
 269         count = GetCount();
 270
 271     wxCHECK_RET( n >= 0 && n < count, _T("invalid index in wxChoice::Delete") );
 272
 273     // if the item to delete is before the selection, and the selection is valid
 274     if ((n < m_selection_hack) && (m_selection_hack != wxNOT_FOUND))
 275     {
 276         // move the selection back one
 277         m_selection_hack--;
 278     }
 279     else if (n == m_selection_hack)
 280     {
 281         // invalidate the selection
 282         m_selection_hack = wxNOT_FOUND;
 283     }
 284
 285     const bool hasClientData = m_clientDataItemsType != wxClientData_None;
 286     const bool hasObjectData = m_clientDataItemsType == wxClientData_Object;
 287
 288     wxList::compatibility_iterator node = m_clientList.GetFirst();
 289
 290     wxArrayString items;
 291     wxArrayPtrVoid itemsData;
 292     items.Alloc(count);
 293     for ( i = 0; i < count; i++ )
 294     {
 295         if ( i != n )
 296         {
 297             items.Add(GetString(i));
 298             if ( hasClientData )
 299             {
 300                 // also save the client data
 301                 itemsData.Add(node->GetData());
 302             }
 303         }
 304         else // need to delete the client object too
 305         {
 306             if ( hasObjectData )
 307             {
 308                 delete (wxClientData *)node->GetData();
 309             }
 310         }
 311
 312         if ( hasClientData )
 313         {
 314             node = node->GetNext();
 315         }
 316     }
 317
 318     if ( hasObjectData )
 319     {
 320         // prevent Clear() from destroying all client data
 321         m_clientDataItemsType = wxClientData_None;
 322     }
 323
 324     Clear();
 325
 326     for ( i = 0; i < count - 1; i++ )
 327     {
 328         Append(items[i]);
 329
 330         if ( hasObjectData )
 331             SetClientObject(i, (wxClientData *)itemsData[i]);
 332         else if ( hasClientData )
 333             SetClientData(i, itemsData[i]);
 334     }
 335 }
 336
 337 int wxChoice::FindString( const wxString &string ) const
 338 {
 339     wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid choice") );
 340
 341     // If you read this code once and you think you understand
 342     // it, then you are very wrong. Robert Roebling.
 343
 344     GtkMenuShell *menu_shell = GTK_MENU_SHELL( gtk_option_menu_get_menu( GTK_OPTION_MENU(m_widget) ) );
 345     int count = 0;
 346     GList *child = menu_shell->children;
 347     while (child)
 348     {
 349         GtkBin *bin = GTK_BIN( child->data );
 350         GtkLabel *label = (GtkLabel *) NULL;
 351         if (bin->child)
 352             label = GTK_LABEL(bin->child);
 353         if (!label)
 354             label = GTK_LABEL( BUTTON_CHILD(m_widget) );
 355
 356         wxASSERT_MSG( label != NULL , wxT("wxChoice: invalid label") );
 357
 358 #ifdef __WXGTK20__
 359          wxString tmp( wxGTK_CONV_BACK( gtk_label_get_text( label) ) );
 360 #else
 361          wxString tmp( label->label );
 362 #endif
 363         if (string == tmp)
 364             return count;
 365
 366         child = child->next;
 367         count++;
 368     }
 369
 370     return wxNOT_FOUND;
 371 }
 372
 373 int wxChoice::GetSelection() const
 374 {
 375     wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid choice") );
 376
 377     return m_selection_hack;
 378
 379 }
 380
 381 void wxChoice::SetString( int n, const wxString& str )
 382 {
 383     wxCHECK_RET( m_widget != NULL, wxT("invalid choice") );
 384
 385     GtkMenuShell *menu_shell = GTK_MENU_SHELL( gtk_option_menu_get_menu( GTK_OPTION_MENU(m_widget) ) );
 386     int count = 0;
 387     GList *child = menu_shell->children;
 388     while (child)
 389     {
 390         GtkBin *bin = GTK_BIN( child->data );
 391         if (count == n)
 392         {
 393             GtkLabel *label = (GtkLabel *) NULL;
 394             if (bin->child)
 395                 label = GTK_LABEL(bin->child);
 396             if (!label)
 397                 label = GTK_LABEL( BUTTON_CHILD(m_widget) );
 398
 399             wxASSERT_MSG( label != NULL , wxT("wxChoice: invalid label") );
 400
 401             gtk_label_set_text( label, wxGTK_CONV( str ) );
 402
 403             return;
 404         }
 405         child = child->next;
 406         count++;
 407     }
 408 }
 409
 410 wxString wxChoice::GetString( int n ) const
 411 {
 412     wxCHECK_MSG( m_widget != NULL, wxEmptyString, wxT("invalid choice") );
 413
 414     GtkMenuShell *menu_shell = GTK_MENU_SHELL( gtk_option_menu_get_menu( GTK_OPTION_MENU(m_widget) ) );
 415     int count = 0;
 416     GList *child = menu_shell->children;
 417     while (child)
 418     {
 419         GtkBin *bin = GTK_BIN( child->data );
 420         if (count == n)
 421         {
 422             GtkLabel *label = (GtkLabel *) NULL;
 423             if (bin->child)
 424                 label = GTK_LABEL(bin->child);
 425             if (!label)
 426                 label = GTK_LABEL( BUTTON_CHILD(m_widget) );
 427
 428             wxASSERT_MSG( label != NULL , wxT("wxChoice: invalid label") );
 429
 430 #ifdef __WXGTK20__
 431             return wxString( wxGTK_CONV_BACK( gtk_label_get_text( label) ) );
 432 #else
 433             return wxString( label->label );
 434 #endif
 435         }
 436         child = child->next;
 437         count++;
 438     }
 439
 440     wxFAIL_MSG( wxT("wxChoice: invalid index in GetString()") );
 441
 442     return wxEmptyString;
 443 }
 444
 445 int wxChoice::GetCount() const
 446 {
 447     wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid choice") );
 448
 449     GtkMenuShell *menu_shell = GTK_MENU_SHELL( gtk_option_menu_get_menu( GTK_OPTION_MENU(m_widget) ) );
 450     int count = 0;
 451     GList *child = menu_shell->children;
 452     while (child)
 453     {
 454         count++;
 455         child = child->next;
 456     }
 457     return count;
 458 }
 459
 460 void wxChoice::SetSelection( int n )
 461 {
 462     wxCHECK_RET( m_widget != NULL, wxT("invalid choice") );
 463
 464     int tmp = n;
 465     gtk_option_menu_set_history( GTK_OPTION_MENU(m_widget), (gint)tmp );
 466
 467     // set the local selection variable manually
 468     if ((n >= 0) && (n < GetCount()))
 469     {
 470         // a valid selection has been made
 471         m_selection_hack = n;
 472     }
 473     else if ((n == wxNOT_FOUND) || (GetCount() == 0))
 474     {
 475         // invalidates the selection if there are no items
 476         // or if it is specifically set to wxNOT_FOUND
 477         m_selection_hack = wxNOT_FOUND;
 478     }
 479     else
 480     {
 481         // this selects the first item by default if the selection is out of bounds
 482         m_selection_hack = 0;
 483     }
 484 }
 485
 486 void wxChoice::DoApplyWidgetStyle(GtkRcStyle *style)
 487 {
 488     GtkMenuShell *menu_shell = GTK_MENU_SHELL( gtk_option_menu_get_menu( GTK_OPTION_MENU(m_widget) ) );
 489
 490     gtk_widget_modify_style( m_widget, style );
 491     gtk_widget_modify_style( GTK_WIDGET( menu_shell ), style );
 492
 493     GList *child = menu_shell->children;
 494     while (child)
 495     {
 496         gtk_widget_modify_style( GTK_WIDGET( child->data ), style );
 497
 498         GtkBin *bin = GTK_BIN( child->data );
 499         GtkWidget *label = (GtkWidget *) NULL;
 500         if (bin->child)
 501             label = bin->child;
 502         if (!label)
 503             label = BUTTON_CHILD(m_widget);
 504
 505         gtk_widget_modify_style( label, style );
 506
 507         child = child->next;
 508     }
 509 }
 510
 511 int wxChoice::GtkAddHelper(GtkWidget *menu, int pos, const wxString& item)
 512 {
 513     wxCHECK_MSG((pos>=0) && (pos<=(int)m_clientList.GetCount()), -1, wxT("invalid index"));
 514
 515     GtkWidget *menu_item = gtk_menu_item_new_with_label( wxGTK_CONV( item ) );
 516
 517     size_t index;
 518     if ( m_strings )
 519     {
 520         // sorted control, need to insert at the correct index
 521         index = m_strings->Add(item);
 522
 523         gtk_menu_insert( GTK_MENU(menu), menu_item, index );
 524
 525         if ( index )
 526         {
 527             m_clientList.Insert( m_clientList.Item(index - 1),
 528                                  (wxObject*) NULL );
 529         }
 530         else
 531         {
 532             m_clientList.Insert( (wxObject*) NULL );
 533         }
 534     }
 535     else
 536     {
 537         // don't call wxChoice::GetCount() from here because it doesn't work
 538         // if we're called from ctor (and GtkMenuShell is still NULL)
 539
 540         // normal control, just append
 541         if (pos == (int)m_clientList.GetCount())
 542         {
 543             gtk_menu_append( GTK_MENU(menu), menu_item );
 544             m_clientList.Append( (wxObject*) NULL );
 545             index = m_clientList.GetCount() - 1;
 546         }
 547         else
 548         {
 549             gtk_menu_insert( GTK_MENU(menu), menu_item, pos );
 550             m_clientList.Insert( pos, (wxObject*) NULL );
 551             index = pos;
 552         }
 553     }
 554
 555     if (GTK_WIDGET_REALIZED(m_widget))
 556     {
 557         gtk_widget_realize( menu_item );
 558         gtk_widget_realize( GTK_BIN(menu_item)->child );
 559
 560         ApplyWidgetStyle();
 561     }
 562
 563     // The best size of a wxChoice should probably
 564     // be changed everytime the control has been
 565     // changed, but at least after adding an item
 566     // it has to change. Adapted from Matt Ownby.
 567     InvalidateBestSize();
 568
 569     gtk_signal_connect_after( GTK_OBJECT( menu_item ), "activate",
 570       GTK_SIGNAL_FUNC(gtk_choice_clicked_callback), (gpointer*)this );
 571
 572     gtk_widget_show( menu_item );
 573
 574     // return the index of the item in the control
 575     return index;
 576 }
 577
 578 wxSize wxChoice::DoGetBestSize() const
 579 {
 580     wxSize ret( wxControl::DoGetBestSize() );
 581
 582     // we know better our horizontal extent: it depends on the longest string
 583     // we have
 584     ret.x = 0;
 585     if ( m_widget )
 586     {
 587         int width;
 588         size_t count = GetCount();
 589         for ( size_t n = 0; n < count; n++ )
 590         {
 591             GetTextExtent( GetString(n), &width, NULL, NULL, NULL );
 592             if ( width > ret.x )
 593                 ret.x = width;
 594         }
 595
 596         // add extra for the choice "=" button
 597
 598         // VZ: I don't know how to get the right value, it seems to be in
 599         //     GtkOptionMenuProps struct from gtkoptionmenu.c but we can't get
 600         //     to it - maybe we can use gtk_option_menu_size_request() for this
 601         //     somehow?
 602         //
 603         //     This default value works only for the default GTK+ theme (i.e.
 604         //     no theme at all) (FIXME)
 605         static const int widthChoiceIndicator = 35;
 606         ret.x += widthChoiceIndicator;
 607     }
 608
 609     // but not less than the minimal width
 610     if ( ret.x < 80 )
 611         ret.x = 80;
 612
 613     // If this request_size is called with no entries then
 614     // the returned height is wrong. Give it a reasonable
 615     // default value.
 616     if (ret.y <= 18)
 617         ret.y = 8 + GetCharHeight();
 618
 619     CacheBestSize(ret);
 620     return ret;
 621 }
 622
 623 bool wxChoice::IsOwnGtkWindow( GdkWindow *window )
 624 {
 625 #ifdef __WXGTK20__
 626     return GTK_BUTTON(m_widget)->event_window;
 627 #else
 628     return (window == m_widget->window);
 629 #endif
 630 }
 631
 632 // static
 633 wxVisualAttributes
 634 wxChoice::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 635 {
 636     return GetDefaultAttributesFromGTKWidget(gtk_option_menu_new);
 637 }
 638
 639
 640 #endif // wxUSE_CHOICE