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 }