← Back to branch summary

~ubuntu-branches/ubuntu/precise/lmms/precise-proposed

« back to all changes in this revision

Viewing changes to include/song.h

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-11-12 13:32:32 UTC
  • mfrom: (1.1.9 upstream) (3.1.8 sid)
  • Revision ID: james.westby@ubuntu.com-20101112133232-vdld83iyji8srqti
Tags: 0.4.7-2ubuntu1
https://launchpad.net/bugs/606533
* Re-sync with Debian (LP: #606533):
  - Replace build-dep on libwine-dev with libwine-dev-unstable to build
    against the newer Wine.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/song.h
29
29
#include <QtCore/QVector>
30
30
 
31
31
#include "track_container.h"
32
 
#include "automatable_model.h"
 
32
#include "AutomatableModel.h"
33
33
#include "Controller.h"
34
 
#include "meter_model.h"
 
34
#include "MeterModel.h"
35
35
 
36
36
 
37
37
class automationTrack;
78
78
                {
79
79
                        m_currentFrame = _f;
80
80
                }
81
 
                inline float currentFrame( void ) const
 
81
                inline float currentFrame() const
82
82
                {
83
83
                        return m_currentFrame;
84
84
                }
92
92
 
93
93
 
94
94
 
95
 
        void processNextBuffer( void );
96
 
 
97
 
 
98
 
        inline bool isPaused( void ) const
 
95
        void processNextBuffer();
 
96
 
 
97
 
 
98
        inline bool isPaused() const
99
99
        {
100
100
                return m_paused;
101
101
        }
102
102
 
103
 
        inline bool isPlaying( void ) const
 
103
        inline bool isPlaying() const
104
104
        {
105
105
                return m_playing && m_exporting == false;
106
106
        }
107
107
 
108
 
        inline bool isExporting( void ) const
 
108
        inline bool isExporting() const
109
109
        {
110
110
                return m_exporting;
111
111
        }
112
112
 
113
 
        inline bool isRecording( void ) const
 
113
        inline bool isRecording() const
114
114
        {
115
115
                return m_recording;
116
116
        }
117
117
 
118
 
        bool realTimeTask( void ) const;
 
118
        bool realTimeTask() const;
119
119
 
120
 
        inline bool isExportDone( void ) const
 
120
        inline bool isExportDone() const
121
121
        {
122
122
                return m_exporting == true &&
123
123
                        m_playPos[Mode_PlaySong].getTact() >= length() + 1;
124
124
        }
125
125
 
126
 
        inline PlayModes playMode( void ) const
 
126
        inline PlayModes playMode() const
127
127
        {
128
128
                return m_playMode;
129
129
        }
133
133
                return m_playPos[_pm];
134
134
        }
135
135
 
136
 
        void updateLength( void );
137
 
        tact_t length( void ) const
 
136
        void updateLength();
 
137
        tact_t length() const
138
138
        {
139
139
                return m_length;
140
140
        }
141
141
 
142
142
 
143
 
        bpm_t getTempo( void );
144
 
        virtual automationPattern * tempoAutomationPattern( void );
 
143
        bpm_t getTempo();
 
144
        virtual automationPattern * tempoAutomationPattern();
145
145
 
146
 
        automationTrack * globalAutomationTrack( void )
 
146
        automationTrack * globalAutomationTrack()
147
147
        {
148
148
                return m_globalAutomationTrack;
149
149
        }
150
150
 
151
151
        // file management
152
 
        void createNewProject( void );
 
152
        void createNewProject();
153
153
        void createNewProjectFromTemplate( const QString & _template );
154
154
        void loadProject( const QString & _file_name );
155
 
        bool saveProject( void );
 
155
        bool saveProject();
156
156
        bool saveProjectAs( const QString & _file_name );
157
 
        inline const QString & projectFileName( void ) const
 
157
        inline const QString & projectFileName() const
158
158
        {
159
159
                return m_fileName;
160
160
        }
161
 
        inline bool isLoadingProject( void ) const
 
161
        inline bool isLoadingProject() const
162
162
        {
163
163
                return m_loadingProject;
164
164
        }
165
 
        inline bool isModified( void ) const
 
165
        inline bool isModified() const
166
166
        {
167
167
                return m_modified;
168
168
        }
169
169
 
170
 
        inline virtual QString nodeName( void ) const
 
