← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/muse/oneiric

« back to all changes in this revision

Viewing changes to widgets/scrollscale.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Kobras
  • Date: 2002-04-23 17:28:23 UTC
  • Revision ID: james.westby@ubuntu.com-20020423172823-w8yplzr81a759xa3
Tags: upstream-0.5.2
Import upstream version 0.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
widgets/scrollscale.cpp
 
1
//=========================================================
 
2
//  MusE
 
3
//  Linux Music Editor
 
4
//    $Id: scrollscale.cpp,v 1.1 2002/01/30 14:54:04 muse Exp $
 
5
//  (C) Copyright 1999 Werner Schweer (ws@seh.de)
 
6
//=========================================================
 
7
 
 
8
#include <stdio.h>
 
9
#include <math.h>
 
10
#include <qslider.h>
 
11
#include <qscrollbar.h>
 
12
#include <qlayout.h>
 
13
#include <qtoolbutton.h>
 
14
#include <qtooltip.h>
 
15
#include <qlabel.h>
 
16
 
 
17
// #include "globals.h"
 
18
#include "scrollscale.h"
 
19
#include "icons.h"
 
20
 
 
21
//---------------------------------------------------------
 
22
//   setScale
 
23
//    "val" - slider value in range 0-1024
 
24
//---------------------------------------------------------
 
25
 
 
26
void ScrollScale::setScale(int val)
 
27
      {
 
28
      if (invers)
 
29
            val = 1024 - val;
 
30
      double min, max;
 
31
      if (scaleMin < 0)
 
32
            min = 1.0/(-scaleMin);
 
33
      else
 
34
            min = double(scaleMin);
 
35
 
 
36
      if (scaleMax < 0)
 
37
            max = 1.0/(-scaleMax);
 
38
      else
 
39
            max = double(scaleMax);
 
40
 
 
41
      double diff = max-min;
 
42
      double fkt  = double(val)/1024.0;
 
43
      double v = (pow(logbase, fkt)-1)/(logbase-1);
 
44
      double scale;
 
45
      if (invers)
 
46
            scale = max - v * diff;
 
47
      else
 
48
            scale = min + v * diff;
 
49
 
 
50
      if (scale < 1.0)
 
51
            scaleVal = -(int(1.0 / scale));
 
52
      else
 
53
            scaleVal = int(scale);
 
54
      if (scaleVal == -1)     // nur so
 
55
            scaleVal = 1;
 
56
 
 
57
#if 0
 
58
      if (scaleMax > scaleMin) {
 
59
            if (scale < scaleMin)
 
60
                  scale = scaleMin;
 
61
            else if (scale > scaleMax)
 
62
                  scale = scaleMax;
 
63
            }
 
64
      else {
 
65
            if (scale < scaleMax)
 
66
                  scale = scaleMax;
 
67
            else if (scale > scaleMin)
 
68
                  scale = scaleMin;
 
69
            }
 
70
#endif
 
71
 
 
72
      int sval = scroll->value();
 
73
      emit scaleChanged(scaleVal);
 
74
      if (!noScale)
 
75
            setRange(minVal, maxVal);
 
76
      setPos(sval);
 
77
      }
 
78
 
 
79
//---------------------------------------------------------
 
80
//   setMag
 
81
//---------------------------------------------------------
 
82
 
 
83
void ScrollScale::setMag(int cs)
 
84
      {
 
85
      scale->setValue(cs);
 
86
      setScale(cs);
 
87
      }
 
88
 
 
89
//---------------------------------------------------------
 
90
//   setRange
 
91
//    min,max  ticks
 
92
//---------------------------------------------------------
 
93
 
 
94
void ScrollScale::setRange(int min, int max)
 
95
      {
 
96
//      if ((min != minVal) && (max != maxVal))
 
97
//            return;
 
98
      minVal = min;
 
99
      maxVal = max;
 
100
      int i = (scroll->orientation() == Horizontal) ? width() : height();
 
101
 
 
102
      if (!noScale) {
 
103
            if (scaleVal < 1) {
 
104
                  min = minVal / (-scaleVal);
 
105
                  max = (maxVal-scaleVal-1) / (-scaleVal) - i;
 
106
                  }
 
107
            else {
 
108
                  min = minVal * scaleVal;
 
109
                  max = maxVal * scaleVal - i;
 
110
                  }
 
111
            }
 
112
      else
 
113
            max -= i;
 
114
      if (max < 0)
 
115
            max = 0;
 
116
      if (min < 0)
 
117
            min = 0;
 
118
      if (min > max)
 
119
            max = min;
 
120
      scroll->setRange(min, max);
 
121
 
 
122
      // qt doesn't check this...
 
123
      if (scroll->value() < min)
 
124
            scroll->setValue(min);
 
125
      if (scroll->value() > max)
 
126
        scroll->setValue(max);
 
127
      scroll->setSteps(20, i);
 
128
      }
 
129
 
 
130
//---------------------------------------------------------
 
131
//   setPos
 
