Subversion Repositories Scribus

Rev

Rev 4013 | Rev 4110 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3 paul 1
/***************************************************************************
2
                          mspinbox.cpp  -  description
3
                             -------------------
4
    begin                : Sat Jun 16 2001
5
    copyright            : (C) 2001 by Franz Schmid
6
    email                : Franz.Schmid@altmuehlnet.de
7
 ***************************************************************************/
8
 
9
/***************************************************************************
10
 *                                                                         *
11
 *   This program is free software; you can redistribute it and/or modify  *
12
 *   it under the terms of the GNU General Public License as published by  *
13
 *   the Free Software Foundation; either version 2 of the License, or     *
14
 *   (at your option) any later version.                                   *
15
 *                                                                         *
16
 ***************************************************************************/
17
 
18
#include "mspinbox.h"
280 Franz 19
#include "mspinbox.moc"
137 Franz 20
#include <qapplication.h>
333 Franz 21
#include <qlineedit.h>
1568 cbradney 22
#include <cmath>
137 Franz 23
#include "fparser.h"
1568 cbradney 24
#include "units.h"
3 paul 25
 
146 Franz 26
/*!
27
 \fn MSpinBox(QWidget *pa, int s)
28
 \author Franz Schmid
29
 \date
30
 \brief Constructor
31
 \param pa Parent Widget
32
 \param s Number of Decimals
33
 \retval None
34
 */
35
 
3 paul 36
MSpinBox::MSpinBox(QWidget *pa, int s):QSpinBox(pa)
37
{
333 Franz 38
        setParameters(s);
39
        setValidator(0);
40
        ed = editor();
41
        QSpinBox::setLineStep(Decimals);
42
        oldLineStep=0;
43
        readOnly=false;
1617 fschmid 44
        edited = false;
45
    connect( ed, SIGNAL(textChanged(const QString&)), SLOT(textChanged()) );
333 Franz 46
}
47
/*!
48
 \fn MSpinBox(double minValue, double maxValue, QWidget *pa, int s)
49
 \author Franz Schmid
50
 \date
51
 \brief Constructor
52
 \param pa Parent Widget
53
 \param s Number of Decimals
54
 \retval None
55
 */
56
 
57
MSpinBox::MSpinBox(double minValue, double maxValue, QWidget *pa, int s):QSpinBox(pa)
58
{
59
        setParameters(s);
60
        setValidator(0);
61
        ed = editor();
62
        QSpinBox::setLineStep(Decimals);
63
        oldLineStep=0;
64
        setMinValue(minValue);
65
        setMaxValue(maxValue);
66
        readOnly=false;
1617 fschmid 67
        edited = false;
68
    connect( ed, SIGNAL(textChanged(const QString&)), SLOT(textChanged()) );
333 Franz 69
}
70
 
71
void MSpinBox::setParameters( int s )
72
{
1795 cbradney 73
        if (s>=0 && s <=unitGetMaxIndex())
161 Franz 74
        {
1568 cbradney 75
                Width=s;
1569 fschmid 76
                Decimals=static_cast<int>(pow(10, s));
161 Franz 77
        }
1568 cbradney 78
        else
79
        {
80
                Width = 2;
81
                Decimals = 100;
82
        }
1617 fschmid 83
        edited = false;
3 paul 84
}
85
 
