Subversion Repositories Scribus

Rev

Rev 364 | 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>
137 Franz 22
#include "fparser.h"
3 paul 23
 
146 Franz 24
/*!
25
 \fn MSpinBox(QWidget *pa, int s)
26
 \author Franz Schmid
27
 \date
28
 \brief Constructor
29
 \param pa Parent Widget
30
 \param s Number of Decimals
31
 \retval None
32
 */
33
 
3 paul 34
MSpinBox::MSpinBox(QWidget *pa, int s):QSpinBox(pa)
35
{
333 Franz 36
        setParameters(s);
37
        setValidator(0);
38
        ed = editor();
39
        QSpinBox::setLineStep(Decimals);
40
        oldLineStep=0;
41
        readOnly=false;
42
}
43
/*!
44
 \fn MSpinBox(double minValue, double maxValue, QWidget *pa, int s)
45
 \author Franz Schmid
46
 \date
47
 \brief Constructor
48
 \param pa Parent Widget
49
 \param s Number of Decimals
50
 \retval None
51
 */
52
 
53
MSpinBox::MSpinBox(double minValue, double maxValue, QWidget *pa, int s):QSpinBox(pa)
54
{
55
        setParameters(s);
56
        setValidator(0);
57
        ed = editor();
58
        QSpinBox::setLineStep(Decimals);
59
        oldLineStep=0;
60
        setMinValue(minValue);
61
        setMaxValue(maxValue);
62
        readOnly=false;
63
}
64
 
65
void MSpinBox::setParameters( int s )
66
{
3 paul 67
        switch (s)
161 Franz 68
        {
138 Franz 69
                case 0:
70
                        Decimals = 1;
71
                        Width = 0;
72
                        break;
3 paul 73
                case 1:
74
                        Decimals = 10;
75
                        Width = 1;
76
                        break;
77
                case 2:
78
                        Decimals = 100;
79
                        Width = 2;
139 Franz 80
                        break;
81
                case 3:
82
                        Decimals = 1000;
83
                        Width = 3;
84
                        break;
85
                case 4:
86
                        Decimals = 10000;
173 Franz 87
                        Width = 4;
139 Franz 88
                        break;
3 paul 89
                default:
90
                        Decimals = 100;
91
                        Width = 2;
92
                        break;
161 Franz 93
        }
3 paul 94
}
95
 
96
bool MSpinBox::eventFilter( QObject* ob, QEvent* ev )
97
{
98
        bool retval = FALSE;
99
        if ( ev->type() == QEvent::KeyPress )
161 Franz 100
        {
3 paul 101
                QKeyEvent* k = (QKeyEvent*)ev;
102
                if (k->key() == Key_Shift)
161 Franz 103
                {
138 Franz 104
                        setLineStep(QMAX(Decimals / 10, 1));
3 paul 105
                        retval = true;
161 Franz 106
                    qApp->sendEvent( this, ev );
3 paul 107
                        return retval;
108
                }
161 Franz 109
        }
3 paul 110
        if ( ev->type() == QEvent::KeyRelease )
161 Franz 111
        {
3 paul 112
                QKeyEvent* k = (QKeyEvent*)ev;
113
                if (k->key() == Key_Shift)
161 Franz 114
                {
3 paul 115
                        setLineStep(Decimals);
116
                        retval = true;
161 Franz 117
                    qApp->sendEvent( this, ev );
3 paul 118
                        return retval;
364 Franz 119
                }
120
        }
121
        if ( ev->type() == QEvent::Wheel )
122
        {
123
                QWheelEvent* k = (QWheelEvent*)ev;
124
                if (k->state() & ShiftButton)
125
                {
126
                        setLineStep(QMAX(Decimals / 10, 1));
127
                        retval = true;
128
                        qApp->sendEvent( this, ev );
129
                        return retval;
161 Franz 130
                }      
364 Franz 131
                if (!(k->state() & ShiftButton))
132
                {
133
                        setLineStep(Decimals);
134
                        retval = true;
135
                        qApp->sendEvent( this, ev );
136
                        return retval;
137
                }      
161 Franz 138
        }
3 paul 139
        return QSpinBox::eventFilter(ob, ev);
140
}
141
 
142
QString MSpinBox::mapValueToText(int value)
143
{
139 Franz 144
        return QString::number(static_cast<double>(value) / Decimals, 'f', Width);
3 paul 145
}
146
 
146 Franz 147
/*!
148
 \fn MSpinBox::mapTextToValue(bool *)
149
 \author Franz Schmid
150
 \date
151
 \brief Maps the Text fo the Spinbox to the Value, does Unit Conversion and Calculations
152
 \param None
153
 \retval The Value
154
 */
155
 
