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