132
//    pos in pixel
 
133
//---------------------------------------------------------
 
134
 
 
135
void ScrollScale::setPos(int pos)
 
136
      {
 
137
      scroll->setValue(pos);
 
138
      }
 
139
 
 
140
//---------------------------------------------------------
 
141
//   resizeEvent
 
142
//---------------------------------------------------------
 
143
 
 
144
void ScrollScale::resizeEvent(QResizeEvent*)
 
145
      {
 
146
      setScale(scale->value());
 
147
      }
 
148
 
 
149
//---------------------------------------------------------
 
150
//   ScrollScale
 
151
//---------------------------------------------------------
 
152
 
 
153
ScrollScale::ScrollScale(int s1, int s2, int cs, int max, Orientation o,
 
154
   QWidget* parent, int min=0, bool inv=false, double bas=10.0)
 
155
   : QWidget(parent)
 
156
      {
 
157
      noScale     = false;
 
158
      _page        = 0;
 
159
      _pages       = 1;
 
160
      pageButtons = false;
 
161
      showMagFlag = true;
 
162
      scaleMin    = s1;
 
163
      scaleMax    = s2;
 
164
      minVal      = min;
 
165
      maxVal      = max;
 
166
      up          = 0;
 
167
      down        = 0;
 
168
      logbase     = bas;
 
169
      invers      = inv;
 
170
 
 
171
      double min, max;
 
172
      if (scaleMin < 0)
 
173
            min = 1.0/(-scaleMin);
 
174
      else
 
175
            min = double(scaleMin);
 
176
 
 
177
      if (scaleMax < 0)
 
178
            max = 1.0/(-scaleMax);
 
179
      else
 
180
            max = double(scaleMax);
 
181
 
 
182
      double cmag = (cs < 0) ? (1.0/(-cs)) : double(cs);
 
183
      double diff = max-min;
 
184
 
 
185
      //
 
186
      // search initial value for slider
 
187
      //
 
188
      int cur   = 512;
 
189
      int delta = 256;
 
190
      for (int i = 0; i < 8; ++i) {
 
191
            int tryVal   = invers ? 1025 - cur : cur;
 
192
            double fkt   = double(tryVal)/1024.0;
 
193
            double v     = (pow(logbase, fkt)-1)/(logbase-1);
 
194
            double scale = invers ? (max - v * diff) : (min + v * diff);
 
195
            if (scale == cmag)   // not very likely
 
196
                  break;
 
197
// printf("iteration %d invers:%d soll %f(cur:%d) - ist %f\n", i, invers, scale, cur, cmag);
 
198
            int dd = invers ? -delta : delta;
 
199
            cur += (scale < cmag) ? dd : -dd;
 
200
            delta/=2;
 
201
            }
 
202
 
 
203
      scale  = new QSlider(0, 1024, 1, cur, o, this);
 
204
      scroll = new QScrollBar(o, this);
 
205
      setScale(cur);
 
206
 
 
207
      if (o == Horizontal) {
 
208
            box = new QBoxLayout(this, QBoxLayout::LeftToRight);
 
209
            scale->setFixedHeight(18);
 
210
            scroll->setFixedHeight(18);
 
211
            scale->setMaximumWidth(70);
 
212
            scroll->setMinimumWidth(50);
 
213
            }
 
214
      else {
 
215
            box = new QBoxLayout(this, QBoxLayout::Down);
 
216
            scale->setFixedWidth(18);
 
217
            scroll->setFixedWidth(18);
 
218
            scroll->setMinimumHeight(50);
 
219
            scale->setMaximumHeight(70);
 
220
            }
 
221
      box->addWidget(scroll, 10);
 
222
      box->addWidget(scale, 5);
 
223
      connect(scale, SIGNAL(valueChanged(int)), SLOT(setScale(int)));
 
224
      connect(scale, SIGNAL(valueChanged(int)), SIGNAL(lscaleChanged(int)));
 
225
      connect(scroll, SIGNAL(valueChanged(int)), SIGNAL(scrollChanged(int)));
 
226
      }
 
227
 
 
228
//---------------------------------------------------------
 
229
//   setPageButtons
 
230
//---------------------------------------------------------
 
231
 
 
232
void ScrollScale::setPageButtons(bool flag)
 
