← Back to branch summary

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

« back to all changes in this revision

Viewing changes to score/items.h

  • 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:
score/items.h
 
1
//=========================================================
 
2
//  MusE
 
3
//  Linux Music Editor
 
4
//    $Id: items.h,v 1.2 2001/11/20 15:19:33 muse Exp $
 
5
//  (C) Copyright 1999,2000 Werner Schweer (ws@seh.de)
 
6
//=========================================================
 
7
 
 
8
#ifndef __ITEMS_H__
 
9
#define __ITEMS_H__
 
10
 
 
11
#include <qrect.h>
 
12
#include <qpainter.h>
 
13
#include <stdio.h>
 
14
#include <list>
 
15
#include <map>
 
16
 
 
17
#include "symbols.h"
 
18
 
 
19
class MidiEvent;
 
20
class MidiPart;
 
21
class QPixmap;
 
22
class NKey;
 
23
class Scale;
 
24
class Attribute;
 
25
class StaveRow;
 
26
class SystemLayout;
 
27
class MidiEditor;
 
28
 
 
29
//---------------------------------------------------------
 
30
//   ScoreItem
 
31
//    represents an object in the score layout
 
32
//---------------------------------------------------------
 
33
 
 
34
class ScoreItem {
 
35
   public:
 
36
      enum State {Normal, Selected, Moving};
 
37
 
 
38
   protected:
 
39
      StaveRow* sr;
 
40
      QPoint _offset;
 
41
      State _state;
 
42
      int _tick;        // sort key
 
43
      QPoint _moving;   // Position of Object while moving
 
44
      mutable QRect  r; // bounding box relative to pt
 
45
      QPoint pt;        // Position of Object in StaveRow coordinates
 
46
 
 
47
   public:
 
48
      ScoreItem(int t);
 
49
      ScoreItem(int t, const QPoint&);
 
50
      ScoreItem(int t, StaveRow* sr);
 
51
      StaveRow* staveRow() const      { return sr;      }
 
52
      void setStaveRow(StaveRow* _sr) { sr = _sr;       }
 
53
      int tick() const                { return _tick;   }
 
54
      void setTick(int n)             { _tick = n;      }
 
55
      State state() const             { return _state;  }
 
56
      void setState(State s)          { _state = s;     }
 
57
      void setMoving(const QPoint& p) { _moving = p;    }
 
58
      QPoint moving() const           { return _moving; }
 
59
      QPoint pos() const              { return pt;      }
 
60
      void setPos(const QPoint& d)    { pt = d;         }
 
61
      void setPos(int x, int y)       { pt.setX(x); pt.setY(y); }
 
62
      void setXPos(int x)             { pt.setX(x); }
 
63
      void setYPos(int y)             { pt.setY(y); }
 
64
      void setBBox(int x, int y, int w, int h) { r.setRect(x,y,w,h); }
 
65
 
 
66
      void moveX(int dx);
 
67
      bool intersects(const QRect& rr) const { return rr.intersects(r); }
 
68
      bool contains(const QPoint& p) { return r.contains(p); }
 
69
      bool isSelected() const { return _state == Selected; }
 
70
 
 
71
      virtual ~ScoreItem() {}
 
72
      virtual void quantize(int, int, int) {}
 
73
      virtual void setEnh(int)     {}
 
74
      virtual void draw(QPainter&) const {}
 
75
      virtual void print(FILE*) const    {}
 
76
      virtual void remove()     {}
 
77
      virtual void place(int)      {}
 
78
      virtual MidiEvent* event() const   { return 0; }
 
79
 
 
80
      virtual void move(MidiEditor*, SystemLayout*, bool) {}
 
81
 
 
82
      QPoint offset() const           { return _offset; }
 
83
      void setOffset(const QPoint& p) { _offset = p; }
 
84
      };
 
85
 
 
86
class Tie;
 
87
 
 
88
//-----------------------------------------------
 
89
//    Note und Ghost-Note
 
90
//-----------------------------------------------
 
