1
2
3 #include "toonz/tframehandle.h"
4 #include "toonz/toonzscene.h"
5 #include "toonz/txshsimplelevel.h"
6 #include "toonz/txsheet.h"
7 #include "toonz/txshcell.h"
8 #include "toonz/sceneproperties.h"
9 #include "toutputproperties.h"
10
11 #include "toonz/txsheethandle.h"
12
13 //=============================================================================
14
15 namespace {
16
17 #if 0
18 /* int getCurrentSceneFrameCount()
19 {
20 return 100; //
21 TApp::instance()->getCurrentScene()->getScene()->getFrameCount();
22 }*/
23
24 /*void getCurrentScenePlayRange(int &r0, int &r1, int &step)
25 {
26 /*
27 ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
28 scene->getProperties()->getPreviewProperties()->getRange(r0, r1, step);
29 if(r0>r1)
30 {
31 r0 = 0;
32 r1 = scene->getFrameCount()-1;
33 }
34 */
35 /* r0 = 0;
36 r1 = getCurrentSceneFrameCount()-1;
37 }*/
38 #endif
39
getCurrentLevelFids(std::vector<TFrameId> & fids)40 bool getCurrentLevelFids(std::vector<TFrameId> &fids) {
41 /*
42 TXshSimpleLevel *sl = TApp::instance()->getCurrentLevel()->getSimpleLevel();
43 if(!sl) return false;
44 sl->getFids(fids);
45 */
46 fids.push_back(TFrameId(1));
47 return !fids.empty();
48 }
49
getLastLevelFid()50 TFrameId getLastLevelFid() { return TFrameId(1); }
51
52 } // namespace
53
54 //=============================================================================
55 // TFrameHandle
56 //-----------------------------------------------------------------------------
57
TFrameHandle()58 TFrameHandle::TFrameHandle()
59 : m_frame(-1)
60 , m_fid()
61 , m_timerId(0)
62 , m_previewFrameRate(25)
63 , m_frameType(SceneFrame)
64 , m_looping(false)
65 , m_isPlaying(false)
66 , m_scrubRange(0, -1)
67 , m_audioColumn(0)
68 , m_xsheet(0)
69 , m_fps(0)
70 , m_frame0(-1)
71 , m_frame1(-1) {}
72
73 //-----------------------------------------------------------------------------
74
~TFrameHandle()75 TFrameHandle::~TFrameHandle() {}
76
77 //-----------------------------------------------------------------------------
78
getFrame() const79 int TFrameHandle::getFrame() const { return m_frame; }
80
81 //-----------------------------------------------------------------------------
82
setCurrentFrame(int frame)83 void TFrameHandle::setCurrentFrame(int frame) {
84 if (m_frameType == LevelFrame) {
85 // std::vector<TFrameId> fids;
86 // if(!getCurrentLevelFids(fids)) return;
87
88 if (m_fids.size() <= 0) return;
89 if (frame - 1 >= (int)m_fids.size())
90 setFid(m_fids.back());
91 else
92 setFid(m_fids[frame - 1]);
93 } else
94 setFrame(frame - 1);
95 }
96
97 //-----------------------------------------------------------------------------
98
setFrame(int frame)99 void TFrameHandle::setFrame(int frame) {
100 if (m_frame == frame && m_frameType == SceneFrame) return;
101 m_frame = frame;
102 if (m_frameType != SceneFrame) {
103 m_frameType = SceneFrame;
104 emit frameTypeChanged();
105 }
106 emit frameSwitched();
107 }
108
109 //-----------------------------------------------------------------------------
110
getFid() const111 TFrameId TFrameHandle::getFid() const { return m_fid; }
112
113 //-----------------------------------------------------------------------------
114
setFid(const TFrameId & fid)115 void TFrameHandle::setFid(const TFrameId &fid) {
116 if (m_fid == fid && m_frameType == LevelFrame) return;
117 m_fid = fid;
118 if (m_frameType != LevelFrame) {
119 m_frameType = LevelFrame;
120 emit frameTypeChanged();
121 }
122 emit frameSwitched();
123 }
124
125 //-----------------------------------------------------------------------------
126
nextFrame(TFrameId id)127 void TFrameHandle::nextFrame(TFrameId id) {
128 if (m_frameType == LevelFrame) {
129 // std::vector<TFrameId> fids;
130 // if(!getCurrentLevelFids(fids)) return;
131 if (m_fids.size() <= 0) return;
132 std::vector<TFrameId>::iterator it;
133 it = std::upper_bound(m_fids.begin(), m_fids.end(), m_fid);
134 if (it == m_fids.end()) {
135 // non c'e' nessun frame del livello oltre m_fid. Non vado oltre al primo
136 // frame dopo l'ultimo.
137 // TXshSimpleLevel *sl =
138 // TApp::instance()->getCurrentLevel()->getSimpleLevel();
139 if (id != 0) {
140 setFid(id);
141 } else {
142 TFrameId fid = m_fids.back(); // sl->index2fid(sl->getFrameCount());
143 setFid(fid);
144 }
145 } else
146 setFid(*it);
147 } else {
148 setFrame(m_frame + 1);
149 }
150 }
151
152 //-----------------------------------------------------------------------------
153
prevFrame()154 void TFrameHandle::prevFrame() {
155 if (m_frameType == LevelFrame) {
156 // std::vector<TFrameId> fids;
157 if (m_fids.size() <= 0) return;
158 std::vector<TFrameId>::iterator it;
159 it = std::lower_bound(m_fids.begin(), m_fids.end(), m_fid);
160 // tornando indietro non vado prima del primo frame del livello
161 if (it != m_fids.end() && it != m_fids.begin()) {
162 --it;
163 setFid(*it);
164 } else {
165 // se sono dopo l'ultimo, vado all'ultimo
166 if (!m_fids.empty() && m_fid > m_fids.back()) setFid(m_fids.back());
167 }
168 } else {
169 if (m_frame > 0) setFrame(m_frame - 1);
170 }
171 }
172
173 //-----------------------------------------------------------------------------
174
firstFrame()175 void TFrameHandle::firstFrame() {
176 if (m_frameType == LevelFrame) {
177 // std::vector<TFrameId> fids;
178 if (m_fids.size() <= 0) return;
179 setFid(m_fids.front());
180 } else {
181 /*int r0,r1,step;
182 getCurrentScenePlayRange(r0,r1,step);*/
183 setFrame(m_frame0);
184 }
185 }
186
187 //-----------------------------------------------------------------------------
188
lastFrame()189 void TFrameHandle::lastFrame() {
190 if (m_frameType == LevelFrame) {
191 // std::vector<TFrameId> fids;
192 if (m_fids.size() <= 0) return;
193 setFid(m_fids.back());
194 } else {
195 /*int r0,r1,step;
196 getCurrentScenePlayRange(r0,r1,step);*/
197 if (m_frame1 > 0) setFrame(m_frame1);
198 }
199 }
200
201 //-----------------------------------------------------------------------------
202
setPlaying(bool isPlaying)203 void TFrameHandle::setPlaying(bool isPlaying) {
204 if (m_isPlaying == isPlaying) return;
205 m_isPlaying = isPlaying;
206 emit isPlayingStatusChanged();
207 }
208
209 //-----------------------------------------------------------------------------
210 #ifdef LEVO
211
startPlaying(bool looping)212 void TFrameHandle::startPlaying(bool looping) {
213 if (m_previewFrameRate == 0) return;
214 if (isScrubbing()) stopScrubbing();
215 setTimer(m_previewFrameRate);
216 m_looping = looping;
217 emit playStarted();
218 }
219
220 //-----------------------------------------------------------------------------
221
stopPlaying()222 void TFrameHandle::stopPlaying() {
223 if (m_timerId != 0) killTimer(m_timerId);
224 m_timerId = 0;
225 m_looping = false;
226 emit playStopped();
227 }
228
229 //-----------------------------------------------------------------------------
230 #endif
231
setTimer(int frameRate)232 void TFrameHandle::setTimer(int frameRate) {
233 m_previewFrameRate = frameRate;
234 if (m_timerId != 0) killTimer(m_timerId);
235 int interval = troundp(1000.0 / double(m_previewFrameRate));
236 m_timerId = startTimer(interval);
237 }
238
239 //-----------------------------------------------------------------------------
240
timerEvent(QTimerEvent * event)241 void TFrameHandle::timerEvent(QTimerEvent *event) {
242 assert(isScrubbing());
243
244 int elapsedTime = m_clock.elapsed();
245 int frame = m_scrubRange.first + elapsedTime * m_fps / 1000;
246 int lastFrame = m_scrubRange.second;
247 if (frame >= lastFrame) {
248 if (m_frame != lastFrame) setFrame(lastFrame);
249 stopScrubbing();
250 } else
251 setFrame(frame);
252 }
253
254 //-----------------------------------------------------------------------------
255
getMaxFrameIndex() const256 int TFrameHandle::getMaxFrameIndex() const {
257 if (m_frameType == LevelFrame) {
258 // std::vector<TFrameId> fids;
259 if (m_fids.size() <= 0)
260 return -1;
261 else
262 return m_fids.size() - 1;
263 } else
264 // return getCurrentSceneFrameCount()-1;
265 return m_sceneFrameSize - 1;
266 }
267
268 //-----------------------------------------------------------------------------
269
getFrameIndex() const270 int TFrameHandle::getFrameIndex() const {
271 if (m_frameType == LevelFrame) {
272 // std::vector<TFrameId> fids;
273 if (m_fids.size() > 0) {
274 std::vector<TFrameId>::const_iterator it =
275 std::find(m_fids.begin(), m_fids.end(), m_fid);
276 if (it != m_fids.end())
277 return std::distance(m_fids.begin(), it);
278 else {
279 if (m_fid > m_fids.back())
280 return m_fids.size();
281 else
282 return -1;
283 }
284 } else
285 return -1;
286 } else
287 return m_frame;
288 }
289
290 //-----------------------------------------------------------------------------
291
getFrameIndexName(int index) const292 QString TFrameHandle::getFrameIndexName(int index) const {
293 if (m_frameType == LevelFrame) {
294 if (m_fid.getNumber() <= 0)
295 return "";
296 else {
297 return QString::number(m_fid.getNumber());
298 }
299 } else
300 return QString::number(m_frame + 1);
301 }
302
setFrameIndex(int index)303 void TFrameHandle::setFrameIndex(int index) {
304 if (m_frameType == LevelFrame) {
305 // std::vector<TFrameId> fids;
306 if (m_fids.size() > 0 && 0 <= index && index < (int)m_fids.size())
307 setFid(m_fids[index]);
308 } else
309 setFrame(index);
310 }
311
setFrameIndexByName(const QString & str)312 void TFrameHandle::setFrameIndexByName(const QString &str) {
313 int num = str.toInt();
314 if (m_frameType == LevelFrame) {
315 setFid(TFrameId(num));
316 } else
317 setFrame(num - 1);
318 }
319
scrubColumn(int r0,int r1,TXshSoundColumn * audioColumn,double framePerSecond)320 void TFrameHandle::scrubColumn(int r0, int r1, TXshSoundColumn *audioColumn,
321 double framePerSecond) {
322 m_audioColumn = audioColumn;
323 if (!scrub(r0, r1, framePerSecond)) m_audioColumn = 0;
324 }
325
scrubXsheet(int r0,int r1,TXsheet * xsheet,double framePerSecond)326 void TFrameHandle::scrubXsheet(int r0, int r1, TXsheet *xsheet,
327 double framePerSecond) {
328 m_xsheet = xsheet;
329 if (!scrub(r0, r1, framePerSecond)) m_xsheet = 0;
330 }
331
scrub(int r0,int r1,double framePerSecond)332 bool TFrameHandle::scrub(int r0, int r1, double framePerSecond) {
333 if (isPlaying() || isScrubbing()) return false;
334 bool onlyOneFrame = (r0 == r1);
335
336 if (!isScrubbing() || !onlyOneFrame) emit scrubStarted();
337 if (!onlyOneFrame) {
338 m_fps = framePerSecond;
339 m_scrubRange = std::make_pair(r0, r1);
340 }
341 setFrame(r0);
342
343 if (m_audioColumn)
344 m_audioColumn->scrub(r0, r1);
345 else if (m_xsheet) {
346 int i;
347 for (i = r0; i <= r1; i++) m_xsheet->scrub(i, true);
348 }
349
350 if (onlyOneFrame) return false;
351
352 m_clock.start();
353 m_timerId = startTimer(40);
354 return true;
355 }
356
stopScrubbing()357 void TFrameHandle::stopScrubbing() {
358 if (!isScrubbing()) return;
359 if (m_timerId > 0) killTimer(m_timerId);
360 m_timerId = 0;
361 m_scrubRange = std::make_pair(0, -1);
362 if (m_audioColumn) m_audioColumn = 0;
363 if (m_xsheet) m_xsheet = 0;
364 m_fps = 0;
365 emit scrubStopped();
366 }
367