# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
-EXCLUDE =
+EXCLUDE = src/template.cpp src/template.h
# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
# directories that are symbolic links (a Unix filesystem feature) are excluded
}
etl::loose_handle<Instance>
-App::get_instance(Canvas::Handle canvas)
+App::get_instance(etl::handle<synfig::Canvas> canvas)
{
if(!canvas) return 0;
canvas=canvas->get_root();
if(imp) delete (imp);
}
-bool studio::AudioContainer::load(const string &filename,const string &filedirectory)
+bool studio::AudioContainer::load(const std::string &filename,const std::string &filedirectory)
{
if(!imp)
{
}
#ifdef WITH_FMOD
-void AudioContainer::AudioImp::start_scrubbing(double t)
+void studio::AudioContainer::AudioImp::start_scrubbing(double t)
#else
-void AudioContainer::AudioImp::start_scrubbing(double /*t*/)
+void studio::AudioContainer::AudioImp::start_scrubbing(double /*t*/)
#endif
{
//synfig::info("Start scrubbing: %lf", t);
#endif
}
-void AudioContainer::AudioImp::stop_scrubbing()
+void studio::AudioContainer::AudioImp::stop_scrubbing()
{
//synfig::info("Stop scrubbing");
}
#ifdef WITH_FMOD
-void AudioContainer::AudioImp::scrub(double t)
+void studio::AudioContainer::AudioImp::scrub(double t)
#else
-void AudioContainer::AudioImp::scrub(double /*t*/)
+void studio::AudioContainer::AudioImp::scrub(double /*t*/)
#endif
{
#ifdef WITH_FMOD
/* === M E T H O D S ======================================================= */
-CanvasOptions::CanvasOptions(loose_handle<studio::CanvasView> canvas_view):
+CanvasOptions::CanvasOptions(etl::loose_handle<CanvasView> canvas_view):
Gtk::Dialog(_("Canvas Options"),*canvas_view,false,true),
canvas_view_(canvas_view),
toggle_grid_snap(_("_Snap to grid"), true),
/* === M E T H O D S ======================================================= */
-CanvasProperties::CanvasProperties(Gtk::Window& parent,handle<synfigapp::CanvasInterface> canvas_interface):
+CanvasProperties::CanvasProperties(Gtk::Window& parent,etl::handle<synfigapp::CanvasInterface> canvas_interface):
Gtk::Dialog(_("Canvas Properties"),parent,false,true),
canvas_interface_(canvas_interface)
{
}
bool
-CanvasTreeStore::find_first_value_node(const ValueNode::Handle& value_node, Gtk::TreeIter& iter)
+CanvasTreeStore::find_first_value_node(const synfig::ValueNode::Handle& value_node, Gtk::TreeIter& iter)
{
iter=children().begin();
while(iter && value_node!=(ValueNode::Handle)(*iter)[model.value_node])
}
bool
-CanvasTreeStore::find_next_value_node(const ValueNode::Handle& value_node, Gtk::TreeIter& iter)
+CanvasTreeStore::find_next_value_node(const synfig::ValueNode::Handle& value_node, Gtk::TreeIter& iter)
{
if(!iter) return find_first_value_node(value_node,iter);
}
handle<CanvasView>
-CanvasView::create(loose_handle<Instance> instance,handle<Canvas> canvas)
+CanvasView::create(etl::loose_handle<Instance> instance, etl::handle<synfig::Canvas> canvas)
{
etl::handle<studio::CanvasView> view(new CanvasView(instance,instance->synfigapp::Instance::find_canvas_interface(canvas)));
instance->canvas_view_list().push_front(view);
}
bool
-CanvasView::duck_change_param(const Point &value,synfig::Layer::Handle layer, synfig::String param_name)
+CanvasView::duck_change_param(const synfig::Point &value,synfig::Layer::Handle layer, synfig::String param_name)
{
return canvas_interface()->change_value(synfigapp::ValueDesc(layer,param_name),value);
}
}
void
-CanvasView::selected_layer_color_set(Color color)
+CanvasView::selected_layer_color_set(synfig::Color color)
{
synfigapp::SelectionManager::LayerList selected_list(get_selection_manager()->get_selected_layers());
synfigapp::SelectionManager::LayerList::iterator iter;
}
void
-CanvasView::rebuild_ducks_layer_(synfig::TransformStack& transform_stack, Canvas::Handle canvas, std::set<synfig::Layer::Handle>& selected_list)
+CanvasView::rebuild_ducks_layer_(synfig::TransformStack& transform_stack, synfig::Canvas::Handle canvas, std::set<synfig::Layer::Handle>& selected_list)
{
int transforms(0);
String layer_name;
}
void
-CanvasView::on_audio_offset_change(const Time &t)
+CanvasView::on_audio_offset_change(const synfig::Time &t)
{
canvas_interface()->set_meta_data("audiooffset",t.get_string());
}
+// The following three functions don't get documented correctly by
+// doxygen 1.5.[23] because of a bug with any function whose name
+// begins with 'property'. Fixed in doxygen 1.5.4 apparently. See
+// http://bugzilla.gnome.org/show_bug.cgi?id=471185 .
Glib::PropertyProxy<synfigapp::ValueDesc>
CellRenderer_TimeTrack::property_value_desc()
{
}
void
-ChildrenTreeStore::on_canvas_added(Canvas::Handle canvas)
+ChildrenTreeStore::on_canvas_added(synfig::Canvas::Handle canvas)
{
Gtk::TreeRow row = *(prepend(canvas_row.children()));
}
void
-ChildrenTreeStore::on_canvas_removed(Canvas::Handle /*canvas*/)
+ChildrenTreeStore::on_canvas_removed(synfig::Canvas::Handle /*canvas*/)
{
rebuild_canvases();
}
void
-ChildrenTreeStore::on_value_node_added(ValueNode::Handle value_node)
+ChildrenTreeStore::on_value_node_added(synfig::ValueNode::Handle value_node)
{
// if(value_node->get_id().find("Unnamed")!=String::npos)
// return;
}
void
-ChildrenTreeStore::on_value_node_deleted(etl::handle<ValueNode> value_node)
+ChildrenTreeStore::on_value_node_deleted(synfig::ValueNode::Handle value_node)
{
Gtk::TreeIter iter;
//int i(0);
}
void
-ChildrenTreeStore::on_value_node_changed(etl::handle<ValueNode> value_node)
+ChildrenTreeStore::on_value_node_changed(synfig::ValueNode::Handle value_node)
{
if(!value_node->is_exported())
}
void
-ChildrenTreeStore::on_value_node_renamed(etl::handle<ValueNode> value_node)
+ChildrenTreeStore::on_value_node_renamed(synfig::ValueNode::Handle value_node)
{
rebuild_value_nodes();
}
/* === M E T H O D S ======================================================= */
-Dialog_Keyframe::Dialog_Keyframe(Gtk::Window& parent,handle<synfigapp::CanvasInterface> canvas_interface):
+Dialog_Keyframe::Dialog_Keyframe(Gtk::Window& parent, etl::handle<synfigapp::CanvasInterface> canvas_interface):
Gtk::Dialog(_("Keyframe Dialog"),parent,false,true),
canvas_interface(canvas_interface)
{
{
}
-void Dialog_Preview::set_preview(handle<Preview> prev)
+void Dialog_Preview::set_preview(etl::handle<Preview> prev)
{
get_window().clear();
preview.set_preview(prev);
void
-Dialog_Setup::set_time_format(Time::Format x)
+Dialog_Setup::set_time_format(synfig::Time::Format x)
{
time_format=x;
if(x<=Time::FORMAT_VIDEO)
{
dock_book_list.front()->clear();
- //! \fixme: UGLY HACK
+ //! \todo Fix this UGLY HACK
// The following line really should be uncommented,
// but it causes crashes. Without it, a small
// memory hole is created--but at least it doesn't crash
}
Point
-Duckmatic::snap_point_to_grid(const Point& x, float radius)const
+Duckmatic::snap_point_to_grid(const synfig::Point& x, float radius)const
{
Point ret(x);
/* === S Y N F I G ========================================================= */
-/*! \file synfigstudio/src/gtkmm/general.h
+/*! \file gtkmm/general.h
** \brief General header file for synfigstudio
**
** $Id$
/* === M E T H O D S ======================================================= */
-Instance::Instance(Canvas::Handle canvas):
+Instance::Instance(synfig::Canvas::Handle canvas):
synfigapp::Instance (canvas),
// canvas_tree_store_ (Gtk::TreeStore::create(CanvasTreeModel())),
// canvas_tree_store_ (Gtk::TreeStore::create()),
}
handle<Instance>
-Instance::create(Canvas::Handle canvas)
+Instance::create(synfig::Canvas::Handle canvas)
{
// Construct a new instance
handle<Instance> instance(new Instance(canvas));
}
handle<CanvasView>
-Instance::find_canvas_view(Canvas::Handle canvas)
+Instance::find_canvas_view(etl::handle<synfig::Canvas> canvas)
{
if(!canvas)
return 0;
}
void
-Instance::focus(Canvas::Handle canvas)
+Instance::focus(etl::handle<synfig::Canvas> canvas)
{
handle<CanvasView> canvas_view=find_canvas_view(canvas);
assert(canvas_view);
void
-Instance::insert_canvas(Gtk::TreeRow row,Canvas::Handle canvas)
+Instance::insert_canvas(Gtk::TreeRow row, synfig::Canvas::Handle canvas)
{
CanvasTreeModel canvas_tree_model;
assert(canvas);
}
void
-Instance::process_action(String name, synfigapp::Action::ParamList param_list)
+Instance::process_action(synfig::String name, synfigapp::Action::ParamList param_list)
{
assert(synfigapp::Action::book().count(name));
}
Gtk::TreeModel::Path
-KeyframeTreeStore::get_path_vfunc (const TreeModel::iterator& gtk_iter)const
+KeyframeTreeStore::get_path_vfunc (const iterator& gtk_iter)const
{
Gtk::TreeModel::Path path;
}
void
-KeyframeTreeStore::add_keyframe(Keyframe keyframe)
+KeyframeTreeStore::add_keyframe(synfig::Keyframe keyframe)
{
try
{
}
void
-KeyframeTreeStore::remove_keyframe(Keyframe keyframe)
+KeyframeTreeStore::remove_keyframe(synfig::Keyframe keyframe)
{
try
{
}
void
-KeyframeTreeStore::change_keyframe(Keyframe keyframe)
+KeyframeTreeStore::change_keyframe(synfig::Keyframe keyframe)
{
try
{
}
}
-bool KeyMapSettings::get_key(const char *path, AccelKey *key)
+bool KeyMapSettings::get_key(const char *path, Gtk::AccelKey *key)
{
GtkAccelKey ac;
if(gtk_accel_map_lookup_entry(path,&ac))
}
void
-LayerGroupTreeStore::on_group_pair_added(String group, etl::handle<Layer> layer)
+LayerGroupTreeStore::on_group_pair_added(synfig::String group, etl::handle<synfig::Layer> layer)
{
if(!layer->get_canvas())
return;
}
void
-LayerGroupTreeStore::on_group_pair_removed(String group, etl::handle<Layer> layer)
+LayerGroupTreeStore::on_group_pair_removed(synfig::String group, etl::handle<synfig::Layer> layer)
{
if(!layer->get_canvas())
return;
}
bool
-LayerGroupTreeStore::find_group_row(const String &group, Gtk::TreeModel::Children::iterator &iter)
+LayerGroupTreeStore::find_group_row(const synfig::String &group, Gtk::TreeModel::Children::iterator &iter)
{
Gtk::TreeModel::Children::iterator prev;
return find_group_row_(group,children(),iter,prev);
}
void
-LayerParamTreeStore::on_value_node_added(ValueNode::Handle /*value_node*/)
+LayerParamTreeStore::on_value_node_added(synfig::ValueNode::Handle /*value_node*/)
{
// queue_refresh();
}
void
-LayerParamTreeStore::on_value_node_deleted(etl::handle<ValueNode> /*value_node*/)
+LayerParamTreeStore::on_value_node_deleted(synfig::ValueNode::Handle /*value_node*/)
{
// queue_refresh();
}
}
void
-LayerParamTreeStore::on_value_node_changed(etl::handle<ValueNode> /*value_node*/)
+LayerParamTreeStore::on_value_node_changed(synfig::ValueNode::Handle /*value_node*/)
{
queue_refresh();
}
}
void
-LayerTree::select_layer(Layer::Handle layer)
+LayerTree::select_layer(synfig::Layer::Handle layer)
{
Gtk::TreeModel::Children::iterator iter;
if(layer_tree_store_->find_layer_row(layer,iter))
}
}
-void studio::Widget_Preview::set_preview(handle<Preview> prev)
+void studio::Widget_Preview::set_preview(etl::handle<Preview> prev)
{
preview = prev;
/* === M E T H O D S ======================================================= */
-RenderSettings::RenderSettings(Gtk::Window& parent,handle<synfigapp::CanvasInterface> canvas_interface):
+RenderSettings::RenderSettings(Gtk::Window& parent, etl::handle<synfigapp::CanvasInterface> canvas_interface):
Gtk::Dialog(_("Render Settings"),parent,false,true),
canvas_interface_(canvas_interface),
adjustment_quality(3,0,9),
}
void
-Toolbox::set_active_state(const String& statename)
+Toolbox::set_active_state(const synfig::String& statename)
{
std::map<synfig::String,Gtk::ToggleButton *>::iterator iter;
}else return String();
}
-int ValueBaseLink::get_link_index_from_name(const String &name)const
+int ValueBaseLink::get_link_index_from_name(const synfig::String &name)const
{
throw Exception::BadLinkName(name);
}
//list management stuff
-ValueBaseLink::list_type::const_iterator ValueBaseLink::findlink(ValueNode::Handle x) const
+ValueBaseLink::list_type::const_iterator ValueBaseLink::findlink(synfig::ValueNode::Handle x) const
{
for(list_type::const_iterator i = list.begin(); i != list.end(); ++i)
{
return list.end();
}
-ValueBaseLink::list_type::iterator ValueBaseLink::findlink(ValueNode::Handle x)
+ValueBaseLink::list_type::iterator ValueBaseLink::findlink(synfig::ValueNode::Handle x)
{
for(list_type::iterator i = list.begin(); i != list.end(); ++i)
{
return list.end();
}
-void ValueBaseLink::add(ValueNode::Handle v)
+void ValueBaseLink::add(synfig::ValueNode::Handle v)
{
list_type::iterator i = findlink(v);
}
}
-void ValueBaseLink::remove(ValueNode::Handle v)
+void ValueBaseLink::remove(synfig::ValueNode::Handle v)
{
list_type::iterator i = findlink(v);
}
void
-Widget_CanvasChooser::set_parent_canvas(etl::handle<synfig::Canvas> x)
+Widget_CanvasChooser::set_parent_canvas(synfig::Canvas::Handle x)
{
assert(x);
parent_canvas=x;
}
void
-Widget_CanvasChooser::set_value_(etl::handle<synfig::Canvas> data)
+Widget_CanvasChooser::set_value_(synfig::Canvas::Handle data)
{
set_value(data);
activate();
}
void
-Widget_CanvasChooser::set_value(etl::handle<synfig::Canvas> data)
+Widget_CanvasChooser::set_value(synfig::Canvas::Handle data)
{
assert(parent_canvas);
canvas=data;
ColorSlider::set_type(Type x) { type=x; queue_draw(); }
void
-ColorSlider::set_color(Color x) { color_=x; queue_draw(); }
+ColorSlider::set_color(synfig::Color x) { color_=x; queue_draw(); }
void
-ColorSlider::slider_color_TYPE_R(Color &color, float amount) { color.set_r(amount); }
+ColorSlider::slider_color_TYPE_R(synfig::Color &color, float amount) { color.set_r(amount); }
void
-ColorSlider::slider_color_TYPE_G(Color &color, float amount) { color.set_g(amount); }
+ColorSlider::slider_color_TYPE_G(synfig::Color &color, float amount) { color.set_g(amount); }
void
-ColorSlider::slider_color_TYPE_B(Color &color, float amount) { color.set_b(amount); }
+ColorSlider::slider_color_TYPE_B(synfig::Color &color, float amount) { color.set_b(amount); }
void
-ColorSlider::slider_color_TYPE_Y(Color &color, float amount) { color.set_y(amount); }
+ColorSlider::slider_color_TYPE_Y(synfig::Color &color, float amount) { color.set_y(amount); }
void
-ColorSlider::slider_color_TYPE_U(Color &color, float amount) { color.set_u(amount-0.5f); }
+ColorSlider::slider_color_TYPE_U(synfig::Color &color, float amount) { color.set_u(amount-0.5f); }
void
-ColorSlider::slider_color_TYPE_V(Color &color, float amount) { color.set_v(amount-0.5f); }
+ColorSlider::slider_color_TYPE_V(synfig::Color &color, float amount) { color.set_v(amount-0.5f); }
void
-ColorSlider::slider_color_TYPE_HUE(Color &color, float amount) { color.set_uv_angle(Angle::rot(amount)); }
+ColorSlider::slider_color_TYPE_HUE(synfig::Color &color, float amount) { color.set_uv_angle(Angle::rot(amount)); }
void
-ColorSlider::slider_color_TYPE_SAT(Color &color, float amount) { color.set_s(amount*0.5f); }
+ColorSlider::slider_color_TYPE_SAT(synfig::Color &color, float amount) { color.set_s(amount*0.5f); }
void
-ColorSlider::slider_color_TYPE_A(Color &color, float amount) { color.set_a(amount); }
+ColorSlider::slider_color_TYPE_A(synfig::Color &color, float amount) { color.set_a(amount); }
void
-ColorSlider::adjust_color(Type type, Color &color, float amount)
+ColorSlider::adjust_color(Type type, synfig::Color &color, float amount)
{
static const slider_color_func jump_table[int(TYPE_END)] =
{
void
-Widget_Filename::set_value(const string &data)
+Widget_Filename::set_value(const std::string &data)
{
entry_filename->set_text(data);
}
}
void
-Widget_Vector::set_canvas(Canvas::LooseHandle x)
+Widget_Vector::set_canvas(synfig::Canvas::LooseHandle x)
{
canvas_=x;
if(x)
}
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();
Action::Handle
-Action::create(const String &name)
+Action::create(const synfig::String &name)
{
if(!book().count(name))
return 0; //! \todo perhaps we should throw something instead?
}
Action::CandidateList::iterator
-Action::CandidateList::find(const String& x)
+Action::CandidateList::find(const synfig::String& x)
{
iterator iter;
for(iter=begin();iter!=end();++iter)
}
-Group::Group(const std::string &str):
+Group::Group(const synfig::String &str):
name_(str),
ready_(true)
{
}
bool
-Action::System::perform_action(handle<Action::Base> action)
+Action::System::perform_action(etl::handle<Action::Base> action)
{
handle<UIInterface> uim(get_ui_interface());
}
bool
-synfigapp::Action::System::undo_(handle<UIInterface> uim)
+synfigapp::Action::System::undo_(etl::handle<UIInterface> uim)
{
handle<Action::Undoable> action(undo_action_stack().front());
most_recent_action_=action;
}
bool
-Action::System::redo_(handle<UIInterface> uim)
+Action::System::redo_(etl::handle<UIInterface> uim)
{
handle<Action::Undoable> action(redo_action_stack().front());
most_recent_action_=action;
return false;
}
-Action::PassiveGrouper::PassiveGrouper(etl::loose_handle<Action::System> instance_,synfig::String name_):
+Action::PassiveGrouper::PassiveGrouper(etl::loose_handle<System> instance_,synfig::String name_):
instance_(instance_),
name_(name_),
redraw_requested_(false),
}
void
-Action::PassiveGrouper::request_redraw(handle<CanvasInterface> x)
+Action::PassiveGrouper::request_redraw(etl::handle<CanvasInterface> x)
{
/* DEBUGPOINT();
if(instance_->group_stack_.empty())
#define old_2_new(x) (((x)-old_begin)/(old_end-old_begin)*(new_end-new_begin)+new_begin)
int
-Action::KeyframeSet::scale_activepoints(const synfigapp::ValueDesc& value_desc,const Time& old_begin,const Time& old_end,const Time& new_begin,const Time& new_end)
+Action::KeyframeSet::scale_activepoints(const synfigapp::ValueDesc& value_desc,const synfig::Time& old_begin,const synfig::Time& old_end,const synfig::Time& new_begin,const synfig::Time& new_end)
{
ValueNode_DynamicList::Handle value_node(ValueNode_DynamicList::Handle::cast_static(value_desc.get_parent_value_node()));
ValueNode_DynamicList::ListEntry& list_entry(value_node->list[value_desc.get_index()]);
}
int
-Action::KeyframeSet::scale_waypoints(const synfigapp::ValueDesc& value_desc,const Time& old_begin,const Time& old_end,const Time& new_begin,const Time& new_end)
+Action::KeyframeSet::scale_waypoints(const synfigapp::ValueDesc& value_desc,const synfig::Time& old_begin,const synfig::Time& old_end,const synfig::Time& new_begin,const synfig::Time& new_end)
{
ValueNode_Animated::Handle value_node(ValueNode_Animated::Handle::cast_static(value_desc.get_value_node()));
// If we couldn't find the layer in the canvas, then bail
if(*iter2!=layer)
{
- /*! \fixme We should really undo all prior removals
+ /*! \todo We should really undo all prior removals
** before we go throwing shit around */
throw Error(_("This layer doesn't exist anymore."));
}
// bail
if(get_canvas()!=subcanvas && !subcanvas->is_inline())
{
- /*! \fixme We should really undo all prior removals
+ /*! \todo We should really undo all prior removals
** before we go throwing shit around */
throw Error(_("This layer doesn't belong to this canvas anymore"));
}
/* === M E T H O D S ======================================================= */
-CanvasInterface::CanvasInterface(loose_handle<Instance> instance,handle<Canvas> canvas):
+CanvasInterface::CanvasInterface(etl::loose_handle<Instance> instance,etl::handle<synfig::Canvas> canvas):
instance_(instance),
canvas_(canvas),
cur_time_(canvas->rend_desc().get_frame_start()),
}
etl::handle<CanvasInterface>
-CanvasInterface::create(loose_handle<Instance> instance,handle<Canvas> canvas)
+CanvasInterface::create(etl::loose_handle<Instance> instance, etl::handle<synfig::Canvas> canvas)
{
etl::handle<CanvasInterface> intrfc;
intrfc=new CanvasInterface(instance,canvas);
Layer::Handle
-CanvasInterface::add_layer_to(String name, Canvas::Handle canvas, int depth)
+CanvasInterface::add_layer_to(synfig::String name, synfig::Canvas::Handle canvas, int depth)
{
synfigapp::Action::PassiveGrouper group(get_instance().get(),_("Add Layer To"));
bool
-CanvasInterface::convert(ValueDesc value_desc, String type)
+CanvasInterface::convert(ValueDesc value_desc, synfig::String type)
{
Action::Handle action(Action::ValueDescConvert::create());
}
bool
-CanvasInterface::set_name(const String &x)
+CanvasInterface::set_name(const synfig::String &x)
{
//! \todo This needs to be converted into an action
get_canvas()->set_name(x);
}
bool
-CanvasInterface::set_description(const String &x)
+CanvasInterface::set_description(const synfig::String &x)
{
//! \todo This needs to be converted into an action
get_canvas()->set_description(x);
}
bool
-CanvasInterface::set_id(const String &x)
+CanvasInterface::set_id(const synfig::String &x)
{
//! \todo This needs to be converted into an action
get_canvas()->set_id(x);
void
-CanvasInterface::auto_export(ValueNode::Handle /*value_node*/)
+CanvasInterface::auto_export(synfig::ValueNode::Handle /*value_node*/)
{
/*
// Check to see if we are already exported.
/* === S Y N F I G ========================================================= */
-/*! \file synfigstudio/src/synfigapp/general.h
+/*! \file synfigapp/general.h
** \brief Te
**
** $Id$
/* === M E T H O D S ======================================================= */
-Instance::Instance(Canvas::Handle canvas):
+Instance::Instance(etl::handle<synfig::Canvas> canvas):
CVSInfo(canvas->get_file_name()),
canvas_(canvas)
{
} // END of synfigapp::Instance::Instance()
handle<Instance>
-Instance::create(Canvas::Handle canvas)
+Instance::create(etl::handle<synfig::Canvas> canvas)
{
// Construct a new instance
handle<Instance> instance(new Instance(canvas));
} // END of studio::Instance::~Instance()
handle<CanvasInterface>
-Instance::find_canvas_interface(handle<Canvas> canvas)
+Instance::find_canvas_interface(synfig::Canvas::Handle canvas)
{
if(!canvas)
return 0;
}
bool
-Instance::save_as(const std::string &file_name)
+Instance::save_as(const synfig::String &file_name)
{
bool ret;
/* === M E T H O D S ======================================================= */
-synfigapp::Main::Main(const synfig::String &basepath,ProgressCallback *cb):
+synfigapp::Main::Main(const synfig::String &basepath, synfig::ProgressCallback *cb):
synfig::Main(basepath,cb),
ref_count_(synfigapp_ref_count_)
{
}
UIInterface::Response
-ConsoleUIInterface::yes_no_cancel(const string &title, const string &message,Response dflt)
+ConsoleUIInterface::yes_no_cancel(const std::string &title, const std::string &message, Response dflt)
{
cout<<title<<": "<<message<<' ';
if(dflt==RESPONSE_NO)
/* === S Y N F I G ========================================================= */
-/*! \file synfigstudio/src/template.cpp
+/*! \file template.cpp
** \brief Template File
**
** $Id$
/* === S Y N F I G ========================================================= */
-/*! \file synfigstudio/src/template.h
+/*! \file template.h
** \brief Template Header
**
** $Id$