91
 
 
92
class NoteItem : public ScoreItem {
 
93
      MidiEvent* _event;
 
94
      MidiPart* _part;
 
95
      int _stem;        // Notenhals
 
96
      int _head;
 
97
      int _len;
 
98
      int _hline;       // h-Linie innerhalb des Liniensystems
 
99
      Tie* _tieTo;
 
100
      Tie* _tieFrom;
 
101
      bool _ghost;
 
102
      int _prefix;       // accidental: 0-none, 1-sharp, 2-flat, 3-norm
 
103
      bool _flags;      // draw flags if true
 
104
 
 
105
   public:
 
106
      NoteItem(int t, MidiEvent* e, MidiPart* part, bool flag = false);
 
107
 
 
108
      bool ghost() const        { return _ghost; }
 
109
      void setGhost(bool f)     { _ghost = f; }
 
110
      void setAccidental(int i) { _prefix = i; }
 
111
      int accidental() const    { return _prefix; }
 
112
      bool flags() const        { return _flags; }
 
113
      void setFlags(bool f)     { _flags = f; }
 
114
 
 
115
      void setTieTo(Tie*);
 
116
      void setTieFrom(Tie* t) { _tieFrom = t; }
 
117
      Tie* tieTo() const      { return _tieTo;   }
 
118
      Tie* tieFrom() const    { return _tieFrom;   }
 
119
 
 
120
      void setHLine(int n)    { _hline = n;    }
 
121
      int hline() const       { return _hline; }
 
122
      bool isStemDown() const { return _stem < 0; }
 
123
      int stem() const        { return _stem; }
 
124
 
 
125
      void stemDown(bool f)  {
 
126
            if ((f && _stem > 0) || (!f && _stem < 0))
 
127
                  _stem = -_stem;
 
128
            }
 
129
      void setStem(int n) {
 
130
            _stem = (_stem < 0) ? -n : n;
 
131
            }
 
132
      int head() const     { return _head; }
 
133
      void setHead(int n)  { _head = n; }
 
134
 
 
135
      int len() const      { return _len; }
 
136
      void setLen(int n)   { _len = n; }
 
137
 
 
138
      MidiPart* part() const   { return _part; }
 
139
 
 
140
      virtual void quantize(int start_tick, int nq, int rq);
 
141
      virtual MidiEvent* event() const { return _event; }
 
142
      void setEvent(MidiEvent* e) { _event = e; }
 
143
      virtual void draw(QPainter&) const;
 
144
      virtual void print(FILE* f) const;
 
145
      virtual void remove();
 
146
      virtual void move(MidiEditor*, SystemLayout*, bool);
 
147
      };
 
148
 
 
149
//-----------------------------------------------
 
150
//    Tie
 
151
//-----------------------------------------------
 
152
 
 
153
class Tie : public ScoreItem {
 
154
      NoteItem* note1;
 
155
      NoteItem* note2;
 
156
      bool _up;
 
157
 
 
158
   public:
 
159
      Tie(int tick, NoteItem* n1, NoteItem* n2)
 
160
         : ScoreItem(tick) {
 
161
            note1 = n1;
 
162
            note2 = n2;
 
163
            _up   = true;
 
164
            }
 
165
      void setUp(bool f)             { _up = f; }
 
166
      bool up() const                { return _up; }
 
167
      NoteItem* startNote() const    { return note1; }
 
168
      NoteItem* endNote() const      { return note2; }
 
169
      void setStartNote(NoteItem* i) { note1 = i; }
 
170
      void setEndNote(NoteItem* i)   { note2 = i; }
 
171
      virtual void draw(QPainter&) const;
 
172
      virtual void print(FILE* f) const;
 
173
      };
 
174
 
 
175
//---------------------------------------------------------
 
176
//   PixmapItem
 
177
//---------------------------------------------------------
 
178
 
 
179
class PixmapItem : public ScoreItem {
 
180
   protected:
 
181
      const QPixmap* pm;
 
182
      QPoint po;
 
183
   public:
 
184
      PixmapItem(int tick, const QPoint&, const QPixmap*);
 
185
      PixmapItem(int tick, const QPoint&);
 
186
      void setPixmap(const QPixmap*);
 
187
      virtual void draw(QPainter& p) const;
 
188
      };
 
189
 
 
190
//-----------------------------------------------
 
191
//    Pause
 
192
//-----------------------------------------------
 
193
 
 
194
class RestItem : public PixmapItem {
 
195
      int _len;
 
196
   public:
 
197
      RestItem(int tick, const QPoint&, int len, int ticksBar);
 
198
      virtual void print(FILE* f) const;
 
199
      };
 
200
 
 
201
//---------------------------------------------------------
 
202
//   BracketItem
 
203
//---------------------------------------------------------
 
204
 
 
205
class BracketItem : public PixmapItem {
 
206
      int _h;
 
207
   public:
 
208
      BracketItem(int tick, int h)
 
209
         : PixmapItem(tick, QPoint(-10, 0), bracketBM)
 
210
            {
 
211
            _h = h;
 
212
            }
 
213
      virtual void print(FILE* f) const;
 
214
      };
 
215
 
 
216
//---------------------------------------------------------
 
217
//   Symbol
 
218
//---------------------------------------------------------
 
219
 
 
220
class Symbol : public PixmapItem {
 
221
      MidiEvent* _event;
 
222
      MidiPart* _part;
 
223
   public:
 
224
      Symbol(const QPoint&, int, MidiEvent*, MidiPart*);
 
225
      ~Symbol() {}
 
226
      virtual MidiEvent* event() const   { return _event; }
 
227
      void setEvent(MidiEvent* e) { _event = e; }
 
228
      MidiPart* part() const { return _part; }
 
229
      virtual void print(FILE* f) const;
 
230
      virtual void remove();
 
231
      virtual void move(MidiEditor*, SystemLayout*, bool);
 
232
      };
 
