src/motif/spinbutt.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        spinbutt.cpp
   3 // Purpose:     wxSpinButton
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13     #pragma implementation "spinbutt.h"
  14 #endif
  15
  16 #include "wx/spinbutt.h"
  17 #include "wx/spinctrl.h"
  18 #include "wx/timer.h"
  19
  20 #ifdef __VMS__
  21 #pragma message disable nosimpint
  22 #endif
  23 #include <Xm/ArrowBG.h>
  24 #include <Xm/ArrowB.h>
  25 #ifdef __VMS__
  26 #pragma message enable nosimpint
  27 #endif
  28
  29 #include "wx/motif/private.h"
  30
  31 // helper class
  32 enum ArrowDirection
  33 {
  34     wxARROW_UP,
  35     wxARROW_DOWN,
  36     wxARROW_LEFT,
  37     wxARROW_RIGHT
  38 };
  39
  40 class wxArrowButtonTimer;
  41 class wxArrowButton;
  42
  43 // ----------------------------------------------------------------------------
  44 // wxArrowButtonTimer
  45 // ----------------------------------------------------------------------------
  46
  47 static const unsigned int TICK_BEFORE_START = 10;
  48 static const unsigned int TICK_BEFORE_EXPONENTIAL = 40;
  49 static const unsigned int MAX_INCREMENT = 150;
  50 static const unsigned int TICK_INTERVAL = 113;
  51
  52 class wxArrowButtonTimer : public wxTimer
  53 {
  54 public:
  55     wxArrowButtonTimer( wxArrowButton* btn, int sign )
  56         : m_sign( sign ),
  57           m_button( btn )
  58         { Reset(); };
  59
  60     void Notify();
  61     void Reset() { m_ticks = 0; m_increment = 1; }
  62 private:
  63     unsigned int m_ticks;
  64     unsigned int m_increment;
  65     int m_sign;
  66     wxArrowButton* m_button;
  67 };
  68
  69 // ----------------------------------------------------------------------------
  70 // wxArrowButton
  71 // ----------------------------------------------------------------------------
  72
  73 class wxArrowButton : public wxControl
  74 {
  75     friend class wxArrowButtonTimer;
  76 public:
  77     wxArrowButton( int increment )
  78         : m_increment( increment ),
  79           m_timer( 0 ) {}
  80
  81     wxArrowButton( wxSpinButton* parent, wxWindowID id, ArrowDirection d,
  82                    const wxPoint& pos = wxDefaultPosition,
  83                    const wxSize& size = wxDefaultSize, int increment = 1 )
  84         : wxControl(),
  85           m_increment( increment ),
  86           m_timer( 0 )
  87     {
  88         Create( parent, id, d, pos, size );
  89     }
  90
  91     ~wxArrowButton()
  92         { delete m_timer; }
  93
  94     bool Create( wxSpinButton* parent, wxWindowID id, ArrowDirection d,
  95                  const wxPoint& pos = wxDefaultPosition,
  96                  const wxSize& size = wxDefaultSize );
  97 private:
  98     // creates a new timer object, or stops the currently running one
  99     wxTimer* GetFreshTimer();
 100     wxSpinButton* GetSpinButton() { return (wxSpinButton*)GetParent(); }
 101     static void SpinButtonCallback( Widget w, XtPointer clientData,
 102                                     XtPointer WXUNUSED(ptr) );
 103     static void StartTimerCallback( Widget w, XtPointer clientData,
 104                                     XtPointer WXUNUSED(ptr) );
 105
 106     static void  StopTimerCallback( Widget w, XtPointer clientData,
 107                                     XtPointer WXUNUSED(ptr) );
 108
 109     int m_increment;
 110     wxArrowButtonTimer* m_timer;
 111 };
 112
 113 // ----------------------------------------------------------------------------
 114 // wxArrowButtonTimer implementation
 115 // ----------------------------------------------------------------------------
 116
 117 void wxArrowButtonTimer::Notify()
 118 {
 119     ++m_ticks;
 120     if( m_ticks < TICK_BEFORE_START ) return;
 121     // increment every other tick
 122     if( m_ticks <= TICK_BEFORE_EXPONENTIAL && m_ticks & 1 )
 123         return;
 124     if( m_ticks > TICK_BEFORE_EXPONENTIAL )
 125         m_increment = 2 * m_increment;
 126     if( m_increment >= MAX_INCREMENT ) m_increment = MAX_INCREMENT;
 127     m_button->GetSpinButton()->Increment( m_sign * m_increment );
 128 }
 129
 130 // ----------------------------------------------------------------------------
 131 // wxArrowButton implementation
 132 // ----------------------------------------------------------------------------
 133
 134 wxTimer* wxArrowButton::GetFreshTimer()
 135 {
 136     if( m_timer )
 137     {
 138         m_timer->Stop();
 139         m_timer->Reset();
 140     }
 141     else
 142         m_timer = new wxArrowButtonTimer( this, m_increment );
 143
 144     return m_timer;
 145 }
 146
 147 void wxArrowButton::SpinButtonCallback( Widget w, XtPointer clientData,
 148                                         XtPointer WXUNUSED(ptr) )
 149 {
 150     if( !wxGetWindowFromTable( w ) )
 151         // Widget has been deleted!
 152         return;
 153
 154     wxArrowButton* btn = (wxArrowButton*)clientData;
 155
 156     btn->GetSpinButton()->Increment( btn->m_increment );
 157 }
 158
 159 void wxArrowButton::StartTimerCallback( Widget w, XtPointer clientData,
 160                                         XtPointer WXUNUSED(ptr) )
 161 {
 162     if( !wxGetWindowFromTable( w ) )
 163         // Widget has been deleted!
 164         return;
 165
 166     wxArrowButton* btn = (wxArrowButton*)clientData;
 167     btn->GetFreshTimer()->Start( TICK_INTERVAL );
 168 }
 169
 170 void wxArrowButton::StopTimerCallback( Widget w, XtPointer clientData,
 171                                        XtPointer WXUNUSED(ptr) )
 172 {
 173     if( !wxGetWindowFromTable( w ) )
 174         // Widget has been deleted!
 175         return;
 176
 177     wxArrowButton* btn = (wxArrowButton*)clientData;
 178     delete btn->m_timer;
 179     btn->m_timer = 0;
 180 }
 181
 182 bool wxArrowButton::Create( wxSpinButton* parent, wxWindowID id,
 183                             ArrowDirection d,
 184                             const wxPoint& pos, const wxSize& size )
 185 {
 186     int arrow_dir = XmARROW_UP;
 187
 188     switch( d )
 189     {
 190     case wxARROW_UP:
 191         arrow_dir = XmARROW_UP;
 192         break;
 193     case wxARROW_DOWN:
 194         arrow_dir = XmARROW_DOWN;
 195         break;
 196     case wxARROW_LEFT:
 197         arrow_dir = XmARROW_LEFT;
 198         break;
 199     case wxARROW_RIGHT:
 200         arrow_dir = XmARROW_RIGHT;
 201         break;
 202     }
 203
 204     if( parent ) parent->AddChild( this );
 205
 206     Widget parentWidget = (Widget) parent->GetClientWidget();
 207     m_mainWidget = (WXWidget) XtVaCreateManagedWidget( "XmArrowButton",
 208         xmArrowButtonWidgetClass,
 209         parentWidget,
 210         XmNarrowDirection, arrow_dir,
 211         XmNborderWidth, 0,
 212         XmNshadowThickness, 0,
 213         NULL );
 214
 215     XtAddCallback( (Widget) m_mainWidget,
 216                    XmNactivateCallback, (XtCallbackProc) SpinButtonCallback,
 217                    (XtPointer) this );
 218     XtAddCallback( (Widget) m_mainWidget,
 219                    XmNarmCallback, (XtCallbackProc) StartTimerCallback,
 220                    (XtPointer) this );
 221     XtAddCallback( (Widget) m_mainWidget,
 222                    XmNactivateCallback, (XtCallbackProc) StopTimerCallback,
 223                    (XtPointer) this );
 224
 225     AttachWidget( parent, m_mainWidget, (WXWidget) NULL,
 226                   pos.x, pos.y, size.x, size.y );
 227
 228     SetForegroundColour( parent->GetBackgroundColour() );
 229
 230     return TRUE;
 231 }
 232
 233 // ----------------------------------------------------------------------------
 234 // wxSpinButton
 235 // ----------------------------------------------------------------------------
 236
 237 IMPLEMENT_DYNAMIC_CLASS(wxSpinButton, wxControl);
 238 IMPLEMENT_DYNAMIC_CLASS(wxSpinEvent, wxNotifyEvent);
 239
 240 static void CalcSizes( wxPoint pt, wxSize sz,
 241                        wxPoint& pt1, wxSize& sz1,
 242                        wxPoint& pt2, wxSize& sz2,
 243                        bool isVertical )
 244 {
 245     typedef int wxSize::* CDPTR1;
 246     typedef int wxPoint::* CDPTR2;
 247
 248     sz1 = sz2 = sz;
 249     pt2 = pt1 = pt;
 250
 251     CDPTR1 szm = isVertical ? &wxSize::y : &wxSize::x;
 252     CDPTR2 ptm = isVertical ? &wxPoint::y : &wxPoint::x;
 253     int dim = sz.*szm, half = dim/2;
 254
 255     sz1.*szm = half;
 256     sz2.*szm = dim - half;
 257     pt2.*ptm += half + 1;
 258 }
 259
 260 bool wxSpinButton::Create( wxWindow *parent, wxWindowID id,
 261                            const wxPoint& pos, const wxSize& size,
 262                            long style, const wxString& name )
 263 {
 264     m_windowStyle = style;
 265
 266     wxSize newSize = GetBestSize();
 267     if( size.x != -1 ) newSize.x = size.x;
 268     if( size.y != -1 ) newSize.y = size.y;
 269
 270     if( !wxControl::Create( parent, id, pos, newSize, style ) )
 271     {
 272         return FALSE;
 273     }
 274
 275     SetName(name);
 276
 277     InitBase();
 278
 279     m_windowId = ( id == -1 ) ? NewControlId() : id;
 280
 281     bool isVert = IsVertical();
 282     wxPoint pt1, pt2;
 283     wxSize sz1, sz2;
 284     CalcSizes( wxPoint(0,0), newSize, pt1, sz1, pt2, sz2, isVert );
 285     m_up = new wxArrowButton( this, -1, isVert ? wxARROW_UP : wxARROW_RIGHT,
 286                               pt1, sz1, 1 );
 287     m_down = new wxArrowButton( this, -1,
 288                                 isVert ? wxARROW_DOWN : wxARROW_LEFT,
 289                                 pt2, sz2, -1 );
 290
 291     return TRUE;
 292 }
 293
 294 wxSpinButton::~wxSpinButton()
 295 {
 296 }
 297
 298 void wxSpinButton::DoMoveWindow(int x, int y, int width, int height)
 299 {
 300     wxControl::DoMoveWindow( x, y, width, height );
 301
 302     wxPoint pt1, pt2;
 303     wxSize sz1, sz2;
 304
 305     CalcSizes( wxPoint(0,0), wxSize(width,height), pt1,
 306                sz1, pt2, sz2, IsVertical() );
 307     m_up->SetSize( pt1.x, pt1.y, sz1.x, sz1.y );
 308     m_down->SetSize( pt2.x, pt2.y, sz2.x, sz2.y );
 309 }
 310
 311 void wxSpinButton::DoSetSize(int x, int y, int width, int height,
 312                              int sizeFlags)
 313 {
 314 #ifdef __VMS__
 315 #pragma message disable codcauunr
 316 #endif
 317     if( sizeFlags & wxSIZE_USE_EXISTING && width == -1 )
 318         width = GetSize().x;
 319     if( sizeFlags & wxSIZE_USE_EXISTING && height == -1 )
 320         height = GetSize().y;
 321 #ifdef __VMS__
 322 #pragma message enable codcauunr
 323 #endif
 324
 325     wxControl::DoSetSize(x, y, width, height, 0);
 326 }
 327
 328 void wxSpinButton::Increment( int delta )
 329 {
 330     if( m_pos < m_min ) m_pos = m_min;
 331     if( m_pos > m_max ) m_pos = m_max;
 332
 333     int npos = m_pos + delta;
 334
 335     if( npos < m_min )
 336     {
 337         if( GetWindowStyle() & wxSP_WRAP )
 338             npos = m_max;
 339         else
 340             npos = m_min;
 341     }
 342     if( npos > m_max )
 343     {
 344         if( GetWindowStyle() & wxSP_WRAP )
 345             npos = m_min;
 346         else
 347             npos = m_max;
 348     }
 349     if( npos == m_pos ) return;
 350
 351     wxSpinEvent event( delta > 0 ? wxEVT_SCROLL_LINEUP : wxEVT_SCROLL_LINEDOWN,
 352                        m_windowId );
 353     event.SetPosition( npos );
 354     event.SetEventObject( this );
 355
 356     GetEventHandler()->ProcessEvent( event );
 357
 358     if( event.IsAllowed() )
 359     {
 360         m_pos = npos;
 361         event.SetEventType( wxEVT_SCROLL_THUMBTRACK );
 362         event.SetPosition( m_pos );
 363
 364         GetEventHandler()->ProcessEvent( event );
 365     }
 366 }
 367
 368 wxSize wxSpinButton::DoGetBestSize() const
 369 {
 370     return IsVertical() ? wxSize( 20, 30 ) : wxSize( 30, 20 );
 371 }
 372
 373 // Attributes
 374 ////////////////////////////////////////////////////////////////////////////
 375
 376 int wxSpinButton::GetValue() const
 377 {
 378     return m_pos;
 379 }
 380
 381 void wxSpinButton::SetValue(int val)
 382 {
 383     m_pos = val;
 384 }
 385
 386 void wxSpinButton::SetRange(int minVal, int maxVal)
 387 {
 388     wxSpinButtonBase::SetRange(minVal, maxVal);
 389 }
 390
 391 void wxSpinButton::ChangeFont(bool WXUNUSED(keepOriginalSize))
 392 {
 393     // TODO
 394 }
 395
 396 void wxSpinButton::ChangeBackgroundColour()
 397 {
 398     wxControl::ChangeBackgroundColour();
 399 }
 400
 401 void wxSpinButton::ChangeForegroundColour()
 402 {
 403     // TODO
 404 }