← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/qwt/oneiric-proposed

« back to all changes in this revision

Viewing changes to qwt-5.1.2/src/qwt_slider.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Fathi Boudra
  • Date: 2009-04-12 23:25:58 UTC
  • mfrom: (1.1.4 upstream) (2.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090412232558-3bl06x785yr8xm8u
Tags: 5.1.2-1
* New upstream release.
* Bump compat/debhelper to 7.
* Bump Standards-Version to 3.8.1. No changes needed.
* Invert Maintainers and Uploaders field.
* Fix lintian warnings:
  - dh_clean _k deprecated.
  - missing dependency on libc.

Show diffs side-by-side

added added

removed removed

Lines of Context:
qwt-5.1.2/src/qwt_slider.cpp
 
1
/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 
2
 * Qwt Widget Library
 
3
 * Copyright (C) 1997   Josef Wilgen
 
4
 * Copyright (C) 2002   Uwe Rathmann
 
5
 *
 
6
 * This library is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the Qwt License, Version 1.0
 
8
 *****************************************************************************/
 
9
 
 
10
// vim: expandtab
 
11
 
 
12
#include <math.h>
 
13
#include <qevent.h>
 
14
#include <qdrawutil.h>
 
15
#include <qpainter.h>
 
16
#include "qwt_painter.h"
 
17
#include "qwt_paint_buffer.h"
 
18
#include "qwt_scale_draw.h"
 
19
#include "qwt_scale_map.h"
 
20
#include "qwt_slider.h"
 
21
 
 
22
class QwtSlider::PrivateData
 
23
{
 
24
public:
 
25
    QRect sliderRect;
 
26
 
 
27
    int thumbLength;
 
28
    int thumbWidth;
 
29
    int borderWidth;
 
30
    int scaleDist;
 
31
    int xMargin;
 
32
    int yMargin;
 
33
 
 
34
    QwtSlider::ScalePos scalePos;
 
35
    QwtSlider::BGSTYLE bgStyle;
 
36
 
 
37
    /*
 
38
      Scale and values might have different maps. This is
 
39
      confusing and I can't see strong arguments for such
 
40
      a feature. TODO ...
 
41
     */
 
42
    QwtScaleMap map; // linear map
 
43
    mutable QSize sizeHintCache;
 
44
};
 
45
 
 
46
/*!
 
47
  \brief Constructor
 
48
  \param parent parent widget
 
49
  \param orientation Orientation of the slider. Can be Qt::Horizontal
 
50
         or Qt::Vertical. Defaults to Qt::Horizontal.
 
51
  \param scalePos Position of the scale.  
 
52
         Defaults to QwtSlider::NoScale.
 
53
  \param bgStyle Background style. QwtSlider::BgTrough draws the
 
54
         slider button in a trough, QwtSlider::BgSlot draws
 
55
         a slot underneath the button. An or-combination of both
 
56
         may also be used. The default is QwtSlider::BgTrough.
 
57
 
 
58
  QwtSlider enforces valid combinations of its orientation and scale position.
 
59
  If the combination is invalid, the scale position will be set to NoScale. 
 
60
  Valid combinations are:
 
61
  - Qt::Horizonal with NoScale, TopScale, or BottomScale;
 
62
  - Qt::Vertical with NoScale, LeftScale, or RightScale.
 
63
*/
 
64
QwtSlider::QwtSlider(QWidget *parent,
 
65
        Qt::Orientation orientation, ScalePos scalePos, BGSTYLE bgStyle): 
 
66
    QwtAbstractSlider(orientation, parent)
 
67
{
 
68
    initSlider(orientation, scalePos, bgStyle);
 
69
}
 
70
 
 
71
#if QT_VERSION < 0x040000
 
72
/*!
 
73
  \brief Constructor
 
74
 
 
75
  Build a horizontal slider with no scale and BgTrough as 
 
76
  background style
 
77
 
 
78
  \param parent parent widget
 
79
  \param name Object name
 
80
*/
 
81
QwtSlider::QwtSlider(QWidget *parent, const char* name):
 
82
    QwtAbstractSlider(Qt::Horizontal, parent)
 
83
{
 
84
    setName(name);
 
85
    initSlider(Qt::Horizontal, NoScale, BgTrough);
 
86
}
 
87
#endif
 
88
 
 
89
void QwtSlider::initSlider(Qt::Orientation orientation, 
 
90
    ScalePos scalePos, BGSTYLE bgStyle)
 
91
{
 
92
    if (orientation == Qt::Vertical) 
 
93
        setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
 
94
    else
 
95
        setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 
96
 
 
97
#if QT_VERSION >= 0x040000
 
98
    setAttribute(Qt::WA_WState_OwnSizePolicy, false);
 
99
#else
 
100
    clearWState( WState_OwnSizePolicy );
 
101
#endif
 
102
 
 
103
 
 
104
#if QT_VERSION < 0x040000
 
105
    setWFlags(Qt::WNoAutoErase);
 
106
#endif
 
107
 
 
108
    d_data = new QwtSlider::PrivateData;
 
109
 
 
110
    d_data->borderWidth = 2;
 
111
    d_data->scaleDist = 4;
 
112
    d_data->scalePos = scalePos;
 
113
    d_data->xMargin = 0;
 
114
    d_data->yMargin = 0;
 
115
    d_data->bgStyle = bgStyle;
 
116
 
 
117
    if (bgStyle == BgSlot)
 
118
    {
 
119
        d_data->thumbLength = 16;
 
120
        d_data->thumbWidth = 30;
 
121
    }
 
122
    else
 
123
    {
 
124
        d_data->thumbLength = 31;
 
125
        d_data->thumbWidth = 16;
 
126
    }
 
127
 
 
128
    d_data->sliderRect.setRect(0,0,8,8);
 
129
 
 
130
    QwtScaleDraw::Alignment align;
 
131
    if ( orientation == Qt::Vertical )
 
132
    {
 
133
        // enforce a valid combination of scale position and orientation
 
134
        if ((d_data->scalePos == BottomScale) || (d_data->scalePos == TopScale))
 
135
            d_data->scalePos = NoScale;
 
136
        // adopt the policy of layoutSlider (NoScale lays out like Left)
 
137
        if (d_data->scalePos == RightScale)
 
138
           align = QwtScaleDraw::RightScale;
 
139
        else
 
140
           align = QwtScaleDraw::LeftScale;
 
141
    }
 
142
    else
 
143
    {
 
144
        // enforce a valid combination of scale position and orientation
 
145
        if ((d_data->scalePos == LeftScale) || (d_data->scalePos == RightScale))
 
146
            d_data->scalePos = NoScale;
 
147
        // adopt the policy of layoutSlider (NoScale lays out like Bottom)
 
148
        if (d_data->scalePos == TopScale)
 
149
           align = QwtScaleDraw::TopScale;
 
150
        else
 
151
           align = QwtScaleDraw::BottomScale;
 
152
    }
 
153
 
 
154
    scaleDraw()->setAlignment(align);
 
155
    scaleDraw()->setLength(100);
 
156
 
 
157
    setRange(0.0, 100.0, 1.0);
 
158
    setValue(0.0);
 
159
}
 
160
 
 
161
QwtSlider::~QwtSlider()
 
162
{
 
163
    delete d_data;
 
164
}
 
165
 
 
166
/*!
 
167
  \brief Set the orientation.
 
168
  \param o Orientation. Allowed values are Qt::Horizontal and Qt::Vertical.
 
169
  
 
170
  If the new orientation and the old scale position are an invalid combination,
 
171
  the scale position will be set to QwtSlider::NoScale.
 
172
  \sa QwtAbstractSlider::orientation()
 
173
*/
 
174
void QwtSlider::setOrientation(Qt::Orientation o) 
 
175
{
 
176
    if ( o == orientation() )
 
177
        return;
 
178
 
 
179
    if (o == Qt::Horizontal)
 
180
    {
 
181
        if ((d_data->scalePos == LeftScale) || (d_data->scalePos == RightScale))
 
182
            d_data->scalePos = NoScale;
 
183
    }
 
184
    else // if (o == Qt::Vertical)
 
185
    {
 
186
        if ((d_data->scalePos == BottomScale) || (d_data->scalePos == TopScale))
 
187
            d_data->scalePos = NoScale;
 
188
    }
 
189
 
 
190
#if QT_VERSION >= 0x040000
 
191
    if ( !testAttribute(Qt::WA_WState_OwnSizePolicy) )
 
192
#else
 
193
    if ( !testWState( WState_OwnSizePolicy ) ) 
 
194
#endif
 
195
    {
 
196
        QSizePolicy sp = sizePolicy();
 
197
        sp.transpose();
 
198
        setSizePolicy(sp);
 
199
 
 
200
#if QT_VERSION >= 0x040000
 
201
        setAttribute(Qt::WA_WState_OwnSizePolicy, false);
 
202
#else
 
203
        clearWState( WState_OwnSizePolicy );
 
204
#endif
 
205
    }
 
206
 
 
207
    QwtAbstractSlider::setOrientation(o);
 
208
    layoutSlider();
 
209
}
 
210
 
 
211
/*!
 
212
  \brief Change the scale position (and slider orientation).
 
213
 
 
214
  \param s Position of the scale.
 
215
 
 
216
  A valid combination of scale position and orientation is enforced:
 
217
  - if the new scale position is Left or Right, the scale orientation will
 
218
    become Qt::Vertical;
 
219
  - if the new scale position is Bottom or Top the scale orientation will
 
220
    become Qt::Horizontal;
 
221
  - if the new scale position is QwtSlider::NoScale, the scale 
 
222
    orientation will not change.
 
223
*/
 
224
void QwtSlider::setScalePosition(ScalePos s)
 
225
{
 
226
    if ( d_data->scalePos == s )
 
227
        return;
 
228
 
 
229
    d_data->scalePos = s;
 
230
 
 
231
    switch(d_data->scalePos)
 
232
    {
 
233
        case BottomScale:
 
234
        {
 
235
            setOrientation(Qt::Horizontal);
 
236
            scaleDraw()->setAlignment(QwtScaleDraw::BottomScale);
 
237
            break;
 
238
        }
 
239
        case TopScale:
 
240
        {
 
241
            setOrientation(Qt::Horizontal);
 
242
            scaleDraw()->setAlignment(QwtScaleDraw::TopScale);
 
243
            break;
 
244
        }
 
245
        case LeftScale:
 
246
        {
 
247
            setOrientation(Qt::Vertical);
 
248
            scaleDraw()->setAlignment(QwtScaleDraw::LeftScale);
 
249
            break;
 
250
        }
 
251
        case RightScale:
 
252
        {
 
253
            setOrientation(Qt::Vertical);
 
254
            scaleDraw()->setAlignment(QwtScaleDraw::RightScale);
 
255
            break;
 
256
        }
 
257
        default:
 
258
        {
 
259
            // nothing
 
260
        }
 
261
    }
 
262
 
 
263
    layoutSlider();
 
264
}
 
265
 
 
266
//! Return the scale position.
 
267
QwtSlider::ScalePos QwtSlider::scalePosition() const
 
268
{
 
269
    return d_data->scalePos;
 
270
}
 
271
 
 
272
/*!
 
273
  \brief Change the slider's border width
 
274
  \param bd border width
 
275
*/
 
276
void QwtSlider::setBorderWidth(int bd)
 
277
{
 
278
    if ( bd < 0 )
 
279
        bd = 0;
 
280
 
 
281
    if ( bd != d_data->borderWidth )
 
282
    {
 
283
        d_data->borderWidth = bd;
 
284
        layoutSlider();
 
285
    }
 
286
}
 
287
 
 
288
/*!
 
289
  \brief Set the slider's thumb length
 
290
  \param thumbLength new length
 
291
*/
 
292
void QwtSlider::setThumbLength(int thumbLength)
 
293
{
 
294
    if ( thumbLength < 8 )
 
295
        thumbLength = 8;
 
296
 
 
297
    if ( thumbLength != d_data->thumbLength )
 
298
    {
 
299
        d_data->thumbLength = thumbLength;
 
300
        layoutSlider();
 
301
    }
 
302
}
 
303
 
 
304
/*!
 
305
  \brief Change the width of the thumb
 
306
  \param w new width
 
307
*/
 
308
void QwtSlider::setThumbWidth(int w)
 
309
{
 
310
    if ( w < 4 )
 
311
        w = 4;
 
312
 
 
313
    if ( d_data->thumbWidth != w )
 
314
    {
 
315
        d_data->thumbWidth = w;
 
316
        layoutSlider();
 
317
    }
 
318
}
 
319
 
 
320
/*!
 
321
  \brief Set a scale draw
 
322
 
 
323
  For changing the labels of the scales, it
 
324
  is necessary to derive from QwtScaleDraw and
 
325
  overload QwtScaleDraw::label().
 
326
 
 
327
  \param scaleDraw ScaleDraw object, that has to be created with 
 
328
                   new and will be deleted in ~QwtSlider or the next 
 
329
                   call of setScaleDraw().
 
330
*/
 
331
void QwtSlider::setScaleDraw(QwtScaleDraw *scaleDraw)
 
332
{
 
333
    const QwtScaleDraw *previousScaleDraw = this->scaleDraw();
 
334
    if ( scaleDraw == NULL || scaleDraw == previousScaleDraw )
 
335
        return;
 
336
 
 
337
    if ( previousScaleDraw )
 
338
        scaleDraw->setAlignment(previousScaleDraw->alignment());
 
339
 
 
340
    setAbstractScaleDraw(scaleDraw);
 
341
    layoutSlider();
 
342
}
 
343
 
 
344
/*!
 
345
  \return the scale draw of the slider
 
346
  \sa setScaleDraw()
 
347
*/
 
348
const QwtScaleDraw *QwtSlider::scaleDraw() const
 
349
{
 
350
    return (QwtScaleDraw *)abstractScaleDraw();
 
351
}
 
352
 
 
353
/*!
 
354
  \return the scale draw of the slider
 
355
  \sa setScaleDraw()
 
356
*/
 
357
QwtScaleDraw *QwtSlider::scaleDraw()
 
358
{
 
359
    return (QwtScaleDraw *)abstractScaleDraw();
 
360
}
 
361
 
 
362
//! Notify changed scale
 
363
void QwtSlider::scaleChange()
 
364
{
 
365
    layoutSlider();
 
366
}
 
367
 
 
368
 
 
369
//! Notify change in font
 
370
void QwtSlider::fontChange(const QFont &f)
 
371
{
 
372
    QwtAbstractSlider::fontChange( f );
 
373
    layoutSlider();
 
374
}
 
375
 
 
376
//! Draw the slider into the specified rectangle.
 
377
void QwtSlider::drawSlider(QPainter *p, const QRect &r)
 
378
{
 
379
    QRect cr(r);
 
380
 
 
381
    if (d_data->bgStyle & BgTrough)
 
382
    {
 
383
        qDrawShadePanel(p, r.x(), r.y(),
 
384
            r.width(), r.height(),
 
385
#if QT_VERSION < 0x040000
 
386
            colorGroup(), 
 
387
#else
 
388
            palette(), 
 
389
#endif
 
390
            true, d_data->borderWidth,0);
 
391
 
 
392
        cr.setRect(r.x() + d_data->borderWidth,
 
393
            r.y() + d_data->borderWidth,
 
394
            r.width() - 2 * d_data->borderWidth,
 
395
            r.height() - 2 * d_data->borderWidth);
 
396
 
 
397
        p->fillRect(cr.x(), cr.y(), cr.width(), cr.height(), 
 
398
#if QT_VERSION < 0x040000
 
399
            colorGroup().brush(QColorGroup::Mid)
 
400
#else
 
401
            palette().brush(QPalette::Mid)
 
402
#endif
 
403
        );
 
404
    }
 
405
 
 
406
    if ( d_data->bgStyle & BgSlot)
 
407
    {
 
408
        int ws = 4;
 
409
        int ds = d_data->thumbLength / 2 - 4;
 
410
        if ( ds < 1 )
 
411
            ds = 1;
 
412
 
 
413
        QRect rSlot;
 
414
        if (orientation() == Qt::Horizontal)
 
415
        {
 
416
            if ( cr.height() & 1 )
 
417
                ws++;
 
418
            rSlot = QRect(cr.x() + ds, 
 
419
                    cr.y() + (cr.height() - ws) / 2,
 
420
                    cr.width() - 2 * ds, ws);
 
421
        }
 
422
        else
 
423
        {
 
424
            if ( cr.width() & 1 )
 
425
                ws++;
 
426
            rSlot = QRect(cr.x() + (cr.width() - ws) / 2, 
 
427
                    cr.y() + ds,
 
428
                    ws, cr.height() - 2 * ds);
 
429
        }
 
430
        p->fillRect(rSlot.x(), rSlot.y(), rSlot.width(), rSlot.height(),
 
431
#if QT_VERSION < 0x040000
 
432
            colorGroup().brush(QColorGroup::Dark)
 
433
#else
 
434
            palette().brush(QPalette::Dark)
 
435
#endif
 
436
        );
 
437
        qDrawShadePanel(p, rSlot.x(), rSlot.y(),
 
438
            rSlot.width(), rSlot.height(), 
 
439
#if QT_VERSION < 0x040000
 
440
            colorGroup(), 
 
441
#else
 
442
            palette(), 
 
443
#endif
 
444
            true, 1 ,0);
 
445
 
 
446
    }
 
447
 
 
448
    if ( isValid() )
 
449
        drawThumb(p, cr, xyPosition(value()));
 
450
}
 
451
 
 
452
//! Draw the thumb at a position
 
453
void QwtSlider::drawThumb(QPainter *p, const QRect &sliderRect, int pos)
 
454
{
 
455
    pos++; // shade line points one pixel below
 
456
    if (orientation() == Qt::Horizontal)
 
457
    {
 
458
        qDrawShadePanel(p, pos - d_data->thumbLength / 2, 
 
459
            sliderRect.y(), d_data->thumbLength, sliderRect.height(),
 
460
#if QT_VERSION < 0x040000
 
461
            colorGroup(), 
 
462
#else
 
463
            palette(), 
 
464
#endif
 
465
            false, d_data->borderWidth, 
 
466
#if QT_VERSION < 0x040000
 
467
            &colorGroup().brush(QColorGroup::Button)
 
468
#else
 
469
            &palette().brush(QPalette::Button)
 
470
#endif
 
471
        );
 
472
 
 
473
        qDrawShadeLine(p, pos, sliderRect.y(), 
 
474
            pos, sliderRect.y() + sliderRect.height() - 2, 
 
475
#if QT_VERSION < 0x040000
 
476
            colorGroup(), 
 
477
#else
 
478
            palette(), 
 
479
#endif
 
480
            true, 1);
 
481
    }
 
482
    else // Vertical
 
483
    {
 
484
        qDrawShadePanel(p,sliderRect.x(), pos - d_data->thumbLength / 2, 
 
485
            sliderRect.width(), d_data->thumbLength,
 
486
#if QT_VERSION < 0x040000
 
487
            colorGroup(),
 
488
#else
 
489
            palette(), 
 
490
#endif
 
491
            false, d_data->borderWidth, 
 
492
#if QT_VERSION < 0x040000
 
493
            &colorGroup().brush(QColorGroup::Button)
 
494
#else
 
495
            &palette().brush(QPalette::Button)
 
496
#endif
 
497
        );
 
498
 
 
499
        qDrawShadeLine(p, sliderRect.x(), pos,
 
500
            sliderRect.x() + sliderRect.width() - 2, pos, 
 
501
#if QT_VERSION < 0x040000
 
502
            colorGroup(), 
 
503
#else
 
504
            palette(), 
 
505
#endif
 
506
            true, 1);
 
507
    }
 
508
}
 
509
 
 
510
//! Find the x/y position for a given value v
 
511
int QwtSlider::xyPosition(double v) const
 
512
{
 
513
    return d_data->map.transform(v);
 
514
}
 
515
 
 
516
//! Determine the value corresponding to a specified mouse location.
 
517
double QwtSlider::getValue(const QPoint &p)
 
518
{
 
519
    return d_data->map.invTransform(
 
520
        orientation() == Qt::Horizontal ? p.x() : p.y());
 
521
}
 
522
 
 
523
 
 
524
/*!
 
525
  \brief Determine scrolling mode and direction
 
526
  \param p point
 
527
  \param scrollMode Scrolling mode
 
528
  \param direction Direction
 
529
*/
 
530
void QwtSlider::getScrollMode(const QPoint &p, 
 
531
    int &scrollMode, int &direction )
 
532
{
 
533
    if (!d_data->sliderRect.contains(p))
 
534
    {
 
535
        scrollMode = ScrNone;
 
536
        direction = 0;
 
537
        return;
 
538
    }
 
539
 
 
540
    const int pos = ( orientation() == Qt::Horizontal ) ? p.x() : p.y();
 
541
    const int markerPos = xyPosition(value());
 
542
 
 
543
    if ((pos > markerPos - d_data->thumbLength / 2)
 
544
        && (pos < markerPos + d_data->thumbLength / 2))
 
545
    {
 
546
        scrollMode = ScrMouse;
 
547
        direction = 0;
 
548
        return;
 
549
    }
 
550
 
 
551
    scrollMode = ScrPage;
 
552
    direction = (pos > markerPos) ? 1 : -1;
 
553
 
 
554
    if ( scaleDraw()->map().p1() > scaleDraw()->map().p2() )
 
555
        direction = -direction;
 
556
}
 
557
 
 
558
//! Qt paint event
 
559
void QwtSlider::paintEvent(QPaintEvent *e)
 
560
{
 
561
    const QRect &ur = e->rect();
 
562
    if ( ur.isValid() )
 
563
    {
 
564
#if QT_VERSION < 0x040000
 
565
        QwtPaintBuffer paintBuffer(this, ur);
 
566
        draw(paintBuffer.painter(), ur);
 
567
#else
 
568
        QPainter painter(this);
 
569
        draw(&painter, ur);
 
570
#endif
 
571
    }
 
572
}
 
573
 
 
574
//! Draw the QwtSlider
 
575
void QwtSlider::draw(QPainter *painter, const QRect&)
 
576
{
 
577
    if (d_data->scalePos != NoScale)
 
578
    {
 
579
#if QT_VERSION < 0x040000
 
580
        scaleDraw()->draw(painter, colorGroup());
 
581
#else
 
582
        scaleDraw()->draw(painter, palette());
 
583
#endif
 
584
    }
 
585
 
 
586
    drawSlider(painter, d_data->sliderRect);
 
587
 
 
588
    if ( hasFocus() )
 
589
        QwtPainter::drawFocusRect(painter, this, d_data->sliderRect);
 
590
}
 
591
 
 
592
//! Qt resize event
 
593
void QwtSlider::resizeEvent(QResizeEvent *)
 
594
{
 
595
    layoutSlider( false );
 
596
}
 
597
 
 
598
/*!
 
599
  Recalculate the slider's geometry and layout based on
 
600
  the current rect and fonts.
 
601
  \param update_geometry  notify the layout system and call update
 
602
         to redraw the scale
 
603
*/
 
604
void QwtSlider::layoutSlider( bool update_geometry )
 
605
{
 
606
    int sliderWidth = d_data->thumbWidth;
 
607
    int sld1 = d_data->thumbLength / 2 - 1;
 
608
    int sld2 = d_data->thumbLength / 2 + d_data->thumbLength % 2;
 
609
    if ( d_data->bgStyle & BgTrough )
 
610
    {
 
611
        sliderWidth += 2 * d_data->borderWidth;
 
612
        sld1 += d_data->borderWidth;
 
613
        sld2 += d_data->borderWidth;
 
614
    }
 
615
 
 
616
    int scd = 0;
 
617
    if ( d_data->scalePos != NoScale )
 
618
    {
 
619
        int d1, d2;
 
620
        scaleDraw()->getBorderDistHint(font(), d1, d2);
 
621
        scd = qwtMax(d1, d2);
 
622
    }
 
623
 
 
624
    int slo = scd - sld1;
 
625
    if ( slo < 0 )
 
626
        slo = 0;
 
627
 
 
628
    int x, y, length;
 
629
 
 
630
    const QRect r = rect();
 
631
    if (orientation() == Qt::Horizontal)
 
632
    {
 
633
        switch (d_data->scalePos)
 
634
        {
 
635
            case TopScale:
 
636
            {
 
637
                d_data->sliderRect.setRect(
 
638
                    r.x() + d_data->xMargin + slo,
 
639
                    r.y() + r.height() -
 
640
                    d_data->yMargin - sliderWidth,
 
641
                    r.width() - 2 * d_data->xMargin - 2 * slo,
 
642
                    sliderWidth);
 
643
 
 
644
                x = d_data->sliderRect.x() + sld1;
 
645
                y = d_data->sliderRect.y() - d_data->scaleDist;
 
646
 
 
647
                break;
 
648
            }
 
649
 
 
650
            case BottomScale:
 
651
            {
 
652
                d_data->sliderRect.setRect(
 
653
                    r.x() + d_data->xMargin + slo,
 
654
                    r.y() + d_data->yMargin,
 
655
                    r.width() - 2 * d_data->xMargin - 2 * slo,
 
656
                    sliderWidth);
 
657
    
 
658
                x = d_data->sliderRect.x() + sld1;
 
659
                y = d_data->sliderRect.y() + d_data->sliderRect.height() 
 
660
                    + d_data->scaleDist;
 
661
 
 
662
                break;
 
663
            }
 
664
 
 
665
            case NoScale: // like Bottom, but no scale. See QwtSlider().
 
666
            default:   // inconsistent orientation and scale position
 
667
            {
 
668
                d_data->sliderRect.setRect(
 
669
                    r.x() + d_data->xMargin + slo,
 
670
                    r.y() + d_data->yMargin,
 
671
                    r.width() - 2 * d_data->xMargin - 2 * slo,
 
672
                    sliderWidth);
 
673
 
 
674
                x = d_data->sliderRect.x() + sld1;
 
675
                y = 0;
 
676
 
 
677
                break;
 
678
            }
 
679
        }
 
680
        length = d_data->sliderRect.width() - (sld1 + sld2);
 
681
    }
 
682
    else // if (orientation() == Qt::Vertical
 
683
    {
 
684
        switch (d_data->scalePos)
 
685
        {
 
686
            case RightScale:
 
687
                d_data->sliderRect.setRect(
 
688
                    r.x() + d_data->xMargin,
 
689
                    r.y() + d_data->yMargin + slo,
 
690
                    sliderWidth,
 
691
                    r.height() - 2 * d_data->yMargin - 2 * slo);
 
692
 
 
693
                x = d_data->sliderRect.x() + d_data->sliderRect.width() 
 
694
                    + d_data->scaleDist;
 
695
                y = d_data->sliderRect.y() + sld1;
 
696
 
 
697
                break;
 
698
 
 
699
            case LeftScale:
 
700
                d_data->sliderRect.setRect(
 
701
                    r.x() + r.width() - sliderWidth - d_data->xMargin,
 
702
                    r.y() + d_data->yMargin + slo,
 
703
                    sliderWidth,
 
704
                    r.height() - 2 * d_data->yMargin - 2 * slo);
 
705
 
 
706
                x = d_data->sliderRect.x() - d_data->scaleDist;
 
707
                y = d_data->sliderRect.y() + sld1;
 
708
 
 
709
                break;
 
710
 
 
711
            case NoScale: // like Left, but no scale. See QwtSlider().
 
712
            default:   // inconsistent orientation and scale position
 
713
                d_data->sliderRect.setRect(
 
714
                    r.x() + r.width() - sliderWidth - d_data->xMargin,
 
715
                    r.y() + d_data->yMargin + slo,
 
716
                    sliderWidth,
 
717
                    r.height() - 2 * d_data->yMargin - 2 * slo);
 
718
 
 
719
                x = 0;
 
720
                y = d_data->sliderRect.y() + sld1;
 
721
 
 
722
                break;
 
723
        }
 
724
        length = d_data->sliderRect.height() - (sld1 + sld2);
 
725
    }
 
726
 
 
727
    scaleDraw()->move(x, y);
 
728
    scaleDraw()->setLength(length);
 
729
 
 
730
    d_data->map.setPaintXInterval(scaleDraw()->map().p1(),
 
731
        scaleDraw()->map().p2());
 
732
 
 
733
    if ( update_geometry )
 
734
    {
 
735
        d_data->sizeHintCache = QSize(); // invalidate
 
736
        updateGeometry();
 
737
        update();
 
738
    }
 
739
}
 
740
 
 
741
//! Notify change of value
 
742
void QwtSlider::valueChange()
 
743
{
 
744
    QwtAbstractSlider::valueChange();
 
745
    update();
 
746
}
 
747
 
 
748
 
 
749
//! Notify change of range
 
750
void QwtSlider::rangeChange()
 
751
{
 
752
    d_data->map.setScaleInterval(minValue(), maxValue());
 
753
 
 
754
    if (autoScale())
 
755
        rescale(minValue(), maxValue());
 
756
 
 
757
    QwtAbstractSlider::rangeChange();
 
758
    layoutSlider();
 
759
}
 
760
 
 
761
/*!
 
762
  \brief Set distances between the widget's border and internals.
 
763
  \param xMargin Horizontal margin
 
764
  \param yMargin Vertical margin
 
765
*/
 
766
void QwtSlider::setMargins(int xMargin, int yMargin)
 
767
{
 
768
    if ( xMargin < 0 )
 
769
        xMargin = 0;
 
770
    if ( yMargin < 0 )
 
771
        yMargin = 0;
 
772
 
 
773
    if ( xMargin != d_data->xMargin || yMargin != d_data->yMargin )
 
774
    {
 
775
        d_data->xMargin = xMargin;
 
776
        d_data->yMargin = yMargin;
 
777
        layoutSlider();
 
778
    }
 
779
}
 
780
 
 
781
/*!
 
782
  Set the background style.
 
783
*/
 
784
void QwtSlider::setBgStyle(BGSTYLE st) 
 
785
{
 
786
    d_data->bgStyle = st; 
 
787
    layoutSlider();
 
788
}
 
789
 
 
790
/*!
 
791
  \return the background style.
 
792
*/
 
793
QwtSlider::BGSTYLE QwtSlider::bgStyle() const 
 
794
{ 
 
795
    return d_data->bgStyle; 
 
796
}
 
797
 
 
798
/*!
 
799
  \return the thumb length.
 
800
*/
 
801
int QwtSlider::thumbLength() const 
 
802
{
 
803
    return d_data->thumbLength;
 
804
}
 
805
 
 
806
/*!
 
807
  \return the thumb width.
 
808
*/
 
809
int QwtSlider::thumbWidth() const 
 
810
{
 
811
    return d_data->thumbWidth;
 
812
}
 
813
 
 
814
/*!
 
815
  \return the border width.
 
816
*/
 
817
int QwtSlider::borderWidth() const 
 
818
{
 
819
    return d_data->borderWidth;
 
820
}
 
821
 
 
822
/*!
 
823
  \return QwtSlider::minimumSizeHint()
 
824
*/
 
825
QSize QwtSlider::sizeHint() const
 
826
{
 
827
    return minimumSizeHint();
 
828
}
 
829
 
 
830
/*!
 
831
  \brief Return a minimum size hint
 
832
  \warning The return value of QwtSlider::minimumSizeHint() depends on 
 
833
           the font and the scale.
 
834
*/
 
835
QSize QwtSlider::minimumSizeHint() const
 
836
{
 
837
    if (!d_data->sizeHintCache.isEmpty()) 
 
838
        return d_data->sizeHintCache;
 
839
 
 
840
    int sliderWidth = d_data->thumbWidth;
 
841
    if (d_data->bgStyle & BgTrough)
 
842
        sliderWidth += 2 * d_data->borderWidth;
 
843
 
 
844
    int w = 0, h = 0;
 
845
    if (d_data->scalePos != NoScale)
 
846
    {
 
847
        int d1, d2;
 
848
        scaleDraw()->getBorderDistHint(font(), d1, d2);
 
849
        int msMbd = qwtMax(d1, d2);
 
850
 
 
851
        int mbd = d_data->thumbLength / 2;
 
852
        if (d_data->bgStyle & BgTrough)
 
853
            mbd += d_data->borderWidth;
 
854
 
 
855
        if ( mbd < msMbd )
 
856
            mbd = msMbd;
 
857
 
 
858
        const int sdExtent = scaleDraw()->extent( QPen(), font() );
 
859
        const int sdLength = scaleDraw()->minLength( QPen(), font() );
 
860
 
 
861
        h = sliderWidth + sdExtent + d_data->scaleDist;
 
862
        w = sdLength - 2 * msMbd + 2 * mbd;
 
863
    }
 
864
    else  // no scale
 
865
    {
 
866
        w = 200;
 
867
        h = sliderWidth;
 
868
    }
 
869
 
 
870
    if ( orientation() == Qt::Vertical )
 
871
        qSwap(w, h);
 
872
 
 
873
    w += 2 * d_data->xMargin;
 
874
    h += 2 * d_data->yMargin;
 
875
 
 
876
    d_data->sizeHintCache = QSize(w, h);
 
877
    return d_data->sizeHintCache;
 
878
}