233
 
 
234
//---------------------------------------------------------
 
235
//   SystemItem
 
236
//---------------------------------------------------------
 
237
 
 
238
class SystemItem : public ScoreItem {
 
239
      int lines;
 
240
      int width;
 
241
   public:
 
242
      SystemItem(int tick, int l, int w)
 
243
         : ScoreItem(tick) {
 
244
            lines = l;
 
245
            width = w;
 
246
            pt = QPoint(0, 0);
 
247
            }
 
248
      virtual void draw(QPainter&) const;
 
249
      virtual void print(FILE* f) const;
 
250
      };
 
251
 
 
252
//-----------------------------------------------
 
253
//    MeasureItem
 
254
//-----------------------------------------------
 
255
 
 
256
class MeasureItem : public ScoreItem {
 
257
      int type;
 
258
      int h;
 
259
   public:
 
260
      MeasureItem(int tick, const QPoint& p, int _h, int t = 0)
 
261
         : ScoreItem(tick) {
 
262
            pt   = p;
 
263
            type = t;
 
264
            h    = _h;
 
265
            }
 
266
      virtual void draw(QPainter&) const;
 
267
      virtual void print(FILE* f) const;
 
268
      };
 
269
 
 
270
//---------------------------------------------------------
 
271
//   Text
 
272
//---------------------------------------------------------
 
273
 
 
274
class Text : public ScoreItem {
 
275
   protected:
 
276
      QColor color;
 
277
      QString s;
 
278
      const QFont font;
 
279
      int align;
 
280
 
 
281
   public:
 
282
      Text(int t, const QString& qs, const QFont& f, const QColor& c = Qt::black)
 
283
         : ScoreItem(t), color(c), s(qs), font(f) {
 
284
            align = QPainter::AlignLeft|QPainter::AlignBottom;
 
285
            }
 
286
      Text(int t, const QFont& f, const QColor& c = Qt::black)
 
287
         : ScoreItem(t), color(c), font(f) {
 
288
            align = QPainter::AlignLeft|QPainter::AlignBottom;
 
289
            }
 
290
      ~Text() {}
 
291
      virtual void draw(QPainter&) const;
 
292
      virtual void print(FILE* f) const;
 
293
      void setAlign(int n) { align = n; }
 
294
      void setText(const QString& txt) { s = txt; }
 
295
      QString text() const { return s; }
 
296
      void setNum(int n) { s.setNum(n); }
 
297
      };
 
298
 
 
299
//---------------------------------------------------------
 
300
//   QuantItem
 
301
//---------------------------------------------------------
 
302
 
 
303
class QuantItem : public Text {
 
304
      int nq;
 
305
      int rq;
 
306
      MidiPart* _part;
 
307
      MidiEvent* _event;
 
308
 
 
309
   public:
 
310
      QuantItem(int t, MidiEvent*, MidiPart*, int n, int r);
 
311
      MidiPart* part() const { return _part; }
 
312
      int noteQuant() const { return nq; }
 
313
      int restQuant() const { return rq; }
 
314
      virtual MidiEvent* event() const { return _event; }
 
315
      virtual void print(FILE*) const {}
 
316
      virtual void remove();
 
317
      };
 
318
 
 
319
class TrackNameItem : public Text {
 
320
   public:
 
321
      TrackNameItem(int t, const QString& ps, const QFont& f)
 
322
         : Text(t, ps, f) { }
 
323
      };
 
324
 
 
325
class TitleItem : public Text {
 
326
   public:
 
327
      TitleItem(int t, const QString& ps, const QFont& f)
 
328
         : Text(t, ps, f) { }
 
329
      virtual void move(MidiEditor*, SystemLayout*, bool);
 
330
      };
 
331
 
 
332
class Comp1Item : public Text {
 
333
   public:
 
334
      Comp1Item(int t, const QString& ps, const QFont& f)
 
335
         : Text(t, ps, f) { }
 
336
      };
 
337
 
 
338
class Comp2Item : public Text {
 
339
   public:
 
340
      Comp2Item(int t, const QString& ps, const QFont& f)
 
341
         : Text(t, ps, f) { }
 
342
      };
 
