← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/nux/oneiric

« back to all changes in this revision

Viewing changes to Nux/SpinBox.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-11-18 19:17:32 UTC
  • Revision ID: james.westby@ubuntu.com-20101118191732-rn35790vekj6o4my
Tags: upstream-0.9.4
Import upstream version 0.9.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
Nux/SpinBox.cpp
 
1
/*
 
2
 * Copyright 2010 Inalogic Inc.
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify it
 
5
 * under the terms of the GNU Lesser General Public License version 3, as
 
6
 * published by the  Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful, but
 
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 
10
 * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
 
11
 * PURPOSE.  See the applicable version of the GNU Lesser General Public
 
12
 * License for more details.
 
13
 *
 
14
 * You should have received a copy of both the GNU Lesser General Public
 
15
 * License version 3 along with this program.  If not, see
 
16
 * <http://www.gnu.org/licenses/>
 
17
 *
 
18
 * Authored by: Jay Taoko <jay.taoko_AT_gmail_DOT_com>
 
19
 *
 
20
 */
 
21
 
 
22
#include "Nux.h"
 
23
#include "TimerProc.h"
 
24
#include "HLayout.h"
 
25
#include "VLayout.h"
 
26
#include "IntegerValidator.h"
 
27
#include "SpinBox.h"
 
28
 
 
29
namespace nux
 
