← Back to branch summary

~ubuntu-branches/ubuntu/feisty/muse/feisty

« back to all changes in this revision

Viewing changes to widgets/nentry.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/nentry.cpp
 
1
//=========================================================
 
2
//  MusE
 
3
//  Linux Music Editor
 
4
//    $Id: nentry.cpp,v 1.1 2002/01/30 14:54:03 muse Exp $
 
5
//  (C) Copyright 1999 Werner Schweer (ws@seh.de)
 
6
//=========================================================
 
7
 
 
8
#include <qlayout.h>
 
9
#include <qlabel.h>
 
10
#include "nentry.h"
 
11
#include <stdio.h>
 
12
#include <qtimer.h>
 
13
#include <qevent.h>
 
14
#include "globals.h"
 
15
#include <qapplication.h>
 
16
#include <qcursor.h>
 
17
 
 
18
#define TIMER1    400
 
19
#define TIMER2    200
 
20
#define TIMEC     7
 
21
#define TIMER3    100
 
22
#define TIMEC2    20
 
23
#define TIMER4    50
 
24
 
 
25
NentryFilter::NentryFilter(QObject* parent)
 
26
   : QObject(parent)
 
27
      {
 
28
      }
 
29
 
 
30
void Nentry::setText(const QString& s)
 
31
      {
 
32
      edit->setText(s);
 
33
      }
 
34
 
 
35
//---------------------------------------------------------
 
36
//   eventFilter
 
37
//---------------------------------------------------------
 
38
 
 
39
bool NentryFilter::eventFilter(QObject*, QEvent* event)
 
40
      {
 
41
      Nentry* e = (Nentry*)parent();
 
42
      if (event->type() == QEvent::MouseButtonPress) {
 
43
            e->mousePress((QMouseEvent*)event);
 
44
            return true;
 
45
            }
 
46
      if (event->type() == QEvent::MouseMove) {
 
47
            e->mouseMove((QMouseEvent*)event);
 
48
            return true;
 
49
            }
 
50
      if (event->type() == QEvent::MouseButtonDblClick) {
 
51
            e->mouseDoubleClick((QMouseEvent*)event);
 
52
            return true;
 
53
            }
 
54
      if (event->type() == QEvent::MouseButtonRelease) {
 
55
            e->mouseRelease((QMouseEvent*)event);
 
56
            return true;
 
57
            }
 
58
      if (event->type() == QEvent::Wheel) {
 
59
            e->wheel((QWheelEvent*)event);
 
60
            return true;
 
61
            }
 
62
      if (event->type() == QEvent::KeyPress) {
 
63
            return e->keyPress((QKeyEvent*)event);
 
64
            }
 
65
      return false;
 
66
      }
 
67
 
 
68
//---------------------------------------------------------
 
69
//   Nentry
 
70
//    lineedit int values
 
71
//---------------------------------------------------------
 
72
 
 
73
Nentry::Nentry(QWidget* parent, const QString& txt = "",
 
74
   int _lPos = 0, bool dark=false) : QFrame(parent)
 
75
      {
 
76
      focusW     = 0;
 
77
      lPos       = _lPos;
 
78
      edit       = new QLineEdit(this);
 
79
      timer      = new QTimer(this);
 
80
      filter     = new NentryFilter(this);
 
81
      drawFrame  = false;
 
82
      edit->installEventFilter(filter);
 
83
      edit->setFrame(drawFrame);
 
84
 
 
85
      connect(timer, SIGNAL(timeout()), SLOT(repeat()));
 
86
      connect(edit, SIGNAL(returnPressed()), SLOT(endEdit()));
 
87
      edit->setCursor(QCursor(arrowCursor));
 
88
//      edit->setFont(font3);
 
89
      val = 0;
 
90
      layout = new QHBoxLayout(this);
 
91
      if (txt == "") {
 
92
            layout->addWidget(edit, 1, AlignHCenter);
 
93
            }
 
94
      else {
 
95
            label = new QLabel(txt, this);
 
96
            if (lPos == 0) {
 
97
                  layout->addStretch(5);
 
98
                  layout->addSpacing(5);
 
99
                  layout->addWidget(label);
 
100
                  layout->addSpacing(5);
 
101
                  layout->addWidget(edit);
 
102
                  layout->addSpacing(5);
 
103
                  layout->addStretch(5);
 
104
                  }
 
105
            else {
 
106
                  label->setAlignment(AlignLeft);
 
107
                  layout->addWidget(edit, 0, AlignRight);
 
108
                  layout->addSpacing(5);
 
109
                  layout->addWidget(label, 100, AlignRight|AlignVCenter);
 
110
                  }
 
111
            }
 
112
      if (dark) {
 
113
            setDark();
 
114
            }
 
115
      edit->setFocusPolicy(NoFocus);
 
116
      }
 