343
 
 
344
class LyricsItem : public Text {
 
345
      Attribute* _attribute;        // points to Attribute in _note->event()
 
346
      NoteItem* _note;
 
347
      bool editState;
 
348
      bool cursorVisible;
 
349
 
 
350
   public:
 
351
      LyricsItem(const QPoint& p, Attribute* a, NoteItem* ni, const QFont&);
 
352
      Attribute* attribute() const { return _attribute; }
 
353
      NoteItem* noteItem() const { return _note; }
 
354
      virtual void draw(QPainter&) const;
 
355
      virtual void print(FILE* f) const;
 
356
      void del() { s.truncate(s.length()-1); }
 
357
      void setEditState();
 
358
      void resetEditState();
 
359
      void add(const QString& s);
 
360
      void blink();
 
361
      virtual MidiEvent* event() { return _note->event(); }
 
362
      virtual void remove();
 
363
      virtual void move(MidiEditor*, SystemLayout*, bool);
 
364
      };
 
365
 
 
366
//-----------------------------------------------
 
367
//    MeasureNo
 
368
//-----------------------------------------------
 
369
 
 
370
class MeasureNo : public Text {
 
371
   public:
 
372
      MeasureNo(int tick, const QPoint& p, int i, const QFont& f)
 
373
         : Text(tick, f) {
 
374
            pt = p;
 
375
            setNum(i+1);
 
376
            }
 
377
      };
 
378
 
 
379
//---------------------------------------------------------
 
380
//   KeyItem
 
381
//---------------------------------------------------------
 
382
 
 
383
class KeyItem : public ScoreItem {
 
384
      NKey* key;
 
385
 
 
386
   public:
 
387
      KeyItem(const QPoint& p, int tick, NKey* k)
 
388
         : ScoreItem(tick) {
 
389
            pt = p;
 
390
            key = k;
 
391
            }
 
392
      ~KeyItem() {}
 
393
      virtual void draw(QPainter&) const;
 
394
      virtual void print(FILE* f) const;
 
395
      };
 
396
 
 
397
//---------------------------------------------------------
 
398
//   TimesigItem
 
399
//---------------------------------------------------------
 
400
 
 
401
class TimesigItem : public ScoreItem {
 
402
      int type;
 
403
      int nom1, nom2, nom3, denom;
 
404
      QFont font;
 
405
 
 
406
   public:
 
407
      TimesigItem(const QPoint& p, int tick, int t, int n1, int n2, int n3, int d)
 
408
         : ScoreItem(tick) {
 
409
            pt = p;
 
410
            type = t;
 
411
            nom1 = n1;
 
412
            nom2 = n2;
 
413
            nom3 = n3;
 
414
            denom = d;
 
415
            font  = QFont("Carter", 18, QFont::Normal);
 
416
            }
 
417
      ~TimesigItem() {}
 
418
      virtual void draw(QPainter&) const;
 
419
      virtual void print(FILE* f) const;
 
420
      };
 
421
 
 
422
//---------------------------------------------------------
 
423
//   Clef
 
424
//---------------------------------------------------------
 
425
 
 
426
class Clef : public ScoreItem {
 
427
      Scale* scale;
 
428
      NKey* key;
 
429
 
 
430
   public:
 
431
      Clef(const QPoint& p, int tick, Scale* s, NKey* k)
 
432
         : ScoreItem(tick) {
 
433
            scale = s;
 
434
            pt    = p;
 
435
            key   = k;
 
436
            }
 
437
      ~Clef() {}
 
438
      virtual void draw(QPainter&) const;
 
439
      virtual void print(FILE* f) const;
 
440
      };
 
441
 
 
442
//-----------------------------------------------
 
443
//    ScoreList
 
444
//-----------------------------------------------
 
445
 
 
446
class ScoreList: public std::multimap<int, ScoreItem*, std::less<int> > {
 
447
   public:
 
448
      ScoreList() {}
 
449
      ~ScoreList() { clear(); }
 
450
      void clear();
 
451
      ScoreItem* find(const QPoint& pos) const;
 
452
      ScoreList::iterator add(ScoreItem* i) {
 
453
            return insert(std::pair<const int, ScoreItem*>(i->tick(), i));
 
454
            }
 
455
      };
 
456
 
 
457
class NoteList: public std::list<NoteItem*> {
 
458
   public:
 
459
      };
 
460
 
 
461
typedef ScoreList::iterator iScore;
 
462
typedef ScoreList::const_iterator ciScore;
 
463
 
 
464
typedef NoteList::iterator iNote;
 
465
typedef NoteList::const_iterator ciNote;
 
466
 
 
467
//---------------------------------------------------------
 
468
//   Beam
 
469
//---------------------------------------------------------
 
470
 
 
471
class Beam : public ScoreItem {
 
472
      NoteList notes;
 
473
      int min, max;
 
474
   public:
 
475
      Beam(int tick, int _min, int _max) : ScoreItem(tick) {
 
476
            min = _min;
 
477
            max = _max;
 
478
            }
 
479
      void addNote(NoteItem* item) { notes.push_back(item); }
 
480
      virtual void draw(QPainter&) const;
 
481
      virtual void print(FILE* f) const;
 
482
      };
 
483
 
 
484
#endif
 
485