30
{
 
31
 
 
32
  const Color SPINBOX_BUTTON_COLOR = Color (0xFF4D4D4D);
 
33
  const Color SPINBOX_BUTTON_MOUSEOVER_COLOR = Color (0xFF222222);
 
34
 
 
35
  SpinBox::SpinBox (int Value, int Step, int MinValue, int MaxValue)
 
36
    :   m_IntValidator (MinValue, MaxValue)
 
37
    ,   m_Step (Step)
 
38
  {
 
39
    InitializeLayout();
 
40
    InitializeWidgets();
 
41
    SetValue (Value);
 
42
  }
 
43
 
 
44
  SpinBox::~SpinBox()
 
45
  {
 
46
    DestroyLayout();
 
47
  }
 
48
 
 
49
  void SpinBox::InitializeWidgets()
 
50
  {
 
51
    m_EditLine->SetValidator (&m_IntValidator);
 
52
    m_EditLine->SetSuffix (TEXT ("") );
 
53
    m_EditLine->SetPrefix (TEXT ("") );
 
54
    m_EditLine->SetText (inlPrintf (TEXT ("%d"), m_IntValidator.GetMinimum() ) );
 
55
 
 
56
    m_EditLine->SetMinimumSize (1.5 * DEFAULT_WIDGET_WIDTH, DEFAULT_WIDGET_HEIGHT);
 
57
    m_EditLine->SetGeometry (Geometry (0, 0, DEFAULT_WIDGET_WIDTH, DEFAULT_WIDGET_HEIGHT) );
 
58
 
 
59
    m_SpinnerUpBtn->SetMinimumSize (15, 10);
 
60
    m_SpinnerUpBtn->SetGeometry (Geometry (0, 0, 15, 10) );
 
61
    m_SpinnerDownBtn->SetMinimumSize (15, 10);
 
62
    m_SpinnerDownBtn->SetGeometry (Geometry (0, 0, 15, 10) );
 
63
 
 
64
    m_UpTimerCallback = new TimerFunctor;
 
65
    m_UpTimerCallback->OnTimerExpired.connect (sigc::mem_fun (this, &SpinBox_Logic::TimerSpinUpBtn) );
 
66
    m_DownTimerCallback = new TimerFunctor;
 
67
    m_DownTimerCallback->OnTimerExpired.connect (sigc::mem_fun (this, &SpinBox_Logic::TimerSpinDownBtn) );
 
68
 
 
69
    // Set the minimum size of this widget.
 
70
    // This is use by TextLineEditPropertyItem::GetItemBestHeight
 
71
    SetMinimumSize (DEFAULT_WIDGET_WIDTH, PRACTICAL_WIDGET_HEIGHT);
 
72
 
 
73
    hlayout->AddView (m_EditLine, 1);
 
74
 
 
75
    vlayout->AddView (m_SpinnerUpBtn, 1);
 
76
    vlayout->AddView (m_SpinnerDownBtn, 1);
 
77
    hlayout->AddLayout (vlayout, 0);
 
78
 
 
79
    SetCompositionLayout (hlayout);
 
80
  }
 
81
 
 
82
  void SpinBox::InitializeLayout()
 
83
  {
 
84
    hlayout = new HLayout (NUX_TRACKER_LOCATION);
 
85
    vlayout = new VLayout (NUX_TRACKER_LOCATION);
 
86
  }
 
87
 
 
88
  void SpinBox::DestroyLayout()
 
89
  {
 
90
  }
 
91
 
 
92
  long SpinBox::ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
 
93
  {
 
94
    long ret = TraverseInfo;
 
95
    ret = m_SpinnerUpBtn->OnEvent (ievent, ret, ProcessEventInfo);
 
96
    ret = m_SpinnerDownBtn->OnEvent (ievent, ret, ProcessEventInfo);
 
97
    ret = m_EditLine->ProcessEvent (ievent, ret, ProcessEventInfo);
 
98
    ret = PostProcessEvent2 (ievent, ret, ProcessEventInfo);
 
99
    return ret;
 
100
  }
 
101
 
 
102
  void SpinBox::Draw (GraphicsEngine &GfxContext, bool force_draw)
 
103
  {
 
104
    Geometry base = GetGeometry();
 
105
    GetPainter().PaintBackground (GfxContext, base);
 
106
 
 
107
    if (m_EditLine->IsMouseInside() || m_SpinnerUpBtn->IsMouseInside() || m_SpinnerDownBtn->IsMouseInside() )
 
108
    {
 
109
 
 
110
      GetPainter().PaintShapeCorner (GfxContext, m_SpinnerUpBtn->GetGeometry(), SPINBOX_BUTTON_MOUSEOVER_COLOR, eSHAPE_CORNER_ROUND4,
 
111
                                 eCornerTopRight, false);
 
112
      GetPainter().PaintShapeCorner (GfxContext, m_SpinnerDownBtn->GetGeometry(), SPINBOX_BUTTON_MOUSEOVER_COLOR, eSHAPE_CORNER_ROUND4,
 
113
                                 eCornerBottomRight, false);
 
114
    }
 
115
    else
 
116
    {
 
117
      GetPainter().PaintShapeCorner (GfxContext, m_SpinnerUpBtn->GetGeometry(), SPINBOX_BUTTON_COLOR, eSHAPE_CORNER_ROUND4,
 
118
                                 eCornerTopRight, false);
 
119
      GetPainter().PaintShapeCorner (GfxContext, m_SpinnerDownBtn->GetGeometry(), SPINBOX_BUTTON_COLOR, eSHAPE_CORNER_ROUND4,
 
120
                                 eCornerBottomRight, false);
 
121
    }
 
122
 
 
123
    GeometryPositioning gp (eHACenter, eVACenter);
 
124
    Geometry GeoPo = ComputeGeometryPositioning (m_SpinnerUpBtn->GetGeometry(), GetTheme().GetImageGeometry (eSPINER_UP), gp);
 
125
 
 
126
    if (m_SpinnerUpBtn->IsMouseInside() )
 
127
      GetPainter().PaintShape (GfxContext, GeoPo, Color (0xFFFFFFFF), eSPINER_UP);
 
128
    else
 
129
      GetPainter().PaintShape (GfxContext, GeoPo, Color (0xFFFFFFFF), eSPINER_UP);
 
130
 
 
131
 
 
132
    gp.SetAlignment (eHACenter, eVACenter);
 
133
    GeoPo = ComputeGeometryPositioning (m_SpinnerDownBtn->GetGeometry(), GetTheme().GetImageGeometry (eSPINER_DOWN), gp);
 
134
 
 
135
    if (m_SpinnerDownBtn->IsMouseInside() )
 
136
      GetPainter().PaintShape (GfxContext, GeoPo, Color (0xFFFFFFFF), eSPINER_DOWN);
 
137
    else
 
138
      GetPainter().PaintShape (GfxContext, GeoPo, Color (0xFFFFFFFF), eSPINER_DOWN);
 
139
 
 
140
    m_EditLine->NeedRedraw();
 
141
  }
 
142
 
 
143
  void SpinBox::DrawContent (GraphicsEngine &GfxContext, bool force_draw)
 
144
  {
 
145
    m_EditLine->ProcessDraw (GfxContext, force_draw);
 
146
  }
 
147
 
 
148
  void SpinBox::PostDraw (GraphicsEngine &GfxContext, bool force_draw)
 
149
  {
 
150
 
 
151
  }
 
152
 
 
153
  void SpinBox::SetValue (int value)
 
154
  {
 
155
    m_iValue = m_IntValidator.Validate (value);
 
156
    m_EditLine->SetText (inlPrintf ("%d", m_iValue) );
 
157
    sigValueChanged.emit (this);
 
158
    sigValue.emit (m_iValue);
 
159
    NeedRedraw();
 
160
  }
 
161
 
 
162
  int SpinBox::GetValue() const
 
163
  {
 
164
    return m_iValue;
 
165
  }
 
166
 
 
167
  void SpinBox::SetStep (int i)
 
168
  {
 
169
    m_Step = i;
 
170
 
 
171
    if (m_Step <= 0)
 
172
      m_Step = 1;
 
173
 
 
174
    NeedRedraw();
 
175
  }
 
176
 
 
177
  int SpinBox::GetStep() const
 
178
  {
 
179
    return m_Step;
 
180
  }
 
181
 
 
182
  int SpinBox::GetMinValue() const
 
183
  {
 
184
    return m_IntValidator.GetMinimum();
 
185
  }
 
186
 
 
187
  int SpinBox::GetMaxValue() const
 
188
  {
 
189
    return m_IntValidator.GetMaximum();
 
190
  }
 
191
 
 
192
  void SpinBox::SetRange (int MinValue, int Maxvalue)
 
193
  {
 
194
    m_IntValidator.SetMinimum (MinValue);
 
195
    m_IntValidator.SetMaximum (Maxvalue);
 
196
    m_iValue = m_IntValidator.Validate (m_iValue);
 
197
    sigValueChanged.emit (this);
 
198
    sigValue.emit (m_iValue);
 
199
    NeedRedraw();
 
200
  }
 
201
 
 
202
  void SpinBox::ImplementIncrementBtn()
 
203
  {
 
204
    SetValue (m_iValue + m_Step);
 
205
 
 
206
    if (m_iValue < m_IntValidator.GetMaximum() )
 
207
    {
 
208
      if (m_UpTimerHandler.IsValid() )
 
209
        m_UpTimerHandler = GetTimer().AddTimerHandler (100, m_UpTimerCallback, 0);
 
210
      else
 
211
        m_UpTimerHandler = GetTimer().AddTimerHandler (800, m_UpTimerCallback, 0);
 
212
 
 
213
      NeedRedraw();
 
214
    }
 
215
 
 
216
    sigValueChanged.emit (this);
 
217
    sigIncrement.emit (this);
 
218
    sigValue.emit (m_iValue);
 
219
  }
 
220
 
 
221
  void SpinBox::ImplementDecrementBtn()
 
222
  {
 
223
    SetValue (m_iValue - m_Step);
 
224
 
 
225
    if (m_iValue > m_IntValidator.GetMinimum() )
 
226
    {
 
227
      if (m_DownTimerHandler.IsValid() )
 
228
        m_DownTimerHandler = GetTimer().AddTimerHandler (100, m_DownTimerCallback, 0);
 
229
      else
 
230
        m_DownTimerHandler = GetTimer().AddTimerHandler (800, m_DownTimerCallback, 0);
 
231
 
 
232
      NeedRedraw();
 
233
    }
 
234
 
 
235
    sigValueChanged.emit (this);
 
236
    sigDecrement.emit (this);
 
237
    sigValue.emit (m_iValue);
 
238
  }
 
239
 
 
240
  void SpinBox::ImplementValidateEntry()
 
241
  {
 
242
    double ret = 0;
 
243
    ret = CharToDouble (m_EditLine->GetCleanText().GetTCharPtr() );
 
244
    {
 
245
      m_iValue = m_IntValidator.Validate (ret);
 
246
      m_EditLine->SetText (inlPrintf ("%d", m_iValue) );
 
247
      sigValueChanged.emit (this);
 
248
      sigValue.emit (m_iValue);
 
249
//
 
250
//        if(m_iValue < m_IntValidator.GetMinimum())
 
251
//        {
 
252
//            m_iValue = m_IntValidator.GetMinimum();
 
253
//            m_EditLine->SetText(inlPrintf("%d", m_iValue));
 
254
//        }
 
255
//        if(m_iValue > m_IntValidator.GetMaximum())
 
256
//        {
 
257
//            m_iValue = m_IntValidator.GetMaximum();
 
258
//            m_EditLine->SetText(inlPrintf("%d", m_iValue));
 
259
//        }
 
260
    }
 
261
//     else
 
262
//     {
 
263
//         m_EditLine->SetText(inlPrintf("%d", m_iValue));
 
264
//         sigValueChanged.emit(this);
 
265
//         sigValue.emit(m_iValue);
 
266
//     }
 
267
  }
 
268
 
 
269
}