233
      {
 
234
      if (flag == pageButtons)
 
235
            return;
 
236
 
 
237
      if (flag) {
 
238
            if (up == 0) {
 
239
                  up = new QToolButton(this);
 
240
                  up->setPixmap(*(upIcon));
 
241
                  down = new QToolButton(this);
 
242
                  down->setPixmap(*(downIcon));
 
243
                  pageNo = new QLabel(this);
 
244
                  QString s;
 
245
                  s.setNum(_page+1);
 
246
                  pageNo->setText(s);
 
247
                  QToolTip::add(down, tr("next page"));
 
248
                  QToolTip::add(up, tr("previous page"));
 
249
                  QToolTip::add(pageNo, tr("current page number"));
 
250
                  box->insertWidget(1, up);
 
251
                  box->insertWidget(2, down);
 
252
                  box->insertSpacing(3, 5);
 
253
                  box->insertWidget(4, pageNo);
 
254
                  box->insertSpacing(5, 5);
 
255
                  connect(up, SIGNAL(clicked()), SLOT(pageUp()));
 
256
                  connect(down, SIGNAL(clicked()), SLOT(pageDown()));
 
257
                  }
 
258
            up->show();
 
259
            down->show();
 
260
            pageNo->show();
 
261
            if (_page == (_pages-1))
 
262
                  down->setEnabled(false);
 
263
            if (_page == 0)
 
264
                  up->setEnabled(false);
 
265
            }
 
266
      else {
 
267
            up->hide();
 
268
            down->hide();
 
269
            }
 
270
      pageButtons = flag;
 
271
      }
 
272
 
 
273
//---------------------------------------------------------
 
274
//   showMag
 
275
//---------------------------------------------------------
 
276
 
 
277
void ScrollScale::showMag(bool flag)
 
278
      {
 
279
      showMagFlag = flag;
 
280
      if (flag)
 
281
            scale->show();
 
282
      else
 
283
            scale->hide();
 
284
      box->activate();
 
285
      }
 
286
 
 
287
//---------------------------------------------------------
 
288
//   setOffset
 
289
//    val in tick
 
290
//---------------------------------------------------------
 
291
 
 
292
void ScrollScale::setOffset(int val)
 
293
      {
 
294
      int i = (scroll->orientation() == Horizontal) ? width() : height();
 
295
      int pos, max;
 
296
 
 
297
      if (scaleVal < 1) {
 
298
            pos = (val-scaleVal/2) / (-scaleVal);
 
299
            max = (maxVal-scaleVal-1) / (-scaleVal) - i;
 
300
            }
 
301
      else {
 
302
            pos = val * scaleVal;
 
303
            max = maxVal * scaleVal - i;
 
304
            }
 
305
      if (pos > max) {
 
306
            int min;
 
307
            if (scaleVal < 1) {
 
308
                  maxVal  = (pos + width()) * (-scaleVal);
 
309
                  min = (minVal-scaleVal/2) / (-scaleVal);
 
310
                  max     = (maxVal-scaleVal/2) / (-scaleVal) - i;
 
311
                  }
 
312
            else {
 
313
                  maxVal  = (pos + width() + scaleVal/2)/scaleVal;
 
314
                  min = minVal * scaleVal;
 
315
                  max     = maxVal * scaleVal - i;
 
316
                  }
 
317
 
 
318
            if (max < 0)
 
319
                  max = 0;
 
320
            if (min < 0)
 
321
                  min = 0;
 
322
            if (min > max)
 
323
                  max = min;
 
324
            scroll->setRange(min, max);
 
325
            }
 
326
      setPos(pos);
 
327
      }
 
328
 
 
329
//---------------------------------------------------------
 
330
//   pageUp
 
331
//    goto previous page
 
332
//---------------------------------------------------------
 
333
 
 
334
void ScrollScale::pageUp()
 
335
      {
 
336
      if (_page) {
 
337
            --_page;
 
338
            emit newPage(_page);
 
339
            QString s;
 
340
            s.setNum(_page+1);
 
341
            pageNo->setText(s);
 
342
            if (_page == 0)
 
343
                  up->setEnabled(false);
 
344
            if (_page == (_pages-2))
 
345
                  down->setEnabled(true);
 
346
            }
 
347
      }
 
348
 
 
349
//---------------------------------------------------------
 
350
//   pageDown
 
351
//    goto next page
 
352
//---------------------------------------------------------
 
353
 
 
354
void ScrollScale::pageDown()
 
355
      {
 
356
      if (_page + 1 < _pages) {
 
357
            ++_page;
 
358
            emit newPage(_page);
 
359
            QString s;
 
360
            s.setNum(_page+1);
 
361
            pageNo->setText(s);
 
362
            if (_page == (_pages-1))
 
363
                  down->setEnabled(false);
 
364
            if (_page == 1)
 
365
                  up->setEnabled(true);
 
366
            }
 
367
      }
 
368
 
 
369
//---------------------------------------------------------
 
370
//   setPages
 
371
//---------------------------------------------------------
 
372
 
 
373
void ScrollScale::setPages(int n)
 
374
      {
 
375
      _pages = n;
 
376
      if (_page >= _pages) {
 
377
            _page = _pages-1;
 
378
            emit newPage(_page);
 
379
            QString s;
 
380
            s.setNum(_page+1);
 
381
            pageNo->setText(s);
 
382
            }
 
383
      up->setEnabled(_page);
 
384
      down->setEnabled(_page < (_pages-1));
 
385
      }
 
386
 
 
387
int ScrollScale::pos() const
 
388
      {
 
389
      return scroll->value();
 
390
      }
 
391
 
 
392
int ScrollScale::mag() const
 
393
      {
 
394
      return scale->value();
 
395
      }
 
396