Implements PXEGeek's http://wiki.synfig.com/Wish_list entry: "Optionally display...
[synfig.git] / synfig-studio / trunk / src / gtkmm / preview.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file preview.cpp
3 **      \brief Preview implementation file
4 **
5 **      $Id$
6 **
7 **      \legal
8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
9 **
10 **      This package is free software; you can redistribute it and/or
11 **      modify it under the terms of the GNU General Public License as
12 **      published by the Free Software Foundation; either version 2 of
13 **      the License, or (at your option) any later version.
14 **
15 **      This package is distributed in the hope that it will be useful,
16 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
17 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 **      General Public License for more details.
19 **      \endlegal
20 */
21 /* ========================================================================= */
22
23 /* === H E A D E R S ======================================================= */
24
25 #ifdef USING_PCH
26 #       include "pch.h"
27 #else
28 #ifdef HAVE_CONFIG_H
29 #       include <config.h>
30 #endif
31
32 #include "preview.h"
33 #include "app.h"
34 #include "audiocontainer.h"
35 #include <gtkmm/stock.h>
36 #include <gtkmm/separator.h>
37
38 #include <synfig/target_scanline.h>
39 #include <synfig/surface.h>
40
41 #include <algorithm>
42 #include "asyncrenderer.h"
43 #endif
44
45 /* === U S I N G =========================================================== */
46
47 using namespace std;
48 using namespace etl;
49 using namespace synfig;
50 using namespace studio;
51
52 /* === M A C R O S ========================================================= */
53
54 /* === G L O B A L S ======================================================= */
55
56 /* === P R O C E D U R E S ================================================= */
57
58 /* === M E T H O D S ======================================================= */
59
60 /* === E N T R Y P O I N T ================================================= */
61
62 class studio::Preview::Preview_Target : public Target_Scanline
63 {
64         Surface surface;
65
66         sigc::signal<void, const Preview_Target *>              signal_frame_done_;
67
68         int scanline;
69
70         double  tbegin,tend;
71
72         int             nframes,curframe;
73
74 public:
75
76         Preview_Target()
77         {
78                 set_remove_alpha();
79                 tbegin = tend = 0;
80                 scanline = 0;
81                 nframes = curframe = 0;
82         }
83
84         const RendDesc &get_rend_desc() const { return desc; }
85
86         virtual bool set_rend_desc(RendDesc *r)
87         {
88                 if(Target_Scanline::set_rend_desc(r))
89                 {
90                         /*synfig::warning("Succeeded in setting the desc to new one: %d x %d, %.2f fps [%.2f,%.2f]",
91                                                         desc.get_w(),desc.get_h(),desc.get_frame_rate(),
92                                         (float)desc.get_time_start(),(float)desc.get_time_end());*/
93
94                         surface.set_wh(desc.get_w(),desc.get_h());
95
96                         curframe = 0;
97                         nframes = (int)floor((desc.get_time_end() - desc.get_time_start())*desc.get_frame_rate());
98
99                         tbegin = desc.get_time_start();
100                         tend = tbegin + nframes/desc.get_frame_rate();
101
102                         return true;
103                 }
104                 return false;
105         }
106
107         virtual bool start_frame(ProgressCallback *cb=NULL)
108         {
109                 return true;
110         }
111
112         virtual void end_frame()
113         {
114                 //ok... notify our subscribers...
115                 signal_frame_done_(this);
116                 curframe += 1;
117                 //synfig::warning("Finished the frame stuff, and changed time to %.3f",t);
118         }
119
120         virtual Color * start_scanline(int scanline)
121         {
122                 return surface[scanline];
123         }
124
125         virtual bool end_scanline() {return true;}
126
127         sigc::signal<void, const Preview_Target *>      &signal_frame_done() {return signal_frame_done_;}
128
129         const Surface &get_surface() const {return surface;}
130
131         float get_time() const
132         {
133                 double time = ((nframes-curframe)/(double)nframes)*tbegin
134                                         + ((curframe)/(double)nframes)*tend;
135                 return time;
136         }
137 };
138
139 studio::Preview::Preview(const studio::CanvasView::LooseHandle &h, float zoom, float f)
140 :canvasview(h),zoom(zoom),fps(f)
141 {
142         overbegin = false;
143         overend = false;
144 }
145
146 void studio::Preview::set_canvasview(const studio::CanvasView::LooseHandle &h)
147 {
148         canvasview = h;
149
150         if(canvasview)
151         {
152                 //perhaps reset override values...
153                 const RendDesc &r = canvasview->get_canvas()->rend_desc();
154                 if(r.get_frame_rate())
155                 {
156                         float rate = 1/r.get_frame_rate();
157                         overbegin = false; begintime = r.get_time_start() + r.get_frame_start()*rate;
158                         overend = false; endtime = r.get_time_start() + r.get_frame_end()*rate;
159                 }
160         }
161 }
162
163 studio::Preview::~Preview()
164 {
165         signal_destroyed_(this); //tell anything that attached to us, we're dying
166 }
167
168 void studio::Preview::render()
169 {
170         if(canvasview)
171         {
172                 //render using the preview target
173                 etl::handle<Preview_Target>     target = new Preview_Target;
174
175                 //connect our information to his...
176                 //synfig::warning("Connecting to the end frame function...");
177                 target->signal_frame_done().connect(sigc::mem_fun(*this,&Preview::frame_finish));
178
179                 //set the options
180                 //synfig::warning("Setting Canvas");
181                 target->set_canvas(get_canvas());
182                 target->set_quality(quality);
183
184                 //render description
185                 RendDesc desc = get_canvas()->rend_desc();
186
187                 //set the global fps of the preview
188                 set_global_fps(desc.get_frame_rate());
189
190                 desc.clear_flags();
191
192                 int neww = (int)floor(desc.get_w()*zoom+0.5),
193                         newh = (int)floor(desc.get_h()*zoom+0.5);
194                 float newfps = fps;
195
196                 /*synfig::warning("Setting the render description: %d x %d, %f fps, [%f,%f]",
197                                                 neww,newh,newfps, overbegin?begintime:(float)desc.get_time_start(),
198                                                 overend?endtime:(float)desc.get_time_end());*/
199
200                 desc.set_w(neww);
201                 desc.set_h(newh);
202                 desc.set_frame_rate(newfps);
203
204                 if(overbegin)
205                 {
206                         desc.set_time_start(std::max(begintime,(float)desc.get_time_start()));
207                         //synfig::warning("Set start time to %.2f...",(float)desc.get_time_start());
208                 }
209                 if(overend)
210                 {
211                         desc.set_time_end(std::min(endtime,(float)desc.get_time_end()));
212                         //synfig::warning("Set end time to %.2f...",(float)desc.get_time_end());
213                 }
214
215                 //setting the description
216
217                 //HACK - BECAUSE THE RENDERER CAN'T RENDER INCLUDING THE LAST FRAME
218                 desc.set_time_end(desc.get_time_end() + 1.3/fps);
219
220                 target->set_rend_desc(&desc);
221
222                 //... first we must clear our current selves of space
223                 frames.resize(0);
224
225                 //now tell it to go... with inherited prog. reporting...
226                 //synfig::info("Rendering Asynchronously...");
227                 if(renderer) renderer->stop();
228                 renderer = new AsyncRenderer(target);
229                 renderer->start();
230         }
231 }
232
233 static void free_guint8(const guint8 *mem)
234 {
235         free((void*)mem);
236 }
237
238 void studio::Preview::frame_finish(const Preview_Target *targ)
239 {
240         //copy image with time to next frame (can just push back)
241         FlipbookElem    fe;
242         float time = targ->get_time();
243         const Surface &surf = targ->get_surface();
244         const RendDesc& r = targ->get_rend_desc();
245
246         //synfig::warning("Finished a frame at %f s",time);
247
248         //copy EVERYTHING!
249         PixelFormat pf(PF_RGB);
250         const int total_bytes(r.get_w()*r.get_h()*synfig::channels(pf));
251
252         //synfig::warning("Creating a buffer");
253         unsigned char *buffer((unsigned char*)malloc(total_bytes));
254
255         if(!buffer)
256                 return;
257
258         //convert all the pixles to the pixbuf... buffer... thing...
259         //synfig::warning("Converting...");
260         convert_color_format(buffer, surf[0], surf.get_w()*surf.get_h(), pf, App::gamma);
261
262         //load time
263         fe.t = time;
264         //uses and manages the memory for the buffer...
265         //synfig::warning("Create a pixmap...");
266         fe.buf =
267         Gdk::Pixbuf::create_from_data(
268                 buffer, // pointer to the data
269                 Gdk::COLORSPACE_RGB, // the colorspace
270                 ((pf&PF_A)==PF_A), // has alpha?
271                 8, // bits per sample
272                 surf.get_w(),   // width
273                 surf.get_h(),   // height
274                 surf.get_w()*synfig::channels(pf), // stride (pitch)
275                 sigc::ptr_fun(free_guint8)
276         );
277
278         //add the flipbook element to the list (assume time is correct)
279         //synfig::info("Prev: Adding %f s to the list", time);
280         frames.push_back(fe);
281
282         signal_changed()();
283 }
284
285 #define IMAGIFY_BUTTON(button,stockid,tooltip)                                  \
286         icon=manage(new Gtk::Image(Gtk::StockID(stockid),Gtk::ICON_SIZE_BUTTON));       \
287         button->add(*icon);     \
288         tooltips.set_tip(*button,tooltip);      \
289         icon->set_padding(0,0);\
290         icon->show();
291
292 Widget_Preview::Widget_Preview()
293 :Gtk::Table(5,5,false),
294 adj_time_scrub(0,0,1000,1,10,0),
295 scr_time_scrub(adj_time_scrub),
296 b_loop(/*_("Loop")*/),
297 currentindex(0),
298 audiotime(0),
299 adj_sound(0,0,4),
300 l_lasttime("0s"),
301 playing(false)
302 {
303         //connect to expose events
304         //signal_expose_event().connect(sigc::mem_fun(*this, &studio::Widget_Preview::redraw));
305
306         //manage all the change in values etc...
307         adj_time_scrub.signal_value_changed().connect(sigc::mem_fun(*this,&Widget_Preview::slider_move));
308         scr_time_scrub.signal_event().connect(sigc::mem_fun(*this,&Widget_Preview::scroll_move_event));
309         draw_area.signal_expose_event().connect(sigc::mem_fun(*this,&Widget_Preview::redraw));
310
311         disp_sound.set_time_adjustment(&adj_sound);
312         timedisp = -1;
313
314         //Set up signals to modify time value as it should be...
315         disp_sound.signal_start_scrubbing().connect(sigc::mem_fun(*this,&Widget_Preview::scrub_updated));
316         disp_sound.signal_scrub().connect(sigc::mem_fun(*this,&Widget_Preview::scrub_updated));
317
318         /*
319         ---------------------------------
320         |                                                               |
321         |                                                               |
322         |                                                               |
323         |                                                               |
324         |                                                               |
325         |                                                               |
326         |                                                               |
327         ---------------------------------
328         |loop|play|stop                                 | hbox
329         |lastl|lastt|rerender|haltrend  | hbox
330         |
331         |sound                                                  |
332         */
333
334         Gtk::HBox *hbox = 0;
335         Gtk::Button *button = 0;
336         Gtk::Image *icon = 0;
337
338         //should set up the dialog using attach etc.
339         attach(draw_area, 0, 1, 0, 1);
340         attach(scr_time_scrub, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);
341
342         #if 1
343
344         //2nd row
345         hbox = manage(new Gtk::HBox);
346
347         button = &b_loop;
348         IMAGIFY_BUTTON(button,Gtk::Stock::REFRESH,"Toggle Looping");
349         hbox->pack_start(b_loop,Gtk::PACK_SHRINK,0);
350         //attach(b_loop,0,1,2,3,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
351
352         button = manage(new Gtk::Button(/*_("Play")*/));
353         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::play));
354         IMAGIFY_BUTTON(button,Gtk::Stock::GO_FORWARD,"Play");
355         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
356         //attach(*button,1,2,2,3,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
357
358         button = manage(new Gtk::Button(/*_("Stop")*/));
359         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::stop));
360         IMAGIFY_BUTTON(button,Gtk::Stock::NO,"Stop");
361         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
362         //attach(*button,2,3,2,3,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
363
364         //attack the stop render and erase all buttons to same line...
365         {
366                 Gtk::VSeparator *vsep = manage(new Gtk::VSeparator);
367                 hbox->pack_start(*vsep,Gtk::PACK_SHRINK,0);
368         }
369
370         button = manage(new Gtk::Button(/*_("Halt Render")*/));
371         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::stoprender));
372         IMAGIFY_BUTTON(button,Gtk::Stock::STOP,"Halt Render");
373         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
374         //attach(*button,2,3,3,4,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
375
376         button = manage(new Gtk::Button(/*_("Re-Preview")*/));
377         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::repreview));
378         IMAGIFY_BUTTON(button,Gtk::Stock::CONVERT,"Re-Preview");
379         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
380         //attach(*button,0,2,4,5,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
381
382         button = manage(new Gtk::Button(/*_("Erase All")*/));
383         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::eraseall));
384         IMAGIFY_BUTTON(button,Gtk::Stock::DELETE,"Erase All");
385         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
386         //attach(*button,2,3,4,5,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
387
388         hbox->show_all();
389         attach(*hbox,0,1,2,3,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK|Gtk::FILL);
390
391         //3rd row
392         hbox = manage(new Gtk::HBox);
393         {
394                 Gtk::Label *label = manage(new Gtk::Label("Last Rendered: "));
395                 //label->show();
396                 hbox->pack_start(*label,Gtk::PACK_SHRINK,10);
397                 //attach(*manage(new Gtk::Label("Last Rendered: ")),0,1,3,4,Gtk::SHRINK,Gtk::SHRINK);
398         }
399         //l_lasttime.show();
400         hbox->pack_start(l_lasttime,Gtk::PACK_SHRINK,0);
401         hbox->show_all();
402         attach(*hbox,0,1,3,4,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
403         //attach(l_lasttime,0,1,3,4,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
404
405         //5th row
406         disp_sound.set_size_request(-1,32);
407         attach(disp_sound,0,1,4,5,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
408
409         show_all();
410
411         //if(draw_area.get_window()) gc_area = Gdk::GC::create(draw_area.get_window());
412         #endif
413 }
414
415 studio::Widget_Preview::~Widget_Preview()
416 {
417 }
418
419 void studio::Widget_Preview::update()
420 {
421         //the meat goes in this locker...
422         double time = adj_time_scrub.get_value();
423
424         //find the frame and display it...
425         if(preview)
426         {
427                 //synfig::warning("Updating at %.3f s",time);
428
429                 //use time to find closest frame...
430                 studio::Preview::FlipBook::const_iterator       beg = preview->begin(),end = preview->end();
431                 studio::Preview::FlipBook::const_iterator       i;
432
433                 i = beg;
434
435                 //go to current hint if need be...
436                 if(currentindex >= 0 && currentindex < (int)preview->numframes())
437                 {
438                         i = beg+currentindex;
439                 }
440
441                 //we can't have a picture if there are none to get
442                 if(beg != end)
443                 {
444                         //don't bother with binary search it will just be slower...
445
446                         //synfig::info("Search for time %f",time);
447
448                         //incrementally go in either direction
449                         //(bias downward towards beg, because that's what we want)
450                         for(;i != end;++i)
451                         {
452                                 //synfig::info("Look at %f",i->t);
453                                 if(i->t > time) break;
454                                 //synfig::info("Go past...");
455                         }
456
457                         //if(i!=beg)--i;
458
459                         //bias down, so we can't be at end... and it still is valid...
460                         for(;i != beg;)
461                         {
462                                 --i;
463                                 //synfig::info("Look at %f",i->t);
464                                 if(i->t <= time) break;
465                                 //synfig::info("Go past...");
466                         }
467
468                         /*i = preview->begin(); end = preview->end();
469                         if(i == end) return;
470
471                         j = i;
472                         for(;i != end; j = i++)
473                         {
474                                 if(i->t > time) break;
475                         }*/
476
477                         //we should be at a valid edge since we biased downward
478
479                         //don't get the closest, round down... (if we can)
480                         if(i == end)
481                         {
482                                 synfig::error("i == end....");
483                                 //assert(0);
484                                 currentbuf.clear();
485                                 currentindex = 0;
486                                 timedisp = -1;
487                         }else
488                         {
489                                 currentbuf = i->buf;
490                                 currentindex = i-beg;
491                                 if(timedisp != i->t)
492                                 {
493                                         timedisp = i->t;
494                                         //synfig::warning("Update at: %f seconds (%f s)",time,timedisp);
495                                         preview_draw();
496                                         //synfig::warning("success!");
497                                 }
498                         }
499                 }
500         }
501
502         if(disp_sound.get_profile() && adj_sound.get_value() != time)
503         {
504                 //timeupdate = time;
505
506                 //Set the position of the sound (short circuited for sound modifying the time)
507
508                 disp_sound.set_position(time);
509                 disp_sound.queue_draw();
510         }
511 }
512 void studio::Widget_Preview::preview_draw()
513 {
514         draw_area.queue_draw();//on_expose_event();
515 }
516
517 bool studio::Widget_Preview::redraw(GdkEventExpose *heh)
518 {
519         //And render the drawing area
520         Glib::RefPtr<Gdk::Pixbuf> pxnew, px = currentbuf;
521
522         if(!px || draw_area.get_height() == 0
523                 || px->get_height() == 0 || px->get_width() == 0 /*|| is_visible()*/) //made not need this line
524                 return true;
525
526         //figure out the scaling factors...
527         float sx, sy;
528         int nw,nh;
529
530         sx = draw_area.get_width() / (float)px->get_width();
531         sy = draw_area.get_height() / (float)px->get_height();
532
533         //synfig::info("widget_preview redraw: now to scale the bitmap: %.3f x %.3f",sx,sy);
534
535         //round to smallest scale (fit entire thing in window without distortion)
536         if(sx > sy) sx = sy;
537         //else sy = sx;
538
539         //scale to a new pixmap and then copy over to the window
540         nw = (int)(px->get_width()*sx);
541         nh = (int)(px->get_height()*sx);
542
543         if(nw == 0 || nh == 0)return true;
544
545         pxnew = px->scale_simple(nw,nh,Gdk::INTERP_NEAREST);
546
547         //synfig::info("Now to draw to the window...");
548         //copy to window
549         Glib::RefPtr<Gdk::Window>       wind = draw_area.get_window();
550         Glib::RefPtr<Gdk::Drawable> surf = Glib::RefPtr<Gdk::Drawable>::cast_static(wind);
551         Glib::RefPtr<Gdk::GC>           gc = Gdk::GC::create(wind);
552
553         {
554                 Gdk::Rectangle r(0,0,draw_area.get_width(),draw_area.get_height());
555                 draw_area.get_window()->begin_paint_rect(r);
556         }
557
558         if(!wind) synfig::warning("The destination window is broken...");
559         if(!surf) synfig::warning("The destination is not drawable...");
560
561         if(surf)
562         {
563                 /* Options for drawing...
564                         1) store with alpha, then clear and render with alpha every frame
565                                 - more time consuming
566                                 + more expandable
567                         2) store with just pixel info
568                                 - less expandable
569                                 + faster
570                                 + better memory footprint
571                 */
572                 //px->composite(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type, int overall_alpha) const
573
574                 surf->draw_pixbuf(
575                         gc, //GC
576                         pxnew, //pixbuf
577                         0, 0,   // Source X and Y
578                         0, 0,   // Dest X and Y
579                         -1,-1,  // Width and Height
580                         Gdk::RGB_DITHER_NONE, // RgbDither
581                         0, 0 // Dither offset X and Y
582                 );
583
584                 if(timedisp >= 0)
585                 {
586                         Glib::RefPtr<Pango::Layout> layout(Pango::Layout::create(get_pango_context()));
587                         Glib::ustring timecode(Time((double)timedisp).round(preview->get_global_fps())
588                                                                                                                         .get_string(preview->get_global_fps(),
589                                                                                                                                                         App::get_time_format()));
590                         //synfig::info("Time for preview draw is: %s for time %g", timecode.c_str(), adj_time_scrub.get_value());
591
592                         gc->set_rgb_fg_color(Gdk::Color("#FF0000"));
593                         layout->set_text(timecode);
594                         surf->draw_layout(gc,4,4,layout);
595                 }
596         }
597
598         draw_area.get_window()->end_paint();
599
600         //synfig::warning("Refresh the draw area");
601         //make sure the widget refreshes
602
603         return false;
604 }
605
606 bool studio::Widget_Preview::play_update()
607 {
608         float diff = timer.pop_time();
609         //synfig::info("Play update: diff = %.2f",diff);
610
611         if(playing)
612         {
613                 //we go to the next one...
614                 double time = adj_time_scrub.get_value() + diff;
615
616                 //adjust it to be synced with the audio if it can...
617                 {
618                         double newtime = audiotime;
619                         if(audio && audio->is_playing()) audio->get_current_time(newtime);
620
621                         if(newtime != audiotime)
622                         {
623                                 //synfig::info("Adjusted time from %.3lf to %.3lf", time,newtime);
624                                 time = audiotime = newtime;
625                         }
626                 }
627
628                 //Looping conditions...
629                 if(time >= adj_time_scrub.get_upper())
630                 {
631                         if(get_loop_flag())
632                         {
633                                 time = adj_time_scrub.get_lower();// + time-adj_time_scrub.get_upper();
634                                 currentindex = 0;
635                         }else
636                         {
637                                 time = adj_time_scrub.get_upper();
638                                 adj_time_scrub.set_value(time);
639                                 play_stop();
640                                 update();
641
642                                 //synfig::info("Play Stopped: time set to %f",adj_time_scrub.get_value());
643                                 return false;
644                         }
645                 }
646
647                 //set the new time...
648                 adj_time_scrub.set_value(time);
649                 adj_time_scrub.value_changed();
650
651                 //update the window to the correct image we might want to do this later...
652                 //update();
653                 //synfig::warning("Did update pu");
654         }
655         return true;
656 }
657
658 void studio::Widget_Preview::slider_move()
659 {
660         //if(!playing)
661         {
662                 update();
663                 //synfig::warning("Did update sm");
664         }
665 }
666
667 //for other things updating the value changed signal...
668 void studio::Widget_Preview::scrub_updated(double t)
669 {
670         stop();
671
672         //Attempt at being more accurate... the time is adjusted to be exactly where the sound says it is
673         //double oldt = t;
674         if(audio)
675         {
676                 if(!audio->isPaused())
677                 {
678                         audio->get_current_time(t);
679                 }
680         }
681
682         //synfig::info("Scrubbing to %.3f, setting adj to %.3f",oldt,t);
683
684         if(adj_time_scrub.get_value() != t)
685         {
686                 adj_time_scrub.set_value(t);
687                 adj_time_scrub.value_changed();
688         }
689 }
690
691 void studio::Widget_Preview::disconnect_preview(Preview *prev)
692 {
693         if(prev == preview)
694         {
695                 preview = 0;
696                 prevchanged.disconnect();
697         }
698 }
699
700 void studio::Widget_Preview::set_preview(handle<Preview>        prev)
701 {
702         preview = prev;
703
704         synfig::info("Setting preview");
705
706         //stop playing the mini animation...
707         stop();
708
709         if(preview)
710         {
711                 //set the internal values
712                 float rate = preview->get_fps();
713                 synfig::info("  FPS = %f",rate);
714                 if(rate)
715                 {
716                         float start = preview->get_begintime();
717                         float end = preview->get_endtime();
718
719                         rate = 1/rate;
720
721                         adj_time_scrub.set_lower(start);
722                         adj_time_scrub.set_upper(end);
723                         adj_time_scrub.set_value(start);
724                         adj_time_scrub.set_step_increment(rate);
725                         adj_time_scrub.set_page_increment(10*rate);
726
727                         //if the begin time and the end time are the same there is only a single frame
728                         singleframe = end==start;
729                 }else
730                 {
731                         adj_time_scrub.set_lower(0);
732                         adj_time_scrub.set_upper(0);
733                         adj_time_scrub.set_value(0);
734                         adj_time_scrub.set_step_increment(0);
735                         adj_time_scrub.set_page_increment(0);
736                         singleframe = true;
737                 }
738
739                 //connect so future information will be found...
740                 prevchanged = prev->signal_changed().connect(sigc::mem_fun(*this,&Widget_Preview::whenupdated));
741                 prev->signal_destroyed().connect(sigc::mem_fun(*this,&Widget_Preview::disconnect_preview));
742                 update();
743                 //synfig::warning("Did update sp");
744                 queue_draw();
745         }
746 }
747
748 void studio::Widget_Preview::whenupdated()
749 {
750         l_lasttime.set_text((Time((double)(--preview->end())->t)
751                                                         .round(preview->get_global_fps())
752                                                         .get_string(preview->get_global_fps(),App::get_time_format())));
753         update();
754 }
755
756 void studio::Widget_Preview::clear()
757 {
758         preview = 0;
759         prevchanged.disconnect();
760 }
761
762 void studio::Widget_Preview::play()
763 {
764         if(preview && !playing)
765         {
766                 //synfig::info("Playing at %lf",adj_time_scrub.get_value());
767                 //audiotime = adj_time_scrub.get_value();
768                 playing = true;
769
770                 //adj_time_scrub.set_value(adj_time_scrub.get_lower());
771                 update(); //we don't want to call play update because that will try to advance the timer
772                 //synfig::warning("Did update p");
773
774                 //approximate length of time in seconds, right?
775                 double rate = /*std::min(*/adj_time_scrub.get_step_increment()/*,1/30.0)*/;
776                 int timeout = (int)floor(1000*rate);
777
778                 //synfig::info("        rate = %.3lfs = %d ms",rate,timeout);
779
780                 signal_play_(adj_time_scrub.get_value());
781
782                 //play the audio...
783                 if(audio) audio->play(adj_time_scrub.get_value());
784
785                 timecon = Glib::signal_timeout().connect(sigc::mem_fun(*this,&Widget_Preview::play_update),timeout);
786                 timer.reset();
787         }
788
789 }
790
791 void studio::Widget_Preview::play_stop()
792 {
793         playing = false;
794         signal_stop()();
795         if(audio) audio->stop(); //!< stop the audio
796         //synfig::info("Stopping...");
797 }
798
799 void studio::Widget_Preview::stop()
800 {
801         //synfig::warning("stopping");
802         play_stop();
803         timecon.disconnect();
804 }
805
806 bool studio::Widget_Preview::scroll_move_event(GdkEvent *event)
807 {
808         switch(event->type)
809         {
810                 case GDK_BUTTON_PRESS:
811                 {
812                         if(event->button.button == 1 || event->button.button == 3)
813                         {
814                                 stop();
815                         }
816                 }
817
818                 default: break;
819         }
820
821         return false;
822 }
823
824 void studio::Widget_Preview::set_audioprofile(etl::handle<AudioProfile> p)
825 {
826         disp_sound.set_profile(p);
827 }
828
829 void studio::Widget_Preview::set_audio(etl::handle<AudioContainer> a)
830 {
831         audio = a;
832
833         //disconnect any previous signals
834         scrstartcon.disconnect(); scrstopcon.disconnect(); scrubcon.disconnect();
835
836         //connect the new signals
837         scrstartcon = disp_sound.signal_start_scrubbing().connect(sigc::mem_fun(*a,&AudioContainer::start_scrubbing));
838         scrstopcon = disp_sound.signal_stop_scrubbing().connect(sigc::mem_fun(*a,&AudioContainer::stop_scrubbing));
839         scrubcon = disp_sound.signal_scrub().connect(sigc::mem_fun(*a,&AudioContainer::scrub));
840 }
841
842 void studio::Widget_Preview::seek(float t)
843 {
844         stop();
845         adj_time_scrub.set_value(t);
846 }
847
848 void studio::Widget_Preview::repreview()
849 {
850         if(preview)
851         {
852                 stoprender();
853                 stop();
854                 preview->get_canvasview()->preview_option();
855         }
856 }
857
858 void studio::Widget_Preview::stoprender()
859 {
860         if(preview)
861         {
862                 preview->renderer.detach();
863         }
864 }
865
866 void studio::Widget_Preview::eraseall()
867 {
868         stop();
869         stoprender();
870
871         currentbuf.clear();
872         currentindex = 0;
873         timedisp = 0;
874         queue_draw();
875
876         if(preview)
877         {
878                 preview->clear();
879         }
880 }