86
bool MSpinBox::eventFilter( QObject* ob, QEvent* ev )
87
{
2680 cbradney 88
        bool retval = false;
3 paul 89
        if ( ev->type() == QEvent::KeyPress )
161 Franz 90
        {
3 paul 91
                QKeyEvent* k = (QKeyEvent*)ev;
92
                if (k->key() == Key_Shift)
161 Franz 93
                {
138 Franz 94
                        setLineStep(QMAX(Decimals / 10, 1));
3 paul 95
                        retval = true;
161 Franz 96
                    qApp->sendEvent( this, ev );
3 paul 97
                        return retval;
98
                }
3736 fschmid 99
                else if (k->key() == Key_Control)
100
                {
101
                        setLineStep(QMAX(Decimals * 10, 1));
102
                        retval = true;
103
                    qApp->sendEvent( this, ev );
104
                        return retval;
105
                }
161 Franz 106
        }
3736 fschmid 107
        if (ev->type() == QEvent::KeyRelease )
161 Franz 108
        {
3 paul 109
                QKeyEvent* k = (QKeyEvent*)ev;
3736 fschmid 110
                if ((k->key() == Key_Shift) || (k->key() == Key_Control))
161 Franz 111
                {
3 paul 112
                        setLineStep(Decimals);
113
                        retval = true;
161 Franz 114
                    qApp->sendEvent( this, ev );
3 paul 115
                        return retval;
364 Franz 116
                }
117
        }
118
        if ( ev->type() == QEvent::Wheel )
119
        {
4013 cbradney 120
                //If read only dont spin
121
                if (readOnly)
122
                        return false;
364 Franz 123
                QWheelEvent* k = (QWheelEvent*)ev;
4027 cbradney 124
                bool shiftB=k->state() & ShiftButton;
125
                bool controlB=k->state() & ControlButton;
126
                if (shiftB && !controlB)
364 Franz 127
                {
128
                        setLineStep(QMAX(Decimals / 10, 1));
129
                        retval = true;
130
                        qApp->sendEvent( this, ev );
131
                        return retval;
3736 fschmid 132
                }
4027 cbradney 133
                else if (!shiftB && controlB)
364 Franz 134
                {
3736 fschmid 135
                        setLineStep(QMAX(Decimals * 10, 1));
136
                        retval = true;
137
                    qApp->sendEvent( this, ev );
138
                        return retval;
139
                }
4027 cbradney 140
                else if (shiftB && controlB)
3736 fschmid 141
                {
4027 cbradney 142
                        setLineStep(QMAX(Decimals / 100, 1));
143
                        retval = true;
144
                    qApp->sendEvent( this, ev );
145
                        return retval;
146
                }
147
                else
148
                if (!shiftB && !controlB)
149
                {
364 Franz 150
                        setLineStep(Decimals);
151
                        retval = true;
152
                        qApp->sendEvent( this, ev );
153
                        return retval;
4027 cbradney 154
                }
161 Franz 155
        }
3 paul 156
        return QSpinBox::eventFilter(ob, ev);
157
}
158
 
159
QString MSpinBox::mapValueToText(int value)
160
{
139 Franz 161
        return QString::number(static_cast<double>(value) / Decimals, 'f', Width);
3 paul 162
}
163
 
146 Franz 164
/*!
165
 \fn MSpinBox::mapTextToValue(bool *)
166
 \author Franz Schmid
167
 \date
1617 fschmid 168
 \brief Maps the Text of the Spinbox to the Value, does Unit Conversion and Calculations
146 Franz 169
 \param None
170
 \retval The Value
171
 */
172
 