117
 
 
118
void Nentry::setFocusPolicy(FocusPolicy policy)
 
119
      {
 
120
      edit->setFocusPolicy(policy);
 
121
      }
 
122
 
 
123
void Nentry::setDark()
 
124
      {
 
125
      const QPalette& oldpalette = edit->palette();
 
126
      QColorGroup cg1 = oldpalette.normal();
 
127
      cg1.setColor(QColorGroup::Base, cg1.background());
 
128
      QPalette newpalette(cg1, cg1, cg1);
 
129
      edit->setPalette(newpalette);
 
130
      }
 
131
 
 
132
//---------------------------------------------------------
 
133
//   setSize
 
134
//---------------------------------------------------------
 
135
 
 
136
void Nentry::setSize(int n)
 
137
      {
 
138
      QString s("0000000000000000");
 
139
      QFontMetrics fm = edit->fontMetrics();
 
140
      int w;
 
141
      if (n <= 16)
 
142
            w = fm.width(s, n);
 
143
      else
 
144
            w = fm.width('0') * n;
 
145
 
 
146
      edit->setFixedSize(w + 14, 15);
 
147
      }
 
148
 
 
149
//---------------------------------------------------------
 
150
//   setFrame
 
151
//---------------------------------------------------------
 
152
 
 
153
void Nentry::setFrame(bool flag)
 
154
      {
 
155
      drawFrame = flag;
 
156
      edit->setFrame(drawFrame);
 
157
      }
 
158
 
 
159
//---------------------------------------------------------
 
160
//   endEdit
 
161
//---------------------------------------------------------
 
162
 
 
163
void Nentry::endEdit()
 
164
      {
 
165
      if (edit->edited()) {
 
166
            if (setSValue(edit->text())) {
 
167
                  setString(val, false);
 
168
                  return;
 
169
                  }
 
170
            edit->setEdited(false);
 
171
            }
 
172
      if (focusW)
 
173
            focusW->setFocus();
 
174
      focusW = 0;
 
175
      edit->clearFocus();
 
176
      if (!drawFrame)
 
177
            edit->setFrame(false);
 
178
      setString(val, false);
 
179
      }
 
180
 
 
181
//---------------------------------------------------------
 
182
//   mousePress
 
183
//---------------------------------------------------------
 
184
 
 
185
void Nentry::mousePress(QMouseEvent* event)
 
186
      {
 
187
      button = event->button();
 
188
      starty = event->y();
 
189
      evx    = event->x();
 
190
      if (event->button() == QMouseEvent::LeftButton) {
 
191
            focusW = qApp->focusWidget();
 
192
            edit->setFocus();
 
193
            edit->setFrame(true);
 
194
            setString(val, true);
 
195
            }
 
196
      else {
 
197
            timecount = 0;
 
198
            repeat();
 
199
            timer->start(TIMER1);
 
200
            }
 
201
      }
 
202
 
 
203
//---------------------------------------------------------
 
204
//   repeat
 
205
//---------------------------------------------------------
 
206
 
 
207
void Nentry::repeat()
 
208
      {
 
209
      if (timecount == 1) {
 
210
           ++timecount;
 
211
            timer->stop();
 
212
            timer->start(TIMER2);
 
213
            return;
 
214
            }
 
215
      ++timecount;
 
216
      if (timecount == TIMEC) {
 
217
            timer->stop();
 
218
            timer->start(TIMER3);
 
219
            }
 
220
      if (timecount == TIMEC2) {
 
221
            timer->stop();
 
222
            timer->start(TIMER4);
 
223
            }
 
224
 
 
225
      switch (button) {
 
226
            case QMouseEvent::LeftButton:
 
227
                  return;
 
228
            case QMouseEvent::MidButton:
 
229
                  decValue(evx);
 
230
                  break;
 
231
            case QMouseEvent::RightButton:
 
232
                  incValue(evx);
 
233
                  break;
 
234
            default:
 
235
                  break;
 
236
            }
 
237
      if (focusW)
 
238
            focusW->setFocus();
 
239
      edit->clearFocus();
 
240
      }
 
241
 
 
242
//---------------------------------------------------------
 
243
//   mouseRelease
 
244
//---------------------------------------------------------
 