3 paul 156
int MSpinBox::mapTextToValue(bool *)
157
{
161 Franz 158
        FunctionParser fp;
138 Franz 159
        QString ts = text();
286 Franz 160
        QString su = suffix().stripWhiteSpace();
138 Franz 161
        ts.replace(",", ".");
272 Franz 162
        ts.replace("%", "");
286 Franz 163
        if ((su == tr( " pt" )) || (su == tr( "pt" )))
161 Franz 164
        {
286 Franz 165
                ts.replace(tr( "pt"), "");
166
                ts.replace(tr( "mm"), "/25.4*72");
167
                ts.replace(tr( "in"), "*72");
168
                ts.replace(tr( "p"), "*12");
161 Franz 169
        }
170
        else
286 Franz 171
                if ((su == tr( " mm" )) || (su == tr( "mm" )))
138 Franz 172
                {
286 Franz 173
                        ts.replace(tr( "pt"), "/72*25.4");
174
                        ts.replace(tr( "mm"), "");
175
                        ts.replace(tr( "in"), "*25.4");
2574 cbradney 176
                        ts.replace(tr( "p"), "/6*25.4");
138 Franz 177
                }
161 Franz 178
                else
286 Franz 179
                        if ((su == tr( " in" )) || (su == tr( "in" )))
161 Franz 180
                        {
286 Franz 181
                                ts.replace(tr( "pt"), "/72");
182
                                ts.replace(tr( "mm"), "/25.4");
183
                                ts.replace(tr( "in"), "");
184
                                ts.replace(tr( "p"), "/6");
161 Franz 185
                        }
186
                        else
286 Franz 187
                                if ((su == tr( " p" )) || (su == tr( "p" )))
161 Franz 188
                                {
286 Franz 189
                                        ts.replace(tr( "pt"), "/12");
190
                                        ts.replace(tr( "mm"), "/25.4*6");
191
                                        ts.replace(tr( "in"), "*6");
192
                                        ts.replace(tr( "p"), "");
161 Franz 193
                                }
286 Franz 194
        if (su != "")
195
                ts.replace(su, " ");
161 Franz 196
        int ret = fp.Parse(ts.latin1(), "", true);
137 Franz 197
        if (ret >= 0)
198
                return 0;
161 Franz 199
        double erg = fp.Eval(NULL);
139 Franz 200
        return qRound(erg*Decimals);
3 paul 201
}
202
 
333 Franz 203
void MSpinBox::setValues(double min, double max, int deci, double val)
204
{
205
        setDecimals(deci);
206
        setMinValue(min);
207
        setMaxValue(max);
208
        setValue(val);
209
}
210
 
211
void MSpinBox::getValues(double *min, double *max, int *deci, double *val)
212
{
213
        *deci = Decimals;
214
        *min = static_cast<double>(QSpinBox::minValue()) / Decimals;
215
        *max = static_cast<double>(QSpinBox::maxValue()) / Decimals;
216
        *val = static_cast<double>(QSpinBox::value()) / Decimals;
217
}
218
 
3 paul 219
void MSpinBox::setDecimals(int deci)
220
{
221
        Decimals = deci;
146 Franz 222
        QSpinBox::setLineStep(Decimals);
138 Franz 223
        if (deci < 10)
224
                Width = 0;
199 Franz 225
        if ((deci > 9) && (deci < 100))
3 paul 226
                Width = 1;
199 Franz 227
        if ((deci > 99) && (deci < 1000))
3 paul 228
                Width = 2;
199 Franz 229
        if ((deci > 999) && (deci < 10000))
139 Franz 230
                Width = 3;
231
        if (deci > 9999)
232
                Width = 4;
3 paul 233
}
146 Franz 234
 
235
/*!
236
 \fn MSpinBox::setMaxValue()
237
 \author Franz Schmid
238
 \date
239
 \brief Sets the Maximum Value of the Spinbox
240
 \param val new Value
241
 \retval None
242
 */
243
 
244
void MSpinBox::setMaxValue(double val)
245
{
246
        QSpinBox::setMaxValue(qRound(val*Decimals));
247
}
248
 
249
/*!
250
 \fn MSpinBox::setMinValue()
251
 \author Franz Schmid
252
 \date
253
 \brief Sets the Minimum Value of the Spinbox
254
 \param val new Value
255
 \retval None
256
 */
257
 
258
void MSpinBox::setMinValue(double val)
259
{
260
        QSpinBox::setMinValue(qRound(val*Decimals));
261
}
262
 
263
/*!
264
 \fn MSpinBox::setValue()
265
 \author Franz Schmid
266
 \date
267
 \brief Sets the Value of the Spinbox
268
 \param val new Value
269
 \retval None
270
 */
271
 
272
void MSpinBox::setValue(double val)
273
{
274
        QSpinBox::setValue(qRound(val*Decimals));
275
}
276
 
277
/*!
278
 \fn MSpinBox::value()
279
 \author Franz Schmid
280
 \date
281
 \brief Returns the current Value of the SpinBox
282
 \param None
283
 \retval The Value
284
 */
285
 
286
double MSpinBox::value()
287
{
288
        return static_cast<double>(QSpinBox::value()) / Decimals;
289
}
199 Franz 290
 
291
/*!
292
 \fn MSpinBox::minValue()
293
 \author Franz Schmid
294
 \date
295
 \brief Gets the Minimum Value of the Spinbox
296
 \param None
297
 \retval The Value
298
 */
299
 
300
double MSpinBox::minValue()
301
{
302
        return static_cast<double>(QSpinBox::minValue()) / Decimals;
303
}
304
 
305
/*!
306
 \fn MSpinBox::maxValue()
307
 \author Franz Schmid
308
 \date
309
 \brief Gets the Maximum Value of the Spinbox
310
 \param None
311
 \retval The Value
312
 */
313
 
314
double MSpinBox::maxValue()
315
{
316
        return static_cast<double>(QSpinBox::maxValue()) / Decimals;
317
}
333 Franz 318
 
319
void MSpinBox::setReadOnly( bool ro )
320
{
335 Franz 321
        if (readOnly!=ro)
322
        {
333 Franz 323
                if (!readOnly && ro) {
324
                        oldLineStep=QSpinBox::lineStep();
325
                        QSpinBox::setLineStep( 0 );
326
                }
327
                else if (readOnly && !ro) {
328
                        QSpinBox::setLineStep( oldLineStep );
329
                        oldLineStep=0;
330
                }
331
                ed->setReadOnly( ro );
335 Franz 332
                readOnly=ro;
333 Franz 333
        }
334
}
335
 
336
bool MSpinBox::isReadOnly() const
337
{
338
        return readOnly;
339
}
340