← Back to branch summary

~om26er/ubuntu/oneiric/nux/sru-888039

« back to all changes in this revision

Viewing changes to Nux/HScrollBar.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2011-07-21 18:41:46 UTC
  • mfrom: (1.1.23 upstream)
  • Revision ID: james.westby@ubuntu.com-20110721184146-po1lz9xhvsz1x7kt
Tags: 1.0.6-0ubuntu1
* New upstream release.
* debian/control:
  - dep on libglu1-mesa-dev
* debian/rules:
  - bump shlib

Show diffs side-by-side

added added

removed removed

Lines of Context:
Nux/HScrollBar.cpp
35
35
  HScrollBar::HScrollBar (NUX_FILE_LINE_DECL)
36
36
    :   ScrollBar (NUX_FILE_LINE_PARAM)
37
37
  {
38
 
    m_contentWidth      = 0;
39
 
    m_contentHeight     = 0;
40
 
    m_containerWidth    = 0;
41
 
    m_containerHeight   = 0;
 
38
    content_width_      = 0;
 
39
    content_height_     = 0;
 
40
    container_width_    = 0;
 
41
    container_height_   = 0;
42
42
    m_TrackWidth        = 0;
43
43
    m_TrackHeight       = 0;
44
44
    m_SlideBarOffsetX   = 0;
45
45
    m_SlideBarOffsetY   = 0;
46
 
    m_contentOffsetX    = 0;
47
 
    m_contentOffsetY    = 0;
 
46
    content_offset_x_    = 0;
 
47
    content_offset_y_    = 0;
48
48
    b_MouseUpTimer      = false;
49
49
    b_MouseDownTimer    = false;
50
50
    m_color_factor      = 1.0f;
52
52
    m_RightTimerHandler = 0;
53
53
 
54
54
    hlayout = new HLayout (NUX_TRACKER_LOCATION);
55
 
    m_LeftThumb = new InputArea (NUX_TRACKER_LOCATION);
56
 
    m_Track = new InputArea (NUX_TRACKER_LOCATION);
57
 
    m_RightThumb = new InputArea (NUX_TRACKER_LOCATION);
58
 
    m_SlideBar = new InputArea (NUX_TRACKER_LOCATION);
 
55
    _scroll_left_button = new InputArea (NUX_TRACKER_LOCATION);
 
56
    _track = new InputArea (NUX_TRACKER_LOCATION);
 
57
    _scroll_right_button = new InputArea (NUX_TRACKER_LOCATION);
 
58
    _slider = new InputArea (NUX_TRACKER_LOCATION);
 
59
    _slider->SetParentObject(this);
59
60
 
60
61
    // Set Original State
61
62
    SetMinimumSize (AREA_MIN_WIDTH, HSCROLLBAR_HEIGHT);
62
63
    SetMaximumSize (AREA_MAX_WIDTH, HSCROLLBAR_HEIGHT);
63
64
    // Set Signals
64
 
    m_RightThumb->OnMouseDown.connect ( sigc::mem_fun (this, &HScrollBar::RecvStartScrollRight) );
65
 
    m_RightThumb->OnMouseUp.connect ( sigc::mem_fun (this, &HScrollBar::RecvEndScrollRight) );
66
 
    m_LeftThumb->OnMouseDown.connect ( sigc::mem_fun (this, &HScrollBar::RecvStartScrollLeft) );
67
 
    m_LeftThumb->OnMouseUp.connect ( sigc::mem_fun (this, &HScrollBar::RecvEndScrollLeft) );
68
 
 
69
 
    m_SlideBar->OnMouseDown.connect ( sigc::mem_fun (this, &HScrollBar::OnSliderMouseDown) );
70
 
    m_SlideBar->OnMouseUp.connect ( sigc::mem_fun (this, &HScrollBar::OnSliderMouseUp) );
71
 
    m_SlideBar->OnMouseDrag.connect ( sigc::mem_fun (this, &HScrollBar::OnSliderMouseDrag) );
72
 
 
73
 
    m_Track->OnMouseDown.connect ( sigc::mem_fun (this, &HScrollBar::RecvTrackMouseDown) );
74
 
    m_Track->OnMouseUp.connect ( sigc::mem_fun (this, &HScrollBar::RecvTrackMouseUp) );
75
 
    m_Track->OnMouseDrag.connect ( sigc::mem_fun (this, &HScrollBar::RecvTrackMouseDrag) );
 
65
    _scroll_right_button->OnMouseDown.connect ( sigc::mem_fun (this, &HScrollBar::RecvStartScrollRight) );
 
66
    _scroll_right_button->OnMouseUp.connect ( sigc::mem_fun (this, &HScrollBar::RecvEndScrollRight) );
 
67
    _scroll_left_button->OnMouseDown.connect ( sigc::mem_fun (this, &HScrollBar::RecvStartScrollLeft) );
 
68
    _scroll_left_button->OnMouseUp.connect ( sigc::mem_fun (this, &HScrollBar::RecvEndScrollLeft) );
 
69
 
 
70
    _slider->OnMouseDown.connect ( sigc::mem_fun (this, &HScrollBar::OnSliderMouseDown) );
 
71
    _slider->OnMouseUp.connect ( sigc::mem_fun (this, &HScrollBar::OnSliderMouseUp) );
 
72
    _slider->OnMouseDrag.connect ( sigc::mem_fun (this, &HScrollBar::OnSliderMouseDrag) );
 
73
 
 
74
    _track->OnMouseDown.connect ( sigc::mem_fun (this, &HScrollBar::RecvTrackMouseDown) );
 
75
    _track->OnMouseUp.connect ( sigc::mem_fun (this, &HScrollBar::RecvTrackMouseUp) );
 
76
    _track->OnMouseDrag.connect ( sigc::mem_fun (this, &HScrollBar::RecvTrackMouseDrag) );
76
77
 
77
78
    // Set Geometry
78
 
    m_RightThumb->SetMinimumSize (HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT);
79
 
    m_RightThumb->SetMaximumSize (HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT);
80
 
    m_RightThumb->SetGeometry (Geometry (0, 0, HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT) );
81
 
    m_LeftThumb->SetMinimumSize (HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT);
82
 
    m_LeftThumb->SetMaximumSize (HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT);
83
 
    m_LeftThumb->SetGeometry (Geometry (0, 0, HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT) );
84
 
 
85
 
 
86
 
    hlayout->AddView (m_LeftThumb, 0, eCenter, eFix);
87
 
    hlayout->AddView (m_Track, 1, eCenter, eFull);
88
 
    hlayout->AddView (m_RightThumb, 0, eCenter, eFix);
 
79
    _scroll_right_button->SetMinimumSize (HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT);
 
80
    _scroll_right_button->SetMaximumSize (HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT);
 
81
    _scroll_right_button->SetGeometry (Geometry (0, 0, HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT) );
 
82
    _scroll_left_button->SetMinimumSize (HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT);
 
83
    _scroll_left_button->SetMaximumSize (HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT);
 
84
    _scroll_left_button->SetGeometry (Geometry (0, 0, HSCROLLBAR_WIDTH, HSCROLLBAR_HEIGHT) );
 
85
 
 
86
 
 
87
    hlayout->AddView (_scroll_left_button, 0, eCenter, eFix);
 
88
    hlayout->AddView (_track, 1, eCenter, eFull);
 
89
    hlayout->AddView (_scroll_right_button, 0, eCenter, eFix);
89
90
 
90
91
    callback = new TimerFunctor;
91
92
    callback->OnTimerExpired.connect (sigc::mem_fun (this, &HScrollBar::HScrollBarHandler) );
103
104
 
104
105
  HScrollBar::~HScrollBar()
105
106
  {
106
 
    m_SlideBar->Dispose();
 
107
    _slider->UnReference();
107
108
    delete callback;
108
109
    delete left_callback;
109
110
    delete trackleft_callback;
173
174
 
174
175
  void HScrollBar::TrackLeft (void *v)
175
176
  {
176
 
    if (m_TrackMouseCoord.x < m_SlideBar->GetBaseX() - m_Track->GetBaseX() )
 
177
    if (m_TrackMouseCoord.x < _slider->GetBaseX() - _track->GetBaseX() )
177
178
    {
178
 
      OnScrollLeft.emit (m_containerWidth, 1);
 
179
      OnScrollLeft.emit (container_width_, 1);
179
180
      m_TrackLeftTimerHandler  = GetTimer().AddTimerHandler (10, trackleft_callback, this);
180
181
      NeedRedraw();
181
182
    }
183
184
 
184
185
  void HScrollBar::TrackRight (void *v)
185
186
  {
186
 
    if (m_TrackMouseCoord.x > m_SlideBar->GetBaseX() + m_SlideBar->GetBaseWidth() - m_Track->GetBaseX() )
 
187
    if (m_TrackMouseCoord.x > _slider->GetBaseX() + _slider->GetBaseWidth() - _track->GetBaseX() )
187
188
    {
188
 
      OnScrollRight.emit (m_containerWidth, 1);
 
189
      OnScrollRight.emit (container_width_, 1);
189
190
      m_TrackRightTimerHandler  = GetTimer().AddTimerHandler (10, trackright_callback, this);
190
191
      NeedRedraw();
191
192
    }
223
224
  {
224
225
    m_TrackMouseCoord = Point (x, y);
225
226
 
226
 
    int X = m_SlideBar->GetBaseX() - m_Track->GetBaseX();
 
227
    int X = _slider->GetBaseX() - _track->GetBaseX();
227
228
 
228
229
    if (x < X)
229
230
    {
257
258
  long HScrollBar::ProcessEvent (IEvent &ievent, long TraverseInfo, long ProcessEventInfo)
258
259
  {
259
260
    long ret = TraverseInfo;
260
 
    ret = m_RightThumb->OnEvent (ievent, ret, ProcessEventInfo);
261
 
    ret = m_LeftThumb->OnEvent (ievent, ret, ProcessEventInfo);
262
 
    ret = m_SlideBar->OnEvent (ievent, ret, ProcessEventInfo);
263
 
    ret = m_Track->OnEvent (ievent, ret, ProcessEventInfo);
 
261
    ret = _scroll_right_button->OnEvent (ievent, ret, ProcessEventInfo);
 
262
    ret = _scroll_left_button->OnEvent (ievent, ret, ProcessEventInfo);
 
263
    ret = _slider->OnEvent (ievent, ret, ProcessEventInfo);
 
264
    ret = _track->OnEvent (ievent, ret, ProcessEventInfo);
264
265
    ret = PostProcessEvent2 (ievent, ret, ProcessEventInfo);
265
266
 
266
267
    return ret;
267
268
  }
268
269
 
 
270
  Area* HScrollBar::FindAreaUnderMouse(const Point& mouse_position, NuxEventType event_type)
 
271
  {
 
272
    bool mouse_inside = TestMousePointerInclusionFilterMouseWheel(mouse_position, event_type);
 
273
 
 
274
    if(mouse_inside == false)
 
275
      return NULL;
 
276
 
 
277
    NUX_RETURN_VALUE_IF_TRUE(_scroll_right_button->TestMousePointerInclusion(mouse_position, event_type), _scroll_right_button);
 
278
    NUX_RETURN_VALUE_IF_TRUE(_scroll_left_button->TestMousePointerInclusion(mouse_position, event_type), _scroll_left_button);
 
279
    NUX_RETURN_VALUE_IF_TRUE(_slider->TestMousePointerInclusion(mouse_position, event_type), _slider);
 
280
    NUX_RETURN_VALUE_IF_TRUE(_track->TestMousePointerInclusion(mouse_position, event_type), _track);
 
281
 
 
282
    if((event_type == NUX_MOUSE_WHEEL) && (!AcceptMouseWheelEvent()))
 
283
      return NULL;
 
284
    return this;
 
285
  }
 
286
 
269
287
  void HScrollBar::Draw (GraphicsEngine &GfxContext, bool force_draw)
270
288
  {
271
289
    Geometry base = GetGeometry();
275
293
    GetPainter().PaintShape (GfxContext, base,
276
294
                         Color (COLOR_SCROLLBAR_TRACK), eHSCROLLBAR, false);
277
295
 
278
 
    GetPainter().PaintShape (GfxContext, m_LeftThumb->GetGeometry(), Color (0xFFFFFFFF), eSCROLLBAR_TRIANGLE_LEFT);
279
 
    GetPainter().PaintShape (GfxContext, m_RightThumb->GetGeometry(), Color (0xFFFFFFFF), eSCROLLBAR_TRIANGLE_RIGHT);
 
296
    GetPainter().PaintShape (GfxContext, _scroll_left_button->GetGeometry(), Color (0xFFFFFFFF), eSCROLLBAR_TRIANGLE_LEFT);
 
297
    GetPainter().PaintShape (GfxContext, _scroll_right_button->GetGeometry(), Color (0xFFFFFFFF), eSCROLLBAR_TRIANGLE_RIGHT);
280
298
 
281
 
    GetPainter().PaintShape (GfxContext, m_SlideBar->GetGeometry(),
 
299
    GetPainter().PaintShape (GfxContext, _slider->GetGeometry(),
282
300
                         Color (0.2156 * m_color_factor, 0.2156 * m_color_factor, 0.2156 * m_color_factor, 1.0f),
283
301
                         eHSCROLLBAR, true);
284
302
  };
286
304
  void HScrollBar::SetContainerSize (int x, int y, int w, int h)
287
305
  {
288
306
    // x and y are not needed
289
 
    m_containerWidth = w;
290
 
    m_containerHeight = h;
 
307
    container_width_ = w;
 
308
    container_height_ = h;
291
309
    ComputeScrolling();
292
310
  }
293
311
 
294
312
  void HScrollBar::SetContentSize (int x, int y, int w, int h)
295
313
  {
296
314
    // x and y are not needed
297
 
    m_contentWidth = w;
298
 
    m_contentHeight = h;
 
315
    content_width_ = w;
 
316
    content_height_ = h;
299
317
    ComputeScrolling();
300
318
  }
301
319
 
302
320
  void HScrollBar::SetContentOffset (float dx, float dy)
303
321
  {
304
 
    m_contentOffsetX = dx;
305
 
    m_contentOffsetY = dy;
 
322
    content_offset_x_ = dx;
 
323
    content_offset_y_ = dy;
306
324
    ComputeScrolling();
307
325
  }
308
326
 
309
327
  void HScrollBar::ComputeScrolling()
310
328
  {
311
 
    float percentage = 0;
312
 
 
313
 
    if (m_contentWidth == 0)
 
329
    if (content_width_ == 0)
314
330
    {
315
 
      percentage = 100.0f;
 
331
      visibility_percentage_ = 100.0f;
316
332
    }
317
333
    else
318
334
    {
319
 
      percentage = 100.0f * (float) m_containerWidth / (float) m_contentWidth;
320
 
    }
321
 
 
322
 
    if (percentage > 100.0f)
323
 
    {
324
 
      percentage = 100.0f;
325
 
    }
326
 
 
327
 
    if (percentage < 0.0f)
328
 
    {
329
 
      percentage = 0.0f;
330
 
    }
331
 
 
332
 
    m_TrackWidth = m_Track->GetBaseWidth();
333
 
 
334
 
    int slider_height = m_LeftThumb->GetBaseHeight();
335
 
    int slider_width = m_TrackWidth * percentage / 100.0f;
 
335
      visibility_percentage_ = Clamp<float>(100.0f * (float) container_width_ / (float) content_width_, 0.0f, 100.0f);
 
336
    }
 
337
 
 
338
    m_TrackWidth = _track->GetBaseWidth();
 
339
 
 
340
    int slider_height = _scroll_left_button->GetBaseHeight();
 
341
    int slider_width = m_TrackWidth * visibility_percentage_ / 100.0f;
336
342
 
337
343
    if (slider_width < 15)
338
344
    {
339
345
      slider_width = 15;
340
346
    }
341
347
 
342
 
    m_SlideBar->SetBaseWidth (slider_width);
343
 
    m_SlideBar->SetBaseHeight (slider_height);
344
 
    m_SlideBar->SetBaseY (m_LeftThumb->GetBaseY() );
 
348
    _slider->SetBaseWidth (slider_width);
 
349
    _slider->SetBaseHeight (slider_height);
 
350
    _slider->SetBaseY (_scroll_left_button->GetBaseY() );
345
351
 
346
352
 
347
353
    float pct;
348
354
 
349
 
    if (m_contentWidth - m_containerWidth > 0)
350
 
      pct = - (float) m_contentOffsetX / (float) (m_contentWidth - m_containerWidth);
 
355
    if (content_width_ - container_width_ > 0)
 
356
      pct = - (float) content_offset_x_ / (float) (content_width_ - container_width_);
351
357
    else
352
358
      pct = 0;
353
359
 
354
 
    int x = m_Track->GetBaseX() + pct * (m_TrackWidth - slider_width);
355
 
    m_SlideBar->SetBaseX (x);
 
360
    int x = _track->GetBaseX() + pct * (m_TrackWidth - slider_width);
 
361
    _slider->SetBaseX (x);
356
362
  }
357
363
 
358
364
 
392
398
 
393
399
  void HScrollBar::OnSliderMouseDrag (int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
394
400
  {
395
 
    if (m_Track->GetBaseWidth() - m_SlideBar->GetBaseWidth() > 0)
 
401
    if (_track->GetBaseWidth() - _slider->GetBaseWidth() > 0)
396
402
    {
397
 
      stepX = (float) (m_contentWidth - m_containerWidth) / (float) (m_Track->GetBaseWidth() - m_SlideBar->GetBaseWidth() );
 
403
      stepX = (float) (content_width_ - container_width_) / (float) (_track->GetBaseWidth() - _slider->GetBaseWidth() );
398
404
    }
399
405
    else
400
406
    {
414
420
 
415
421
  bool HScrollBar::AtMaximum()
416
422
  {
417
 
    if (m_SlideBar->GetBaseX() + m_SlideBar->GetBaseWidth() == m_Track->GetBaseX() + m_Track->GetBaseWidth() )
 
423
    if (_slider->GetBaseX() + _slider->GetBaseWidth() == _track->GetBaseX() + _track->GetBaseWidth() )
418
424
      return TRUE;
419
425
 
420
426
    return FALSE;
422
428
 
423
429
  bool HScrollBar::AtMinimum()
424
430
  {
425
 
    if (m_SlideBar->GetBaseX() == m_Track->GetBaseX() )
 
431
    if (_slider->GetBaseX() == _track->GetBaseX() )
426
432
      return TRUE;
427
433
 
428
434
    return FALSE;