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 }