src/univ/button.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        univ/button.cpp
   3 // Purpose:     wxButton
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     14.08.00
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_BUTTON
  27
  28 #ifndef WX_PRECOMP
  29     #include "wx/dcclient.h"
  30     #include "wx/dcscreen.h"
  31     #include "wx/button.h"
  32     #include "wx/validate.h"
  33     #include "wx/settings.h"
  34 #endif
  35
  36 #include "wx/univ/renderer.h"
  37 #include "wx/univ/inphand.h"
  38 #include "wx/univ/theme.h"
  39 #include "wx/univ/colschem.h"
  40 #include "wx/stockitem.h"
  41
  42 // ----------------------------------------------------------------------------
  43 // wxStdButtonInputHandler: translates SPACE and ENTER keys and the left mouse
  44 // click into button press/release actions
  45 // ----------------------------------------------------------------------------
  46
  47 class WXDLLEXPORT wxStdButtonInputHandler : public wxStdInputHandler
  48 {
  49 public:
  50     wxStdButtonInputHandler(wxInputHandler *inphand);
  51
  52     virtual bool HandleKey(wxInputConsumer *consumer,
  53                            const wxKeyEvent& event,
  54                            bool pressed);
  55     virtual bool HandleMouse(wxInputConsumer *consumer,
  56                              const wxMouseEvent& event);
  57     virtual bool HandleMouseMove(wxInputConsumer *consumer,
  58                                  const wxMouseEvent& event);
  59     virtual bool HandleFocus(wxInputConsumer *consumer,
  60                              const wxFocusEvent& event);
  61     virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
  62
  63 private:
  64     // the window (button) which has capture or NULL and the flag telling if
  65     // the mouse is inside the button which captured it or not
  66     wxWindow *m_winCapture;
  67     bool      m_winHasMouse;
  68 };
  69
  70 // ----------------------------------------------------------------------------
  71 // constants
  72 // ----------------------------------------------------------------------------
  73
  74 // default margins around the image
  75 static const wxCoord DEFAULT_BTN_MARGIN_X = 0;  // We should give space for the border, at least.
  76 static const wxCoord DEFAULT_BTN_MARGIN_Y = 0;
  77
  78 // ============================================================================
  79 // implementation
  80 // ============================================================================
  81
  82 IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
  83
  84 // ----------------------------------------------------------------------------
  85 // creation
  86 // ----------------------------------------------------------------------------
  87
  88 void wxButton::Init()
  89 {
  90     m_isPressed =
  91     m_isDefault = false;
  92 }
  93
  94 bool wxButton::Create(wxWindow *parent,
  95                       wxWindowID id,
  96                       const wxBitmap& bitmap,
  97                       const wxString &lbl,
  98                       const wxPoint &pos,
  99                       const wxSize &size,
 100                       long style,
 101                       const wxValidator& validator,
 102                       const wxString &name)
 103 {
 104     wxString label(lbl);
 105     if (label.empty() && wxIsStockID(id))
 106         label = wxGetStockLabel(id);
 107
 108     long ctrl_style = style & ~wxBU_ALIGN_MASK;
 109     ctrl_style = ctrl_style & ~wxALIGN_MASK;
 110
 111     if((style & wxBU_RIGHT) == wxBU_RIGHT)
 112         ctrl_style |= wxALIGN_RIGHT;
 113     else if((style & wxBU_LEFT) == wxBU_LEFT)
 114         ctrl_style |= wxALIGN_LEFT;
 115     else
 116         ctrl_style |= wxALIGN_CENTRE_HORIZONTAL;
 117
 118     if((style & wxBU_TOP) == wxBU_TOP)
 119         ctrl_style |= wxALIGN_TOP;
 120     else if((style & wxBU_BOTTOM) == wxBU_BOTTOM)
 121         ctrl_style |= wxALIGN_BOTTOM;
 122     else
 123         ctrl_style |= wxALIGN_CENTRE_VERTICAL;
 124
 125     if ( !wxControl::Create(parent, id, pos, size, ctrl_style, validator, name) )
 126         return false;
 127
 128     SetLabel(label);
 129
 130     if (bitmap.Ok())
 131         SetBitmap(bitmap); // SetInitialSize called by SetBitmap()
 132     else
 133         SetInitialSize(size);
 134
 135     CreateInputHandler(wxINP_HANDLER_BUTTON);
 136
 137     return true;
 138 }
 139
 140 wxButton::~wxButton()
 141 {
 142 }
 143
 144 // ----------------------------------------------------------------------------
 145 // size management
 146 // ----------------------------------------------------------------------------
 147
 148 /* static */
 149 wxSize wxButtonBase::GetDefaultSize()
 150 {
 151     static wxSize s_sizeBtn;
 152
 153     if ( s_sizeBtn.x == 0 )
 154     {
 155         wxScreenDC dc;
 156
 157         // this corresponds more or less to wxMSW standard in Win32 theme (see
 158         // wxWin32Renderer::AdjustSize())
 159 //        s_sizeBtn.x = 8*dc.GetCharWidth();
 160 //        s_sizeBtn.y = (11*dc.GetCharHeight())/10 + 2;
 161         // Otto Wyss, Patch 664399
 162         s_sizeBtn.x = dc.GetCharWidth()*10 + 2;
 163         s_sizeBtn.y = dc.GetCharHeight()*11/10 + 2;
 164     }
 165
 166     return s_sizeBtn;
 167 }
 168
 169 wxSize wxButton::DoGetBestClientSize() const
 170 {
 171     wxClientDC dc(wxConstCast(this, wxButton));
 172     wxCoord width, height;
 173     dc.GetMultiLineTextExtent(GetLabel(), &width, &height);
 174
 175     if ( m_bitmap.Ok() )
 176     {
 177         // allocate extra space for the bitmap
 178         wxCoord heightBmp = m_bitmap.GetHeight() + 2*m_marginBmpY;
 179         if ( height < heightBmp )
 180             height = heightBmp;
 181
 182         width += m_bitmap.GetWidth() + 2*m_marginBmpX;
 183     }
 184
 185     // The default size should not be adjusted, so the code is moved into the
 186     // renderer. This is conceptual wrong but currently the only solution.
 187     // (Otto Wyss, Patch 664399)
 188
 189 /*
 190     // for compatibility with other ports, the buttons default size is never
 191     // less than the standard one, but not when display not PDAs.
 192     if (wxSystemSettings::GetScreenType() > wxSYS_SCREEN_PDA)
 193     {
 194         if ( !(GetWindowStyle() & wxBU_EXACTFIT) )
 195         {
 196             wxSize szDef = GetDefaultSize();
 197             if ( width < szDef.x )
 198                 width = szDef.x;
 199         }
 200     }
 201 */
 202     return wxSize(width, height);
 203 }
 204
 205 // ----------------------------------------------------------------------------
 206 // drawing
 207 // ----------------------------------------------------------------------------
 208
 209 void wxButton::DoDraw(wxControlRenderer *renderer)
 210 {
 211     if ( !(GetWindowStyle() & wxBORDER_NONE) )
 212     {
 213         renderer->DrawButtonBorder();
 214     }
 215
 216     renderer->DrawLabel(m_bitmap, m_marginBmpX, m_marginBmpY);
 217 }
 218
 219 bool wxButton::DoDrawBackground(wxDC& dc)
 220 {
 221     wxRect rect;
 222     wxSize size = GetSize();
 223     rect.width = size.x;
 224     rect.height = size.y;
 225
 226     if ( GetBackgroundBitmap().Ok() )
 227     {
 228         // get the bitmap and the flags
 229         int alignment;
 230         wxStretch stretch;
 231         wxBitmap bmp = GetBackgroundBitmap(&alignment, &stretch);
 232         wxControlRenderer::DrawBitmap(dc, bmp, rect, alignment, stretch);
 233     }
 234     else
 235     {
 236         m_renderer->DrawButtonSurface(dc, wxTHEME_BG_COLOUR(this),
 237                                       rect, GetStateFlags());
 238     }
 239
 240     return true;
 241 }
 242
 243 // ----------------------------------------------------------------------------
 244 // input processing
 245 // ----------------------------------------------------------------------------
 246
 247 void wxButton::Press()
 248 {
 249     if ( !m_isPressed )
 250     {
 251         m_isPressed = true;
 252
 253         Refresh();
 254     }
 255 }
 256
 257 void wxButton::Release()
 258 {
 259     if ( m_isPressed )
 260     {
 261         m_isPressed = false;
 262
 263         Refresh();
 264     }
 265 }
 266
 267 void wxButton::Toggle()
 268 {
 269     if ( m_isPressed )
 270         Release();
 271     else
 272         Press();
 273
 274     if ( !m_isPressed )
 275     {
 276         // releasing button after it had been pressed generates a click event
 277         Click();
 278     }
 279 }
 280
 281 void wxButton::Click()
 282 {
 283     wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
 284     InitCommandEvent(event);
 285     Command(event);
 286 }
 287
 288 bool wxButton::PerformAction(const wxControlAction& action,
 289                              long numArg,
 290                              const wxString& strArg)
 291 {
 292     if ( action == wxACTION_BUTTON_TOGGLE )
 293         Toggle();
 294     else if ( action == wxACTION_BUTTON_CLICK )
 295         Click();
 296     else if ( action == wxACTION_BUTTON_PRESS )
 297         Press();
 298     else if ( action == wxACTION_BUTTON_RELEASE )
 299         Release();
 300     else
 301         return wxControl::PerformAction(action, numArg, strArg);
 302
 303     return true;
 304 }
 305
 306 /* static */
 307 wxInputHandler *wxButton::GetStdInputHandler(wxInputHandler *handlerDef)
 308 {
 309     static wxStdButtonInputHandler s_handlerBtn(handlerDef);
 310
 311     return &s_handlerBtn;
 312 }
 313
 314 // ----------------------------------------------------------------------------
 315 // misc
 316 // ----------------------------------------------------------------------------
 317
 318 void wxButton::DoSetBitmap(const wxBitmap& bitmap, State which)
 319 {
 320     // we support only one bitmap right now, although this wouldn't be
 321     // difficult to change
 322     if ( which == State_Normal )
 323         m_bitmap = bitmap;
 324
 325     SetBitmapMargins(DEFAULT_BTN_MARGIN_X, DEFAULT_BTN_MARGIN_Y);
 326 }
 327
 328 void wxButton::DoSetBitmapMargins(wxCoord x, wxCoord y)
 329 {
 330     m_marginBmpX = x + 2;
 331     m_marginBmpY = y + 2;
 332
 333     SetInitialSize(wxDefaultSize);
 334 }
 335
 336 wxWindow *wxButton::SetDefault()
 337 {
 338     m_isDefault = true;
 339
 340     return wxButtonBase::SetDefault();
 341 }
 342
 343 // ============================================================================
 344 // wxStdButtonInputHandler
 345 // ============================================================================
 346
 347 wxStdButtonInputHandler::wxStdButtonInputHandler(wxInputHandler *handler)
 348                        : wxStdInputHandler(handler)
 349 {
 350     m_winCapture = NULL;
 351     m_winHasMouse = false;
 352 }
 353
 354 bool wxStdButtonInputHandler::HandleKey(wxInputConsumer *consumer,
 355                                         const wxKeyEvent& event,
 356                                         bool pressed)
 357 {
 358     int keycode = event.GetKeyCode();
 359     if ( keycode == WXK_SPACE || keycode == WXK_RETURN )
 360     {
 361         consumer->PerformAction(wxACTION_BUTTON_TOGGLE);
 362
 363         return true;
 364     }
 365
 366     return wxStdInputHandler::HandleKey(consumer, event, pressed);
 367 }
 368
 369 bool wxStdButtonInputHandler::HandleMouse(wxInputConsumer *consumer,
 370                                           const wxMouseEvent& event)
 371 {
 372     // the button has 2 states: pressed and normal with the following
 373     // transitions between them:
 374     //
 375     //      normal -> left down -> capture mouse and go to pressed state
 376     //      pressed -> left up inside -> generate click -> go to normal
 377     //                         outside ------------------>
 378     //
 379     // the other mouse buttons are ignored
 380     if ( event.Button(1) )
 381     {
 382         if ( event.LeftDown() || event.LeftDClick() )
 383         {
 384             m_winCapture = consumer->GetInputWindow();
 385             m_winCapture->CaptureMouse();
 386             m_winHasMouse = true;
 387
 388             consumer->PerformAction(wxACTION_BUTTON_PRESS);
 389
 390             return true;
 391         }
 392         else if ( event.LeftUp() )
 393         {
 394             if ( m_winCapture )
 395             {
 396                 m_winCapture->ReleaseMouse();
 397                 m_winCapture = NULL;
 398             }
 399
 400             if ( m_winHasMouse )
 401             {
 402                 // this will generate a click event
 403                 consumer->PerformAction(wxACTION_BUTTON_TOGGLE);
 404
 405                 return true;
 406             }
 407             //else: the mouse was released outside the window, this doesn't
 408             //      count as a click
 409         }
 410         //else: don't do anything special about the double click
 411     }
 412
 413     return wxStdInputHandler::HandleMouse(consumer, event);
 414 }
 415
 416 bool wxStdButtonInputHandler::HandleMouseMove(wxInputConsumer *consumer,
 417                                               const wxMouseEvent& event)
 418 {
 419     // we only have to do something when the mouse leaves/enters the pressed
 420     // button and don't care about the other ones
 421     if ( event.GetEventObject() == m_winCapture )
 422     {
 423         // leaving the button should remove its pressed state
 424         if ( event.Leaving() )
 425         {
 426             // remember that the mouse is now outside
 427             m_winHasMouse = false;
 428
 429             // we do have a pressed button, so release it
 430             consumer->GetInputWindow()->SetCurrent(false);
 431             consumer->PerformAction(wxACTION_BUTTON_RELEASE);
 432
 433             return true;
 434         }
 435         // and entering it back should make it pressed again if it had been
 436         // pressed
 437         else if ( event.Entering() )
 438         {
 439             // the mouse is (back) inside the button
 440             m_winHasMouse = true;
 441
 442             // we did have a pressed button which we released when leaving the
 443             // window, press it again
 444             consumer->GetInputWindow()->SetCurrent(true);
 445             consumer->PerformAction(wxACTION_BUTTON_PRESS);
 446
 447             return true;
 448         }
 449     }
 450
 451     return wxStdInputHandler::HandleMouseMove(consumer, event);
 452 }
 453
 454 bool wxStdButtonInputHandler::HandleFocus(wxInputConsumer * WXUNUSED(consumer),
 455                                           const wxFocusEvent& WXUNUSED(event))
 456 {
 457     // buttons change appearance when they get/lose focus, so return true to
 458     // refresh
 459     return true;
 460 }
 461
 462 bool wxStdButtonInputHandler::HandleActivation(wxInputConsumer *consumer,
 463                                                bool WXUNUSED(activated))
 464 {
 465     // the default button changes appearance when the app is [de]activated, so
 466     // return true to refresh
 467     return wxStaticCast(consumer->GetInputWindow(), wxButton)->IsDefault();
 468 }
 469
 470 #endif // wxUSE_BUTTON
 471