3 paul 173
int MSpinBox::mapTextToValue(bool *)
174
{
161 Franz 175
        FunctionParser fp;
138 Franz 176
        QString ts = text();
286 Franz 177
        QString su = suffix().stripWhiteSpace();
138 Franz 178
        ts.replace(",", ".");
272 Franz 179
        ts.replace("%", "");
2594 cbradney 180
        QString strPT=unitGetStrFromIndex(SC_PT);
181
        QString strMM=unitGetStrFromIndex(SC_MM);
182
        QString strIN=unitGetStrFromIndex(SC_IN);
183
        QString strP =unitGetStrFromIndex(SC_P);
184
        QString strCM=unitGetStrFromIndex(SC_CM);
185
        QString strC =unitGetStrFromIndex(SC_C);
1568 cbradney 186
 
2594 cbradney 187
        QString suffPT=unitGetSuffixFromIndex(SC_PT);
188
        QString suffMM=unitGetSuffixFromIndex(SC_MM);
189
        QString suffIN=unitGetSuffixFromIndex(SC_IN);
190
        QString suffP =unitGetSuffixFromIndex(SC_P);
191
        QString suffCM=unitGetSuffixFromIndex(SC_CM);
192
        QString suffC =unitGetSuffixFromIndex(SC_C);
1568 cbradney 193
 
194
        if ((su == suffPT) || (su == strPT))
161 Franz 195
        {
1568 cbradney 196
                ts.replace(strPT, "");
197
                ts.replace(strMM, "/25.4*72.0");
198
                ts.replace(strIN, "*72.0");
199
                ts.replace(strP, "*12.0");
200
                ts.replace(strCM, "/2.54*72.0");
2575 cbradney 201
                ts.replace(strC, "/25.4*72.0*4.512");
161 Franz 202
        }
203
        else
2575 cbradney 204
        if ((su == suffMM) || (su == strMM))
205
        {
206
                ts.replace(strPT, "/72.0*25.4");
207
                ts.replace(strMM, "");
208
                ts.replace(strIN, "*25.4");
209
                ts.replace(strP, "/6.0*25.4");
210
                ts.replace(strCM, "*10.0");
211
                ts.replace(strC, "*4.512");
212
        }
213
        else
214
        if ((su == suffIN) || (su == strIN))
215
        {
216
                ts.replace(strPT, "/72.0");
217
                ts.replace(strMM, "/25.4");
218
                ts.replace(strIN, "");
219
                ts.replace(strP, "/6.0");
220
                ts.replace(strCM, "/2.54");
221
                ts.replace(strC, "/25.4*4.512");
222
        }
223
        else
224
        if ((su == suffP) || (su == strP))
225
        {
226
                ts.replace(strPT, "/12");
227
                ts.replace(strMM, "/25.4*6");
228
                ts.replace(strIN, "*6");
229
                ts.replace(strP, "");
230
                ts.replace(strCM, "/2.54*6.0");
231
                ts.replace(strC, "*6.0/25.4*4.512");
232
        }
233
        else
234
        if ((su == suffCM) || (su == strCM))
235
        {
236
                ts.replace(strPT, "/72.0*2.54");
237
                ts.replace(strMM, "/10");
238
                ts.replace(strIN, "*2.54");
239
                ts.replace(strP, "/6.0*2.54");
240
                ts.replace(strCM, "");
241
                ts.replace(strC, "/10*4.512");
242
        }
243
        else
244
        if ((su == suffC) || (su == strC))
245
        {
246
                ts.replace(strPT, "*25.4/72.0/4.512");
247
                ts.replace(strMM, "/4.512");
248
                ts.replace(strIN, "*25.4/4.512");
249
                ts.replace(strP, "/6.0*25.4/4.512");
250
                ts.replace(strCM, "*10.0/4.512");
251
                ts.replace(strC, "");
252
        }
2877 cbradney 253
        if (!su.isEmpty())
286 Franz 254
                ts.replace(su, " ");
161 Franz 255
        int ret = fp.Parse(ts.latin1(), "", true);
137 Franz 256
        if (ret >= 0)
257
                return 0;
161 Franz 258
        double erg = fp.Eval(NULL);
139 Franz 259
        return qRound(erg*Decimals);
3 paul 260
}
261
 
1617 fschmid 262
void MSpinBox::textChanged()
263
{
264
        edited = true;
265
}
266
 
267
void MSpinBox::stepDown()
268
{
269
        if ( edited )
270
                QSpinBox::interpretText();
271
        if ( wrapping() && ( QSpinBox::value()-lineStep() < QSpinBox::minValue() ) )
272
                QSpinBox::setValue( QSpinBox::maxValue() - (QSpinBox::maxValue() % lineStep()));
273
        else
274
                QSpinBox::subtractLine();
275
}
276
 
333 Franz 277
void MSpinBox::setValues(double min, double max, int deci, double val)
278
{
279
        setDecimals(deci);
280
        setMinValue(min);
281
        setMaxValue(max);
282
        setValue(val);
1617 fschmid 283
        edited = false;
333 Franz 284
}
285
 