245
 
 
246
void Nentry::mouseRelease(QMouseEvent* event)
 
247
      {
 
248
      button = QMouseEvent::NoButton;
 
249
      timer->stop();
 
250
      if (event->button() != QMouseEvent::LeftButton) {
 
251
            if (focusW)
 
252
                  focusW->setFocus();
 
253
            edit->clearFocus();
 
254
            }
 
255
      }
 
256
 
 
257
//---------------------------------------------------------
 
258
//   mouseMove
 
259
//---------------------------------------------------------
 
260
 
 
261
void Nentry::mouseMove(QMouseEvent*)
 
262
      {
 
263
      switch (button) {
 
264
            case QMouseEvent::LeftButton:
 
265
                  break;
 
266
            case QMouseEvent::MidButton:
 
267
                  break;
 
268
            case QMouseEvent::RightButton:
 
269
                  break;
 
270
            default:
 
271
                  break;
 
272
            }
 
273
      }
 
274
 
 
275
//---------------------------------------------------------
 
276
//   mouseDoubleClick
 
277
//---------------------------------------------------------
 
278
 
 
279
void Nentry::mouseDoubleClick(QMouseEvent* event)
 
280
      {
 
281
      if (event->button() != QMouseEvent::LeftButton) {
 
282
            mousePress(event);
 
283
            return;
 
284
            }
 
285
      }
 
286
 
 
287
//---------------------------------------------------------
 
288
//   wheel
 
289
//---------------------------------------------------------
 
290
 
 
291
void Nentry::wheel(QWheelEvent* event)
 
292
      {
 
293
      int n = event->delta();
 
294
      if (n > 0)
 
295
            incValue(n);
 
296
      else
 
297
            decValue(-n);
 
298
      event->accept();
 
299
      }
 
300
 
 
301
//---------------------------------------------------------
 
302
//   setValue
 
303
//---------------------------------------------------------
 
304
 
 
305
void Nentry::setValue(int v)
 
306
      {
 
307
      if (v == val)
 
308
           return;
 
309
      if (setString(v)) {
 
310
//            edit->setCursorPosition(-1);
 
311
            if (!drawFrame)
 
312
                  edit->setFrame(false);
 
313
            edit->setEnabled(false);
 
314
            }
 
315
      else {
 
316
            edit->setEnabled(true);
 
317
            }
 
318
      val = v;
 
319
      }
 
320
 
 
321
//---------------------------------------------------------
 
322
//   keyPress
 
323
//---------------------------------------------------------
 
324
 
 
325
bool Nentry::keyPress(QKeyEvent* event)
 
326
      {
 
327
      bool shift = event->state() & ShiftButton;
 
328
      bool ctrl  = event->state() & ControlButton;
 
329
      int key    = event->key();
 
330
 
 
331
      if (shift) {
 
332
            switch(key) {
 
333
                  case Key_Left:
 
334
                  case Key_Right:
 
335
                        return false;
 
336
                  default:
 
337
                        return true;
 
338
                  }
 
339
            return true;
 
340
            }
 
341
      if (ctrl) {
 
342
            switch(key) {
 
343
                  case Key_A:
 
344
                  case Key_B:
 
345
                  case Key_C:
 
346
                  case Key_D:
 
347
                  case Key_E:
 
348
                  case Key_F:
 
349
                  case Key_H:
 
350
                  case Key_V:
 
351
                  case Key_X:
 
352
                  case Key_Z:
 
353
                  case Key_Y:
 
354
                        return false;
 
355
                  default:
 
356
                        return true;
 
357
                  }
 
358
            return true;
 
359
            }
 
360
      if (event->state())
 
361
            return true;
 
362
      switch (key) {
 
363
            case Key_Up:   incValue(0); return true;
 
364
            case Key_Down: decValue(0); return true;
 
365
            case 0x30:
 
366
            case 0x31:
 
367
            case 0x32:
 
368
            case 0x33:
 
369
            case 0x34:
 
370
            case 0x35:
 
371
            case 0x36:
 
372
            case 0x37:
 
373
            case 0x38:
 
374
            case 0x39:
 
375
            case Key_Minus:
 
376
            case Key_Left:
 
377
            case Key_Right:
 
378
            case Key_Backspace:
 
379
            case Key_Home:
 
380
            case Key_End:
 
381
            case Key_Delete:
 
382
            case Key_Return:
 
383
                  return false;
 
384
            default:
 
385
                  break;
 
386
            }
 
387
      return true;
 
388
      }
 
389