1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/*
Rosegarden
A sequencer and musical notation editor.
This program is Copyright 2000-2008
Guillaume Laurent <[email protected]>,
Chris Cannam <[email protected]>,
Richard Bown <[email protected]>
The moral right of the authors to claim authorship of this work
has been asserted.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version. See the file
COPYING included with this distribution for more information.
*/
#ifndef _STAFF_H_
#define _STAFF_H_
#include "ViewElement.h"
#include "Segment.h"
#include <iostream>
#include <cassert>
namespace Rosegarden
{
class StaffObserver;
/**
* Staff is the base class for classes which represent a Segment as an
* on-screen graphic. It manages the relationship between Segment/Event
* and specific implementations of ViewElement.
*
* The template argument T must be a subclass of ViewElement.
*
* Staff was formerly known as ViewElementsManager.
*/
class Staff : public SegmentObserver
{
public:
virtual ~Staff();
/**
* Create a new ViewElementList wrapping all Events in the
* segment, or return the previously created one
*/
ViewElementList *getViewElementList();
/**
* Create a new ViewElementList wrapping Events in the
* [from, to[ interval, or return the previously created one
* (even if passed new arguments)
*/
ViewElementList *getViewElementList(Segment::iterator from,
Segment::iterator to);
/**
* Return the Segment wrapped by this object
*/
Segment &getSegment() { return m_segment; }
/**
* Return the Segment wrapped by this object
*/
const Segment &getSegment() const { return m_segment; }
/**
* Return the location of the given event in this Staff
*/
ViewElementList::iterator findEvent(Event *);
/**
* SegmentObserver method - called after the event has been added to
* the segment
*/
virtual void eventAdded(const Segment *, Event *);
/**
* SegmentObserver method - called after the event has been removed
* from the segment, and just before it is deleted
*/
virtual void eventRemoved(const Segment *, Event *);
/**
* SegmentObserver method - called after the segment's end marker
* time has been changed
*/
virtual void endMarkerTimeChanged(const Segment *, bool shorten);
/**
* SegmentObserver method - called from Segment dtor
*/
virtual void segmentDeleted(const Segment *);
void addObserver (StaffObserver *obs) { m_observers.push_back(obs); }
void removeObserver(StaffObserver *obs) { m_observers.remove(obs); }
protected:
Staff(Segment &);
virtual ViewElement* makeViewElement(Event*) = 0;
/**
* Return true if the event should be wrapped
* Useful for piano roll where we only want to wrap notes
* (always true by default)
*/
virtual bool wrapEvent(Event *);
void notifyAdd(ViewElement *) const;
void notifyRemove(ViewElement *) const;
void notifySourceDeletion() const;
//--------------- Data members ---------------------------------
Segment &m_segment;
ViewElementList *m_viewElementList;
typedef std::list<StaffObserver*> ObserverSet;
ObserverSet m_observers;
private: // not provided
Staff(const Staff &);
Staff &operator=(const Staff &);
};
class StaffObserver
{
public:
virtual ~StaffObserver() {}
virtual void elementAdded(const Staff *, ViewElement *) = 0;
virtual void elementRemoved(const Staff *, ViewElement *) = 0;
/// called when the observed object is being deleted
virtual void staffDeleted(const Staff *) = 0;
};
}
#endif
|