286
void MSpinBox::getValues(double *min, double *max, int *deci, double *val)
287
{
288
        *deci = Decimals;
289
        *min = static_cast<double>(QSpinBox::minValue()) / Decimals;
290
        *max = static_cast<double>(QSpinBox::maxValue()) / Decimals;
291
        *val = static_cast<double>(QSpinBox::value()) / Decimals;
292
}
293
 
3 paul 294
void MSpinBox::setDecimals(int deci)
295
{
296
        Decimals = deci;
146 Franz 297
        QSpinBox::setLineStep(Decimals);
138 Franz 298
        if (deci < 10)
299
                Width = 0;
199 Franz 300
        if ((deci > 9) && (deci < 100))
3 paul 301
                Width = 1;
199 Franz 302
        if ((deci > 99) && (deci < 1000))
3 paul 303
                Width = 2;
199 Franz 304
        if ((deci > 999) && (deci < 10000))
139 Franz 305
                Width = 3;
306
        if (deci > 9999)
307
                Width = 4;
3 paul 308
}
146 Franz 309
 
310
/*!
311
 \fn MSpinBox::setMaxValue()
312
 \author Franz Schmid
313
 \date
314
 \brief Sets the Maximum Value of the Spinbox
315
 \param val new Value
316
 \retval None
317
 */
318
 
319
void MSpinBox::setMaxValue(double val)
320
{
321
        QSpinBox::setMaxValue(qRound(val*Decimals));
322
}
323
 
324
/*!
325
 \fn MSpinBox::setMinValue()
326
 \author Franz Schmid
327
 \date
328
 \brief Sets the Minimum Value of the Spinbox
329
 \param val new Value
330
 \retval None
331
 */
332
 
333
void MSpinBox::setMinValue(double val)
334
{
335
        QSpinBox::setMinValue(qRound(val*Decimals));
336
}
337
 
338
/*!
339
 \fn MSpinBox::setValue()
340
 \author Franz Schmid
341
 \date
342
 \brief Sets the Value of the Spinbox
343
 \param val new Value
344
 \retval None
345
 */
346
 
347
void MSpinBox::setValue(double val)
348
{
349
        QSpinBox::setValue(qRound(val*Decimals));
1617 fschmid 350
        edited = false;
146 Franz 351
}
352
 
353
/*!
354
 \fn MSpinBox::value()
355
 \author Franz Schmid
356
 \date
357
 \brief Returns the current Value of the SpinBox
358
 \param None
359
 \retval The Value
360
 */
361
 
362
double MSpinBox::value()
363
{
364
        return static_cast<double>(QSpinBox::value()) / Decimals;
365
}
199 Franz 366
 
367
/*!
368
 \fn MSpinBox::minValue()
369
 \author Franz Schmid
370
 \date
371
 \brief Gets the Minimum Value of the Spinbox
372
 \param None
373
 \retval The Value
374
 */
375
 
376
double MSpinBox::minValue()
377
{
378
        return static_cast<double>(QSpinBox::minValue()) / Decimals;
379
}
380
 
381
/*!
382
 \fn MSpinBox::maxValue()
383
 \author Franz Schmid
384
 \date
385
 \brief Gets the Maximum Value of the Spinbox
386
 \param None
387
 \retval The Value
388
 */
389
 
390
double MSpinBox::maxValue()
391
{
392
        return static_cast<double>(QSpinBox::maxValue()) / Decimals;
393
}
333 Franz 394
 
395
void MSpinBox::setReadOnly( bool ro )
396
{
335 Franz 397
        if (readOnly!=ro)
398
        {
333 Franz 399
                if (!readOnly && ro) {
400
                        oldLineStep=QSpinBox::lineStep();
401
                        QSpinBox::setLineStep( 0 );
402
                }
403
                else if (readOnly && !ro) {
404
                        QSpinBox::setLineStep( oldLineStep );
405
                        oldLineStep=0;
406
                }
407
                ed->setReadOnly( ro );
335 Franz 408
                readOnly=ro;
333 Franz 409
        }
410
}
411
 
412
bool MSpinBox::isReadOnly() const
413
{
414
        return readOnly;
415
}
416