src/gtk/button.cpp

   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