170
        inline virtual QString nodeName() const
171
171
        {
172
172
                return "song";
173
173
        }
174
174
 
175
 
        virtual inline bool fixedTCOs( void ) const
 
175
        virtual inline bool fixedTCOs() const
176
176
        {
177
177
                return false;
178
178
        }
181
181
        void removeController( Controller * _c );
182
182
        
183
183
 
184
 
        const ControllerVector & controllers( void ) const
 
184
        const ControllerVector & controllers() const
185
185
        {
186
186
                return m_controllers;
187
187
        }
188
188
 
189
189
 
190
 
        meterModel & getTimeSigModel( void )
 
190
        MeterModel & getTimeSigModel()
191
191
        {
192
192
                return m_timeSigModel;
193
193
        }
194
194
 
195
195
 
196
196
public slots:
197
 
        void play( void );
198
 
        void record( void );
199
 
        void playAndRecord( void );
200
 
        void stop( void );
 
197
        void play();
 
198
        void record();
 
199
        void playAndRecord();
 
200
        void stop();
201
201
        void playTrack( track * _trackToPlay );
202
 
        void playBB( void );
 
202
        void playBB();
203
203
        void playPattern( pattern * _patternToPlay, bool _loop = true );
204
 
        void pause( void );
205
 
        void resumeFromPause( void );
206
 
 
207
 
        void importProject( void );
208
 
        void exportProject( void );
209
 
 
210
 
        void startExport( void );
211
 
        void stopExport( void );
212
 
 
213
 
 
214
 
        void setModified( void );
215
 
 
216
 
        void clearProject( void );
 
204
        void pause();
 
205
        void resumeFromPause();
 
206
 
 
207
        void importProject();
 
208
        void exportProject();
 
209
 
 
210
        void startExport();
 
211
        void stopExport();
 
212
 
 
213
 
 
214
        void setModified();
 
215
 
 
216
        void clearProject();
217
217
 
218
218
 
219
219
private slots:
220
 
        void insertBar( void );
221
 
        void removeBar( void );
222
 
        void addBBTrack( void );
223
 
        void addSampleTrack( void );
224
 
        void addAutomationTrack( void );
225
 
 
226
 
        void setTempo( void );
227
 
        void setTimeSignature( void );
228
 
 
229
 
        void masterVolumeChanged( void );
230
 
 
231
 
        void doActions( void );
232
 
 
233
 
        void updateFramesPerTick( void );
 
220
        void insertBar();
 
221
        void removeBar();
 
222
        void addBBTrack();
 
223
        void addSampleTrack();
 
224
        void addAutomationTrack();
 
225
 
 
226
        void setTempo();
 
227
        void setTimeSignature();
 
228
 
 
229
        void masterVolumeChanged();
 
230
 
 
231
        void doActions();
 
232
 
 
233
        void updateFramesPerTick();
234
234
 
235
235
 
236
236
 
237
237
private:
238
 
        song( void );
 
238
        song();
239
239
        song( const song & );
240
240
        virtual ~song();
241
241
 
242
242
 
243
 
        inline int ticksPerTact( void ) const
 
243
        inline int ticksPerTact() const
244
244
        {
245
245
                return DefaultTicksPerTact *
246
246
                                m_timeSigModel.getNumerator() /
247
247
                                         m_timeSigModel.getDenominator();
248
248
        }
249
249
 
250
 
        inline tact_t currentTact( void ) const
 
250
        inline tact_t currentTact() const
251
251
        {
252
252
                return m_playPos[m_playMode].getTact();
253
253
        }
254
254
 
255
 
        inline tick_t currentTick( void ) const
 
255
        inline tick_t currentTick() const
256
256
        {
257
257
                return m_playPos[m_playMode].getTicks();
258
258
        }
264
264
 
265
265
        automationTrack * m_globalAutomationTrack;
266
266
 
267
 
        intModel m_tempoModel;
268
 
        meterModel m_timeSigModel;
 
267
        IntModel m_tempoModel;
 
268
        MeterModel m_timeSigModel;
269
269
        int m_oldTicksPerTact;
270
 
        intModel m_masterVolumeModel;
271
 
        intModel m_masterPitchModel;
 
270
        IntModel m_masterVolumeModel;
 
271
        IntModel m_masterPitchModel;
272
272
 
273
273
        ControllerVector m_controllers;
274
274