minor fix
[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: preview.cpp,v 1.2 2005/01/10 08:13:44 darco Exp $
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)  \
286         icon=manage(new Gtk::Image(Gtk::StockID(stockid),Gtk::ICON_SIZE_BUTTON));       \
287         button->add(*icon);     \
288         icon->set_padding(0,0);\
289         icon->show();   
290
291 Widget_Preview::Widget_Preview()
292 :Gtk::Table(5,5,false),
293 adj_time_scrub(0,0,1000,1,10,0),
294 scr_time_scrub(adj_time_scrub),
295 b_loop(/*_("Loop")*/),
296 adj_sound(0,0,4),
297 l_lasttime("0s"),
298 playing(false)
299 {
300         //connect to expose events
301         //signal_expose_event().connect(sigc::mem_fun(*this, &studio::Widget_Preview::redraw));
302         
303         //manage all the change in values etc...
304         adj_time_scrub.signal_value_changed().connect(sigc::mem_fun(*this,&Widget_Preview::slider_move));
305         scr_time_scrub.signal_event().connect(sigc::mem_fun(*this,&Widget_Preview::scroll_move_event));
306         draw_area.signal_expose_event().connect(sigc::mem_fun(*this,&Widget_Preview::redraw));
307         
308         disp_sound.set_time_adjustment(&adj_sound);
309         timedisp = -1;
310         
311         //Set up signals to modify time value as it should be...
312         disp_sound.signal_start_scrubbing().connect(sigc::mem_fun(*this,&Widget_Preview::scrub_updated));
313         disp_sound.signal_scrub().connect(sigc::mem_fun(*this,&Widget_Preview::scrub_updated));
314                 
315         /*
316         ---------------------------------
317         |                                                               |
318         |                                                               |
319         |                                                               |
320         |                                                               |
321         |                                                               |
322         |                                                               |
323         |                                                               |
324         ---------------------------------
325         |loop|play|stop                                 | hbox
326         |lastl|lastt|rerender|haltrend  | hbox
327         |       
328         |sound                                                  |
329         */
330         
331         Gtk::HBox *hbox = 0;
332         Gtk::Button *button = 0;
333         Gtk::Image *icon = 0;
334         
335         //should set up the dialog using attach etc.    
336         attach(draw_area, 0, 1, 0, 1);
337         attach(scr_time_scrub, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);
338         
339         #if 1
340         
341         //2nd row
342         hbox = manage(new Gtk::HBox);
343         
344         button = &b_loop;
345         IMAGIFY_BUTTON(button,Gtk::Stock::REFRESH);
346         hbox->pack_start(b_loop,Gtk::PACK_SHRINK,0);
347         //attach(b_loop,0,1,2,3,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
348         
349         button = manage(new Gtk::Button(/*_("Play")*/));
350         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::play));
351         IMAGIFY_BUTTON(button,Gtk::Stock::GO_FORWARD);
352         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
353         //attach(*button,1,2,2,3,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
354         
355         button = manage(new Gtk::Button(/*_("Stop")*/));
356         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::stop));
357         IMAGIFY_BUTTON(button,Gtk::Stock::NO);
358         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
359         //attach(*button,2,3,2,3,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
360         
361         //attack the stop render and erase all buttons to same line...
362         {
363                 Gtk::VSeparator *vsep = manage(new Gtk::VSeparator);
364                 hbox->pack_start(*vsep,Gtk::PACK_SHRINK,0);
365         }
366         
367         button = manage(new Gtk::Button(/*_("Halt Render")*/));
368         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::stoprender));
369         IMAGIFY_BUTTON(button,Gtk::Stock::STOP);
370         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
371         //attach(*button,2,3,3,4,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
372         
373         button = manage(new Gtk::Button(/*_("Re-Preview")*/));
374         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::repreview));
375         IMAGIFY_BUTTON(button,Gtk::Stock::CONVERT);
376         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
377         //attach(*button,0,2,4,5,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
378         
379         button = manage(new Gtk::Button(/*_("Erase All")*/));
380         button->signal_clicked().connect(sigc::mem_fun(*this,&Widget_Preview::eraseall));
381         //IMAGIFY_BUTTON(button,Gtk::Stock::DELETE);
382         hbox->pack_start(*button,Gtk::PACK_SHRINK,0);
383         //attach(*button,2,3,4,5,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
384         
385         hbox->show_all();
386         attach(*hbox,0,1,2,3,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK|Gtk::FILL);
387         
388         //3rd row
389         hbox = manage(new Gtk::HBox);
390         {
391                 Gtk::Label *label = manage(new Gtk::Label("Last Rendered: "));
392                 //label->show();
393                 hbox->pack_start(*label,Gtk::PACK_SHRINK,10);
394                 //attach(*manage(new Gtk::Label("Last Rendered: ")),0,1,3,4,Gtk::SHRINK,Gtk::SHRINK);
395         }
396         //l_lasttime.show();
397         hbox->pack_start(l_lasttime,Gtk::PACK_SHRINK,0);
398         hbox->show_all();
399         attach(*hbox,0,1,3,4,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
400         //attach(l_lasttime,0,1,3,4,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
401                 
402         //5th row
403         disp_sound.set_size_request(-1,32);
404         attach(disp_sound,0,1,4,5,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK);
405         
406         show_all();
407         
408         //if(draw_area.get_window()) gc_area = Gdk::GC::create(draw_area.get_window());
409         #endif
410 }
411
412 studio::Widget_Preview::~Widget_Preview()
413 {
414 }
415
416 void studio::Widget_Preview::update()
417 {
418         //the meat goes in this locker...
419         double time = adj_time_scrub.get_value();
420         
421         //find the frame and display it...
422         if(preview)
423         {
424                 //synfig::warning("Updating at %.3f s",time);           
425                 
426                 //use time to find closest frame...
427                 studio::Preview::FlipBook::const_iterator       beg = preview->begin(),end = preview->end();
428                 studio::Preview::FlipBook::const_iterator       i;
429                 
430                 i = beg;
431                 
432                 //go to current hint if need be...
433                 if(currentindex >= 0 && currentindex < (int)preview->numframes())
434                 {
435                         i = beg+currentindex;
436                 }
437                 
438                 //we can't have a picture if there are none to get
439                 if(beg != end)
440                 {                       
441                         //don't bother with binary search it will just be slower...
442                         
443                         //synfig::info("Search for time %f",time);
444                         
445                         //incrementally go in either direction 
446                         //(bias downward towards beg, because that's what we want)
447                         for(;i != end;++i)
448                         {
449                                 //synfig::info("Look at %f",i->t);
450                                 if(i->t > time) break;
451                                 //synfig::info("Go past...");
452                         }
453                         
454                         //if(i!=beg)--i; 
455                         
456                         //bias down, so we can't be at end... and it still is valid...          
457                         for(;i != beg;)
458                         {
459                                 --i;
460                                 //synfig::info("Look at %f",i->t);
461                                 if(i->t <= time) break;
462                                 //synfig::info("Go past...");
463                         }
464                         
465                         /*i = preview->begin(); end = preview->end();
466                         if(i == end) return;
467                         
468                         j = i;
469                         for(;i != end; j = i++)
470                         {
471                                 if(i->t > time) break;
472                         }*/
473                         
474                         //we should be at a valid edge since we biased downward
475                         
476                         //don't get the closest, round down... (if we can)
477                         if(i == end)
478                         {
479                                 synfig::error("i == end....");
480                                 //assert(0);
481                                 currentbuf.clear();
482                                 currentindex = 0;
483                                 timedisp = -1;
484                         }else
485                         {
486                                 currentbuf = i->buf;
487                                 currentindex = i-beg;
488                                 if(timedisp != i->t)
489                                 {
490                                         timedisp = i->t;
491                                         //synfig::warning("Update at: %f seconds (%f s)",time,timedisp);
492                                         preview_draw();
493                                         //synfig::warning("success!");                  
494                                 }
495                         }
496                 }
497         }
498         
499         if(disp_sound.get_profile() && adj_sound.get_value() != time)
500         {
501                 //timeupdate = time;
502                 
503                 //Set the position of the sound (short circuited for sound modifying the time)
504                 
505                 disp_sound.set_position(time);
506                 disp_sound.queue_draw();
507         }
508 }
509 void studio::Widget_Preview::preview_draw()
510 {
511         draw_area.queue_draw();//on_expose_event();
512 }
513
514 bool studio::Widget_Preview::redraw(GdkEventExpose *heh)
515 {       
516         //And render the drawing area
517         Glib::RefPtr<Gdk::Pixbuf> pxnew, px = currentbuf;
518         
519         if(!px || draw_area.get_height() == 0 
520                 || px->get_height() == 0 || px->get_width() == 0 /*|| is_visible()*/) //made not need this line
521                 return true;
522         
523         //figure out the scaling factors...
524         float sx, sy;
525         int nw,nh;
526
527         sx = draw_area.get_width() / (float)px->get_width();
528         sy = draw_area.get_height() / (float)px->get_height();
529         
530         //synfig::info("widget_preview redraw: now to scale the bitmap: %.3f x %.3f",sx,sy);
531         
532         //round to smallest scale (fit entire thing in window without distortion)
533         if(sx > sy) sx = sy;
534         //else sy = sx;
535         
536         //scale to a new pixmap and then copy over to the window
537         nw = (int)(px->get_width()*sx);
538         nh = (int)(px->get_height()*sx);
539         
540         if(nw == 0 || nh == 0)return true;
541                 
542         pxnew = px->scale_simple(nw,nh,Gdk::INTERP_NEAREST);
543                 
544         //synfig::info("Now to draw to the window...");
545         //copy to window
546         Glib::RefPtr<Gdk::Window>       wind = draw_area.get_window();
547         Glib::RefPtr<Gdk::Drawable> surf = Glib::RefPtr<Gdk::Drawable>::cast_static(wind);
548         Glib::RefPtr<Gdk::GC>           gc = Gdk::GC::create(wind);
549
550         {
551                 Gdk::Rectangle r(0,0,draw_area.get_width(),draw_area.get_height());
552                 draw_area.get_window()->begin_paint_rect(r);
553         }
554
555         if(!wind) synfig::warning("The destination window is broken...");
556         if(!surf) synfig::warning("The destination is not drawable...");
557         
558         if(surf)
559         {
560                 /* Options for drawing...
561                         1) store with alpha, then clear and render with alpha every frame
562                                 - more time consuming
563                                 + more expandable
564                         2) store with just pixel info
565                                 - less expandable
566                                 + faster
567                                 + better memory footprint
568                 */
569                 //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
570                 
571                 surf->draw_pixbuf(
572                         gc, //GC
573                         pxnew, //pixbuf
574                         0, 0,   // Source X and Y
575                         0, 0,   // Dest X and Y
576                         -1,-1,  // Width and Height
577                         Gdk::RGB_DITHER_NONE, // RgbDither
578                         0, 0 // Dither offset X and Y
579                 );
580                 
581                 if(timedisp >= 0)
582                 {
583                         Glib::RefPtr<Pango::Layout> layout(Pango::Layout::create(get_pango_context()));         
584                         Glib::ustring timecode(Time((double)timedisp).round(preview->get_global_fps())
585                                                                                                                         .get_string(preview->get_global_fps(),
586                                                                                                                                                         App::get_time_format()));
587                         //synfig::info("Time for preview draw is: %s for time %g", timecode.c_str(), adj_time_scrub.get_value());
588                                                                                                                                                 
589                         gc->set_rgb_fg_color(Gdk::Color("#FF0000"));
590                         layout->set_text(timecode);
591                         surf->draw_layout(gc,4,4,layout);
592                 }
593         }
594
595         draw_area.get_window()->end_paint();
596         
597         //synfig::warning("Refresh the draw area");
598         //make sure the widget refreshes
599         
600         return false;
601 }
602
603 bool studio::Widget_Preview::play_update()
604 {
605         float diff = timer.pop_time();
606         //synfig::info("Play update: diff = %.2f",diff);
607         
608         if(playing)
609         {
610                 //we go to the next one...
611                 double time = adj_time_scrub.get_value() + diff;
612                 
613                 //adjust it to be synced with the audio if it can...
614                 {
615                         double newtime = audiotime;
616                         if(audio && audio->is_playing()) audio->get_current_time(newtime);
617                                 
618                         if(newtime != audiotime)
619                         {
620                                 //synfig::info("Adjusted time from %.3lf to %.3lf", time,newtime);
621                                 time = audiotime = newtime;
622                         }
623                 }
624                 
625                 //Looping conditions...
626                 if(time >= adj_time_scrub.get_upper())
627                 {
628                         if(get_loop_flag())
629                         {
630                                 time = adj_time_scrub.get_lower();// + time-adj_time_scrub.get_upper();
631                                 currentindex = 0;
632                         }else
633                         {
634                                 time = adj_time_scrub.get_upper();
635                                 adj_time_scrub.set_value(time);
636                                 play_stop();
637                                 update();
638                                 
639                                 //synfig::info("Play Stopped: time set to %f",adj_time_scrub.get_value());
640                                 return false;
641                         }
642                 }
643                 
644                 //set the new time...
645                 adj_time_scrub.set_value(time);
646                 adj_time_scrub.value_changed();
647                 
648                 //update the window to the correct image we might want to do this later...
649                 //update();
650                 //synfig::warning("Did update pu");
651         }
652         return true;
653 }
654
655 void studio::Widget_Preview::slider_move()
656 {
657         //if(!playing)
658         {
659                 update();
660                 //synfig::warning("Did update sm");
661         }
662 }
663
664 //for other things updating the value changed signal...
665 void studio::Widget_Preview::scrub_updated(double t)
666 {
667         stop();
668         
669         //Attempt at being more accurate... the time is adjusted to be exactly where the sound says it is
670         //double oldt = t;
671         if(audio)
672         {
673                 if(!audio->isPaused()) 
674                 {
675                         audio->get_current_time(t);
676                 }
677         }
678         
679         //synfig::info("Scrubbing to %.3f, setting adj to %.3f",oldt,t);
680                         
681         if(adj_time_scrub.get_value() != t)
682         {
683                 adj_time_scrub.set_value(t);
684                 adj_time_scrub.value_changed();
685         }
686 }
687         
688 void studio::Widget_Preview::disconnect_preview(Preview *prev)
689 {
690         if(prev == preview)
691         {
692                 preview = 0;
693                 prevchanged.disconnect();
694         }
695 }
696
697 void studio::Widget_Preview::set_preview(handle<Preview>        prev)
698 {
699         preview = prev;
700         
701         synfig::info("Setting preview");
702         
703         //stop playing the mini animation...
704         stop();
705         
706         if(preview)
707         {
708                 //set the internal values
709                 float rate = preview->get_fps();
710                 synfig::info("  FPS = %f",rate);
711                 if(rate)
712                 {
713                         float start = preview->get_begintime();
714                         float end = preview->get_endtime();
715                         
716                         rate = 1/rate;
717                         
718                         adj_time_scrub.set_lower(start);
719                         adj_time_scrub.set_upper(end);
720                         adj_time_scrub.set_value(start);
721                         adj_time_scrub.set_step_increment(rate);
722                         adj_time_scrub.set_page_increment(10*rate);
723                         
724                         //if the begin time and the end time are the same there is only a single frame
725                         singleframe = end==start;
726                 }else
727                 {
728                         adj_time_scrub.set_lower(0);
729                         adj_time_scrub.set_upper(0);
730                         adj_time_scrub.set_value(0);
731                         adj_time_scrub.set_step_increment(0);
732                         adj_time_scrub.set_page_increment(0);                   
733                         singleframe = true;
734                 }
735                 
736                 //connect so future information will be found...
737                 prevchanged = prev->signal_changed().connect(sigc::mem_fun(*this,&Widget_Preview::whenupdated));
738                 prev->signal_destroyed().connect(sigc::mem_fun(*this,&Widget_Preview::disconnect_preview));
739                 update();
740                 //synfig::warning("Did update sp");
741                 queue_draw();
742         }
743 }
744
745 void studio::Widget_Preview::whenupdated()
746 {
747         l_lasttime.set_text((Time((double)(--preview->end())->t)
748                                                         .round(preview->get_global_fps())
749                                                         .get_string(preview->get_global_fps(),App::get_time_format())));
750         update();
751 }
752
753 void studio::Widget_Preview::clear()
754 {
755         preview = 0;
756         prevchanged.disconnect();
757 }
758
759 void studio::Widget_Preview::play()
760 {
761         if(preview && !playing)
762         {
763                 //synfig::info("Playing at %lf",adj_time_scrub.get_value());
764                 //audiotime = adj_time_scrub.get_value();
765                 playing = true;
766
767                 //adj_time_scrub.set_value(adj_time_scrub.get_lower());         
768                 update(); //we don't want to call play update because that will try to advance the timer
769                 //synfig::warning("Did update p");
770                 
771                 //approximate length of time in seconds, right?
772                 double rate = /*std::min(*/adj_time_scrub.get_step_increment()/*,1/30.0)*/;
773                 int timeout = (int)floor(1000*rate);
774                 
775                 //synfig::info("        rate = %.3lfs = %d ms",rate,timeout);
776                 
777                 signal_play_(adj_time_scrub.get_value());
778                 
779                 //play the audio...
780                 if(audio) audio->play(adj_time_scrub.get_value());
781                                 
782                 timecon = Glib::signal_timeout().connect(sigc::mem_fun(*this,&Widget_Preview::play_update),timeout);            
783                 timer.reset();          
784         }
785         
786 }
787
788 void studio::Widget_Preview::play_stop()
789 {
790         playing = false;
791         signal_stop()();
792         if(audio) audio->stop(); //!< stop the audio
793         //synfig::info("Stopping...");
794 }
795
796 void studio::Widget_Preview::stop()
797 {
798         //synfig::warning("stopping");
799         play_stop();
800         timecon.disconnect();
801 }
802
803 bool studio::Widget_Preview::scroll_move_event(GdkEvent *event)
804 {
805         switch(event->type)
806         {
807                 case GDK_BUTTON_PRESS:
808                 {
809                         if(event->button.button == 1 || event->button.button == 3)
810                         {
811                                 stop();
812                         }
813                 }
814                 
815                 default: break;
816         }
817         
818         return false;
819 }
820
821 void studio::Widget_Preview::set_audioprofile(etl::handle<AudioProfile> p)
822 {
823         disp_sound.set_profile(p);
824 }
825
826 void studio::Widget_Preview::set_audio(etl::handle<AudioContainer> a)
827 {
828         audio = a;
829         
830         //disconnect any previous signals
831         scrstartcon.disconnect(); scrstopcon.disconnect(); scrubcon.disconnect();
832                 
833         //connect the new signals
834         scrstartcon = disp_sound.signal_start_scrubbing().connect(sigc::mem_fun(*a,&AudioContainer::start_scrubbing));
835         scrstopcon = disp_sound.signal_stop_scrubbing().connect(sigc::mem_fun(*a,&AudioContainer::stop_scrubbing));
836         scrubcon = disp_sound.signal_scrub().connect(sigc::mem_fun(*a,&AudioContainer::scrub));
837 }
838
839 void studio::Widget_Preview::seek(float t)
840 {
841         stop();
842         adj_time_scrub.set_value(t);
843 }
844
845 void studio::Widget_Preview::repreview()
846 {
847         if(preview)
848         {
849                 stoprender();
850                 stop();
851                 preview->get_canvasview()->preview_option();
852         }
853 }
854
855 void studio::Widget_Preview::stoprender()
856 {
857         if(preview)
858         {
859                 preview->renderer.detach();
860         }
861 }
862         
863 void studio::Widget_Preview::eraseall()
864 {
865         stop();
866         stoprender();
867         
868         currentbuf.clear();
869         currentindex = 0;
870         timedisp = 0;
871         queue_draw();
872         
873         if(preview)
874         {
875                 preview->clear();
876         }
877 }