**
** \legal
** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
-** Copyright 2006 Yue Shi Lai
+** Copyright (c) 2006 Yue Shi Lai
+** Copyright (c) 2007, 2008 Chris Moore
**
** This package is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License as
#include <synfig/mutex.h>
+#include "general.h"
+
#endif
/* === U S I N G =========================================================== */
synfig::Mutex mutex;
- void set_onion_skin(bool x)
+ void set_onion_skin(bool x, int *onions)
{
onionskin=x;
Time time(rend_desc().get_time_start());
+ if(!onionskin)
+ return;
onion_skin_queue.push_back(time);
- //onion_skin_queue.push_back(time-1);
- //onion_skin_queue.push_back(time+1);
try
{
- onion_skin_queue.push_back(
- get_canvas()->keyframe_list().find_prev(
- time
- )->get_time()
- );
+ Time thistime=time;
+ for(int i=0; i<onions[0]; i++)
+ {
+ Time keytime=get_canvas()->keyframe_list().find_prev(thistime)->get_time();
+ onion_skin_queue.push_back(keytime);
+ thistime=keytime;
+ }
}
catch(...)
{ }
try
{
- onion_skin_queue.push_back(
- get_canvas()->keyframe_list().find_next(
- time
- )->get_time()
- );
+ Time thistime=time;
+ for(int i=0; i<onions[1]; i++)
+ {
+ Time keytime=get_canvas()->keyframe_list().find_next(thistime)->get_time();
+ onion_skin_queue.push_back(keytime);
+ thistime=keytime;
+ }
}
catch(...)
{ }
set_clipping(true);
if(low_res)
{
- set_tile_w(workarea->tile_w/2);
- set_tile_h(workarea->tile_h/2);
+ int div = workarea->get_low_res_pixel_size();
+ set_tile_w(workarea->tile_w/div);
+ set_tile_h(workarea->tile_h/div);
}
else
{
{
assert(workarea);
newdesc->set_flags(RendDesc::PX_ASPECT|RendDesc::IM_SPAN);
- if(low_res)
- newdesc->set_wh(w/2,h/2);
+ if(low_res) {
+ int div = workarea->get_low_res_pixel_size();
+ newdesc->set_wh(w/div,h/div);
+ }
else
newdesc->set_wh(w,h);
int w(get_tile_w());
int h(get_tile_h());
int x(surface.get_w()*surface.get_h());
- //if(low_res) { w/=2,h/=2; }
+ //if(low_res) {
+ // int div = workarea->get_low_res_pixel_size();
+ // w/=div,h/=div;
+ //}
Color dark(0.6,0.6,0.6);
Color lite(0.8,0.8,0.8);
for(int i=0;i<x;i++)
if(low_res)
{
// We need to scale up
+ int div = workarea->get_low_res_pixel_size();
pixbuf=pixbuf->scale_simple(
- surface.get_w()*2,
- surface.get_h()*2,
+ surface.get_w()*div,
+ surface.get_h()*div,
Gdk::INTERP_NEAREST
);
}
std::list<synfig::Time> onion_skin_queue;
- void set_onion_skin(bool x)
+ void set_onion_skin(bool x, int *onions)
{
onionskin=x;
Time time(rend_desc().get_time_start());
+ if(!onionskin)
+ return;
onion_skin_queue.push_back(time);
//onion_skin_queue.push_back(time-1);
//onion_skin_queue.push_back(time+1);
- if(!onionskin)
- return;
-
try
{
- onion_skin_queue.push_back(
- get_canvas()->keyframe_list().find_prev(
- time
- )->get_time()
- );
+ Time thistime=time;
+ for(int i=0; i<onions[0]; i++)
+ {
+ Time keytime=get_canvas()->keyframe_list().find_prev(thistime)->get_time();
+ onion_skin_queue.push_back(keytime);
+ thistime=keytime;
+ }
}
catch(...)
{ }
try
{
- onion_skin_queue.push_back(
- get_canvas()->keyframe_list().find_next(
- time
- )->get_time()
- );
+ Time thistime=time;
+ for(int i=0; i<onions[1]; i++)
+ {
+ Time keytime=get_canvas()->keyframe_list().find_next(thistime)->get_time();
+ onion_skin_queue.push_back(keytime);
+ thistime=keytime;
+ }
}
catch(...)
{ }
assert(workarea);
newdesc->set_flags(RendDesc::PX_ASPECT|RendDesc::IM_SPAN);
if(low_res)
- newdesc->set_wh(w/2,h/2);
+ {
+ int div = workarea->get_low_res_pixel_size();
+ newdesc->set_wh(w/div,h/div);
+ }
else
newdesc->set_wh(w,h);
int w(surface.get_w());
//int h(surface.get_h());
int x(surface.get_w()*surface.get_h());
- //if(low_res) { w/=2,h/=2; }
+ //if(low_res) {
+ // int div = workarea->get_low_res_pixel_size();
+ // w/=div,h/=div;
+ //}
Color dark(0.6,0.6,0.6);
Color lite(0.8,0.8,0.8);
int tw=workarea->tile_w;
int th=workarea->tile_h;
if(low_res)
{
- tw/=2;
- th/=2;
+ int div = workarea->get_low_res_pixel_size();
+ tw/=div;
+ th/=div;
}
for(int i=0;i<x;i++)
dest=Color2PixelFormat(
if(low_res)
{
// We need to scale up
+ int div = workarea->get_low_res_pixel_size();
pixbuf=pixbuf->scale_simple(
- surface.get_w()*2,
- surface.get_h()*2,
+ surface.get_w()*div,
+ surface.get_h()*div,
Gdk::INTERP_NEAREST
);
}
canvas(canvas_interface->get_canvas()),
scrollx_adjustment(0,-4,4,0.01,0.1),
scrolly_adjustment(0,-4,4,0.01,0.1),
- w(128),
- h(128),
+ w(TILE_SIZE),
+ h(TILE_SIZE),
last_event_time(0),
progresscallback(0),
dragging(DRAG_NONE),
show_grid(false),
- tile_w(128),
- tile_h(128)
+ tile_w(TILE_SIZE),
+ tile_h(TILE_SIZE),
+ timecode_width(0),
+ timecode_height(0)
{
show_guides=true;
curr_input_device=0;
render_idle_func_id=0;
zoom=prev_zoom=1.0;
quality=10;
+ low_res_pixel_size=2;
rendering=false;
canceled_=false;
low_resolution=true;
ph=0.001;
last_focus_point=Point(0,0);
onion_skin=false;
+ onion_skins[0]=0;
+ onion_skins[1]=0;
queued=false;
dirty_trap_enabled=false;
solid_lines=true;
WorkArea::~WorkArea()
{
// delete [] buffer;
+
+ // don't leave the render function queued if we are about to vanish;
+ // that causes crashes
+ if(render_idle_func_id)
+ render_idle_func_id=0;
+}
+
+#ifdef SINGLE_THREADED
+bool
+WorkArea::get_updating()const
+{
+ return App::single_threaded && async_renderer && async_renderer->updating;
}
+#endif
+
+#ifdef SINGLE_THREADED
+void
+WorkArea::stop_updating(bool cancel)
+{
+ async_renderer->stop();
+ if (cancel) canceled_=true;
+}
+#endif
void
WorkArea::save_meta_data()
if(!tmp.empty())
gx=stratof(tmp);
+ else
+ synfig::error("WorkArea::load_meta_data(): Unable to parse data for \"grid_size\", which was \"%s\"",data.c_str());
if(iter==data.end())
tmp.clear();
if(!tmp.empty())
gy=stratof(tmp);
+ else
+ synfig::error("WorkArea::load_meta_data(): Unable to parse data for \"grid_size\", which was \"%s\"",data.c_str());
set_grid_size(Vector(gx,gy));
}
- else
- synfig::error("WorkArea::load_meta_data(): Unable to parse data for \"grid_size\", which was \"%s\"",data.c_str());
data=canvas->get_meta_data("grid_show");
if(data.size() && (data=="1" || data[0]=='t' || data[0]=='T'))
return onion_skin;
}
+void WorkArea::set_onion_skins(int *onions)
+{
+ onion_skins[0]=onions[0];
+ onion_skins[1]=onions[1];
+ if(onion_skin)
+ queue_render_preview();
+}
+
void
WorkArea::enable_grid()
{
WorkArea::set_focus_point(const synfig::Point &point)
{
// These next three lines try to ensure that we place the
- // focus on a pixel boundry
+ // focus on a pixel boundary
/*Point adjusted(point[0]/abs(get_pw()),point[1]/abs(get_ph()));
adjusted[0]=(abs(adjusted[0]-floor(adjusted[0]))<0.5)?floor(adjusted[0])*abs(get_pw()):ceil(adjusted[0])*abs(get_ph());
adjusted[1]=(abs(adjusted[1]-floor(adjusted[1]))<0.5)?floor(adjusted[1])*abs(get_ph()):ceil(adjusted[1])*abs(get_ph());
break;
}
- synfigapp::Action::PassiveGrouper grouper(instance.get(),"Nudge");
+ synfigapp::Action::PassiveGrouper grouper(instance.get(),_("Nudge"));
// Grid snap does not apply to nudging
bool grid_snap_holder(get_grid_snap());
bool is_mouse(false);
Gdk::ModifierType modifier(Gdk::ModifierType(0));
- drawing_area->grab_focus();
-
// Handle input stuff
if(
event->any.type==GDK_MOTION_NOTIFY ||
{
device=event->button.device;
modifier=Gdk::ModifierType(event->button.state);
+ drawing_area->grab_focus();
}
- // Make sure we recognise the device
+ // Make sure we recognize the device
if(curr_input_device)
{
if(curr_input_device!=device)
// GDK mouse scrolling events
else if(event->any.type==GDK_SCROLL)
{
- // GDK information needed to properly interprete mouse
+ // GDK information needed to properly interpret mouse
// scrolling events are: scroll.state, scroll.x/scroll.y, and
// scroll.direction. The value of scroll.direction will be
// obtained later.
selected_bezier=find_bezier(mouse_pos,radius,&bezier_click_pos);
- if(duck && duck->get_editable())
+ if(duck)
{
+ if (!duck->get_editable())
+ return true;
+
//get_selected_duck()->signal_user_click(0)();
//if(clicked_duck)clicked_duck->signal_user_click(0)();
// if the tangent isn't split, then split it
if (!((*(parent_value_node->get_link("split")))(get_time()).get(bool())))
{
- get_canvas_view()->canvas_interface()->
+ if (get_canvas_view()->canvas_interface()->
change_value(synfigapp::ValueDesc(parent_value_node,
parent_value_node->get_link_index_from_name("split")),
- true);
- // rebuild the ducks from scratch, so the tangents ducks aren't connected
- get_canvas_view()->rebuild_ducks();
-
- // reprocess the mouse click
- return on_drawing_area_event(event);
+ true))
+ {
+ // rebuild the ducks from scratch, so the tangents ducks aren't connected
+ get_canvas_view()->rebuild_ducks();
+
+ // reprocess the mouse click
+ return on_drawing_area_event(event);
+ }
+ else
+ return true;
}
} else {
// I don't know how to access the vertex from the tangent duck when originally drawing the bline in the bline tool
if(get_selected_ducks().size()<=1)
duck->signal_user_click(2)();
else
- {
canvas_view->get_smach().process_event(EventMouse(EVENT_WORKAREA_MULTIPLE_DUCKS_CLICKED,BUTTON_RIGHT,mouse_pos,pressure,modifier));
- }
return true;
}
- else
- if(bezier)
+ else if(bezier)
{
bezier->signal_user_click(2)(bezier_click_pos);
return true;
}
- else
- if(layer)
+ else if (layer)
{
if(canvas_view->get_smach().process_event(EventLayerClick(layer,BUTTON_RIGHT,mouse_pos))==Smach::RESULT_OK)
return false;
signal_cursor_moved_();
- // Guide/Duck hilights on hover
+ // Guide/Duck highlights on hover
if(dragging==DRAG_NONE)
{
GuideList::iterator iter;
drawing_area->queue_draw();
}
+
if(dragging==DRAG_BOX)
{
curr_point=mouse_pos;
drawing_area->queue_draw();
}
+
if(dragging==DRAG_GUIDE)
{
if(curr_guide_is_x)
*curr_guide=mouse_pos[1];
drawing_area->queue_draw();
}
+
if(dragging!=DRAG_WINDOW)
{ // Update those triangle things on the rulers
const synfig::Point point(mouse_pos);
hruler->property_position()=Distance(point[0],Distance::SYSTEM_UNITS).get(App::distance_system,get_canvas()->rend_desc());
vruler->property_position()=Distance(point[1],Distance::SYSTEM_UNITS).get(App::distance_system,get_canvas()->rend_desc());
}
- if(dragging==DRAG_WINDOW)
- {
- set_focus_point(get_focus_point()+mouse_pos-drag_point);
- }
- else
- if(event->motion.state&GDK_BUTTON1_MASK && canvas_view->get_smach().process_event(EventMouse(EVENT_WORKAREA_MOUSE_BUTTON_DRAG,BUTTON_LEFT,mouse_pos,pressure,modifier))==Smach::RESULT_ACCEPT)
+
+ if(dragging == DRAG_WINDOW)
+ set_focus_point(get_focus_point() + mouse_pos-drag_point);
+ else if (event->motion.state & GDK_BUTTON1_MASK &&
+ canvas_view->get_smach().process_event(EventMouse(EVENT_WORKAREA_MOUSE_BUTTON_DRAG, BUTTON_LEFT,
+ mouse_pos,pressure,modifier)) == Smach::RESULT_ACCEPT)
return true;
- else
- if(event->motion.state&GDK_BUTTON2_MASK && canvas_view->get_smach().process_event(EventMouse(EVENT_WORKAREA_MOUSE_BUTTON_DRAG,BUTTON_MIDDLE,mouse_pos,pressure,modifier))==Smach::RESULT_ACCEPT)
+ else if (event->motion.state & GDK_BUTTON2_MASK &&
+ canvas_view->get_smach().process_event(EventMouse(EVENT_WORKAREA_MOUSE_BUTTON_DRAG, BUTTON_MIDDLE,
+ mouse_pos, pressure, modifier)) == Smach::RESULT_ACCEPT)
return true;
- else
- if(event->motion.state&GDK_BUTTON3_MASK && canvas_view->get_smach().process_event(EventMouse(EVENT_WORKAREA_MOUSE_BUTTON_DRAG,BUTTON_RIGHT,mouse_pos,pressure,modifier))==Smach::RESULT_ACCEPT)
+ else if (event->motion.state & GDK_BUTTON3_MASK &&
+ canvas_view->get_smach().process_event(EventMouse(EVENT_WORKAREA_MOUSE_BUTTON_DRAG, BUTTON_RIGHT,
+ mouse_pos, pressure, modifier)) == Smach::RESULT_ACCEPT)
return true;
- else
- if(canvas_view->get_smach().process_event(EventMouse(EVENT_WORKAREA_MOUSE_MOTION,BUTTON_NONE,mouse_pos,pressure,modifier))==Smach::RESULT_ACCEPT)
+ else if(canvas_view->get_smach().process_event(EventMouse(EVENT_WORKAREA_MOUSE_MOTION, BUTTON_NONE,
+ mouse_pos, pressure,modifier)) == Smach::RESULT_ACCEPT)
return true;
break;
+
case GDK_BUTTON_RELEASE:
{
bool ret(false);
else
if(dragging==DRAG_DUCK)
{
- synfigapp::Action::PassiveGrouper grouper(instance.get(),"Move");
+ synfigapp::Action::PassiveGrouper grouper(instance.get(),_("Move"));
dragging=DRAG_NONE;
//translate_selected_ducks(mouse_pos);
set_axis_lock(false);
switch(event->type)
{
case GDK_BUTTON_PRESS:
- DEBUGPOINT();
if(dragging==DRAG_NONE)
{
- DEBUGPOINT();
dragging=DRAG_GUIDE;
curr_guide=get_guide_list_x().insert(get_guide_list_x().begin());
curr_guide_is_x=true;
return true;
break;
case GDK_BUTTON_RELEASE:
- DEBUGPOINT();
if(dragging==DRAG_GUIDE && curr_guide_is_x==true)
{
- DEBUGPOINT();
dragging=DRAG_NONE;
get_guide_list_x().erase(curr_guide);
}
x(focus_point[0]/pw+drawing_area->get_width()/2-w/2),
y(focus_point[1]/ph+drawing_area->get_height()/2-h/2);
- const int width_in_tiles(w/tile_w+(w%tile_w?1:0));
+ int div = low_res_pixel_size;
+ const int width_in_tiles(w/tile_w+((low_resolution?((w/div)%(tile_w/div)):(w%tile_w))?1:0));
const int height_in_tiles(h/tile_h+(h%tile_h?1:0));
int
}
}
-
// Calculate the window coordinates of the top-left
// corner of the canvas.
//const synfig::Vector::value_type
Glib::RefPtr<Gdk::GC> gc=Gdk::GC::create(drawing_area->get_window());
-
-
// If we are in animate mode, draw a red border around the screen
if(canvas_interface->get_mode()&synfigapp::MODE_ANIMATE)
{
- /*gc->set_rgb_fg_color(Gdk::Color("#FF0000"));
+// #define USE_FRAME_BACKGROUND_TO_SHOW_EDIT_MODE
+#ifdef USE_FRAME_BACKGROUND_TO_SHOW_EDIT_MODE
+ // This method of drawing the red border doesn't work on any
+ // Gtk theme which uses the crux-engine, hcengine, industrial,
+ // mist, or ubuntulooks engine, such as the default ubuntu
+ // 'Human' theme.
+ drawing_frame->modify_bg(Gtk::STATE_NORMAL,Gdk::Color("#FF0000"));
+#else
+ // So let's do it in a more primitive fashion.
+ gc->set_rgb_fg_color(Gdk::Color("#FF0000"));
gc->set_line_attributes(1,Gdk::LINE_SOLID,Gdk::CAP_BUTT,Gdk::JOIN_MITER);
drawing_area->get_window()->draw_rectangle(
gc,
false, // Fill?
0,0, // x,y
- drawing_area->get_width()-1,drawing_area->get_height()-1 //w,h
- );
- */
- drawing_frame->modify_bg(Gtk::STATE_NORMAL,Gdk::Color("#FF0000"));
- //get_window()->set_background(Gdk::Color("#FF0000"));
+ drawing_area->get_width()-1,drawing_area->get_height()-1); // w,h
+#endif
}
+#ifdef USE_FRAME_BACKGROUND_TO_SHOW_EDIT_MODE
else
drawing_frame->unset_bg(Gtk::STATE_NORMAL);
-
-
-
- previous_focus=get_focus_point();
+#endif
return true;
}
queue_render_preview();
}
+void
+WorkArea::set_low_res_pixel_size(int x)
+{
+ if(x==low_res_pixel_size)
+ return;
+ low_res_pixel_size=x;
+ queue_render_preview();
+}
namespace studio
{
bool
studio::WorkArea::async_update_preview()
{
+#ifdef SINGLE_THREADED
+ if (get_updating())
+ {
+ stop_updating();
+ queue_render_preview();
+ return false;
+ }
+#endif
+
async_renderer=0;
queued=false;
int w=(int)(desc.get_w()*zoom);
int h=(int)(desc.get_h()*zoom);
+ // ensure that the size we draw is at least one pixel in each dimension
+ int min_size = low_resolution ? low_res_pixel_size : 1;
+ if (w < min_size) w = min_size;
+ if (h < min_size) h = min_size;
+
// Setup the description parameters
desc.set_antialias(1);
desc.set_time(cur_time);
// Create the render target
handle<Target> target;
- if(w*h>(low_resolution?480*270:480*270/2))
+ // if we have lots of pixels to render and the tile renderer isn't disabled, use it
+ int div;
+ div = low_resolution ? low_res_pixel_size : 1;
+ if ((w*h > 240*div*135*div && !getenv("SYNFIG_DISABLE_TILE_RENDER")) || getenv("SYNFIG_FORCE_TILE_RENDER"))
{
+ // do a tile render
handle<WorkAreaTarget> trgt(new class WorkAreaTarget(this,w,h));
trgt->set_rend_desc(&desc);
- trgt->set_onion_skin(get_onion_skin());
+ trgt->set_onion_skin(get_onion_skin(), onion_skins);
target=trgt;
}
else
{
+ // do a scanline render
handle<WorkAreaTarget_Full> trgt(new class WorkAreaTarget_Full(this,w,h));
trgt->set_rend_desc(&desc);
- trgt->set_onion_skin(get_onion_skin());
+ trgt->set_onion_skin(get_onion_skin(), onion_skins);
target=trgt;
}
synfig::ProgressCallback *cb=get_canvas_view()->get_ui_interface().get();
rendering=true;
- cb->task("Rendering...");
+ cb->task(_("Rendering..."));
rendering=true;
return true;
{
dirty=false;
//queued=false;
- cb->task("Idle");
+ cb->task(_("Idle"));
}
else
{
dirty=true;
- cb->task("Render Failed");
+ cb->task(_("Render Failed"));
}
//get_canvas_view()->reset_cancel_status();
done_rendering();
target->set_avoid_time_sync(true);
if(cb)
- cb->task(strprintf("Rendering canvas %s...",get_canvas()->get_name().c_str()));
+ cb->task(strprintf(_("Rendering canvas %s..."),get_canvas()->get_name().c_str()));
bool ret = target->render(cb);
if(cb)
{
if(ret)
- cb->task("Idle");
+ cb->task(_("Idle"));
else
- cb->task("Render Failed");
+ cb->task(_("Render Failed"));
cb->amount_complete(0,1);
}
}
void
-studio::WorkArea::async_render_preview(Time time)
+studio::WorkArea::async_render_preview(synfig::Time time)
{
cur_time=time;
//tile_book.clear();
}
bool
-studio::WorkArea::sync_render_preview(Time time)
+studio::WorkArea::sync_render_preview(synfig::Time time)
{
cur_time=time;
//tile_book.clear();
drawing_area->get_window()->scroll(-dx,-dy);
- /*drawing_area->queue_draw_area(
- 0,
- 0,
- 128,
- 64
- );
- */
+ if (timecode_width && timecode_height)
+ {
+ drawing_area->queue_draw_area(4, 4, 4+timecode_width, 4+timecode_height);
+ drawing_area->queue_draw_area(4-dx, 4-dy, 4-dx+timecode_width, 4-dy+timecode_height);
+ }
+
+#ifndef USE_FRAME_BACKGROUND_TO_SHOW_EDIT_MODE
+ if(canvas_interface->get_mode()&synfigapp::MODE_ANIMATE)
+ {
+ int maxx = drawing_area->get_width()-1;
+ int maxy = drawing_area->get_height()-1;
+
+ if (dx > 0)
+ {
+ drawing_area->queue_draw_area( 0, 0, 1, maxy);
+ drawing_area->queue_draw_area(maxx-dx, 0, maxx-dx, maxy);
+ }
+ else if (dx < 0)
+ {
+ drawing_area->queue_draw_area( maxx, 0, maxx, maxy);
+ drawing_area->queue_draw_area( -dx, 0, -dx, maxy);
+ }
+ if (dy > 0)
+ {
+ drawing_area->queue_draw_area(0, 0, maxx, 1);
+ drawing_area->queue_draw_area(0, maxy-dy, maxx, maxy-dy);
+ }
+ else if (dy < 0)
+ {
+ drawing_area->queue_draw_area(0, maxy, maxx, maxy);
+ drawing_area->queue_draw_area(0, -dy, maxx, -dy);
+ }
+ }
+#endif // USE_FRAME_BACKGROUND_TO_SHOW_EDIT_MODE
+
last_focus_point=focus_point;
}
void
studio::WorkArea::zoom_fit()
{
- // This really doesn't zoom to fit. Bug.
- zoom_norm();
+ float new_zoom(min(drawing_area->get_width() * zoom / w,
+ drawing_area->get_height() * zoom / h) * 0.995);
+ if (zoom / new_zoom > 0.995 && new_zoom / zoom > 0.995)
+ {
+ set_zoom(prev_zoom);
+ return set_focus_point(previous_focus);
+ }
+ previous_focus = get_focus_point();
+ prev_zoom = zoom;
+ set_zoom(new_zoom);
+ set_focus_point(Point(0,0));
}
void
studio::WorkArea::zoom_norm()
{
- if(zoom==1.0)
- set_zoom(prev_zoom);
- else
- {
- prev_zoom=zoom;
- set_zoom(1.0f);
- }
+ if (zoom == 1.0) return set_zoom(prev_zoom);
+ prev_zoom = zoom;
+ set_zoom(1.0f);
}
gboolean
studio::WorkArea::__render_preview(gpointer data)
{
-
WorkArea *work_area(static_cast<WorkArea*>(data));
+ // there's no point anyone trying to cancel the timer now - it's gone off already
+ work_area->render_idle_func_id = 0;
+
work_area->queued=false;
work_area->async_render_preview(work_area->get_canvas_view()->get_time());
//synfig::info("queue_render_preview(): (re)queuing...");
//render_idle_func_id=g_idle_add_full(G_PRIORITY_DEFAULT,__render_preview,this,NULL);
render_idle_func_id=g_timeout_add_full(
- G_PRIORITY_DEFAULT, // priority -
+ G_PRIORITY_DEFAULT, // priority -
queue_time, // interval - the time between calls to the function, in milliseconds (1/1000ths of a second)
__render_preview, // function - function to call
this, // data - data to pass to function
drawing_area->get_window()->set_cursor(Gdk::Cursor(x));
}
-#include "iconcontroler.h"
+#include "iconcontroller.h"
void
studio::WorkArea::refresh_cursor()
{
-// set_cursor(IconControler::get_tool_cursor(canvas_view->get_smach().get_state_name(),drawing_area->get_window()));
+// set_cursor(IconController::get_tool_cursor(canvas_view->get_smach().get_state_name(),drawing_area->get_window()));
}
void