-/* === S I N F G =========================================================== */
+/* === S Y N F I G ========================================================= */
/*! \file keyframetreestore.cpp
** \brief Template File
**
-** $Id: keyframetreestore.cpp,v 1.1.1.1 2005/01/07 03:34:36 darco Exp $
+** $Id$
**
** \legal
-** Copyright (c) 2002 Robert B. Quattlebaum Jr.
+** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
+** Copyright (c) 2007, 2008 Chris Moore
**
-** This software and associated documentation
-** are CONFIDENTIAL and PROPRIETARY property of
-** the above-mentioned copyright holder.
+** This package is free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License as
+** published by the Free Software Foundation; either version 2 of
+** the License, or (at your option) any later version.
**
-** You may not copy, print, publish, or in any
-** other way distribute this software without
-** a prior written agreement with
-** the copyright holder.
+** This package is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+** General Public License for more details.
** \endlegal
*/
/* ========================================================================= */
#endif
#include "keyframetreestore.h"
-#include <sinfg/valuenode.h>
-#include "iconcontroler.h"
-#include <sinfg/valuenode_timedswap.h>
+#include <synfig/valuenode.h>
+#include "iconcontroller.h"
+#include <synfig/valuenode_timedswap.h>
#include <gtkmm/button.h>
#include <gtkmm/treerowreference.h>
-#include <sinfg/canvas.h>
-#include <sinfg/keyframe.h>
+#include <synfig/canvas.h>
+#include <synfig/keyframe.h>
#include <time.h>
#include <cstdlib>
#include <ETL/smart_ptr>
-#include <sinfgapp/action.h>
-#include <sinfgapp/instance.h>
+#include <synfigapp/action.h>
+#include <synfigapp/instance.h>
#include "onemoment.h"
-#include <sinfg/exception.h>
+#include <synfig/exception.h>
+
+#include "general.h"
#endif
using namespace std;
using namespace etl;
-using namespace sinfg;
+using namespace synfig;
using namespace studio;
/* === M A C R O S ========================================================= */
/* === G L O B A L S ======================================================= */
-KeyframeTreeStore_Class KeyframeTreeStore::keyframe_tree_store_class_;
+// KeyframeTreeStore_Class KeyframeTreeStore::keyframe_tree_store_class_;
/* === C L A S S E S & S T R U C T S ======================================= */
struct _keyframe_iterator
{
- sinfg::KeyframeList::iterator iter;
+ synfig::KeyframeList::iterator iter;
int ref_count;
int index;
};
/*
-Gtk::TreeModel::iterator keyframe_iter_2_model_iter(sinfg::KeyframeList::iterator iter,int index)
+Gtk::TreeModel::iterator keyframe_iter_2_model_iter(synfig::KeyframeList::iterator iter,int index)
{
Gtk::TreeModel::iterator ret;
-
+
_keyframe_iterator*& data(static_cast<_keyframe_iterator*&>(ret->gobj()->user_data));
data=new _keyframe_iterator();
data->ref_count=1;
data->iter=iter;
data->index=index;
-
+
return ret;
}
*/
-sinfg::KeyframeList::iterator model_iter_2_keyframe_iter(Gtk::TreeModel::iterator iter)
+synfig::KeyframeList::iterator model_iter_2_keyframe_iter(Gtk::TreeModel::iterator iter)
{
_keyframe_iterator* data(static_cast<_keyframe_iterator*>(iter->gobj()->user_data));
if(!data)
gobject_(0)
{
}
-
+
TreeRowReferenceHack(const Glib::RefPtr<Gtk::TreeModel>& model, const Gtk::TreeModel::Path& path):
gobject_ ( gtk_tree_row_reference_new(model->gobj(), const_cast<GtkTreePath*>(path.gobj())) )
{
TreeRowReferenceHack(const TreeRowReferenceHack &x):
gobject_ ( x.gobject_?gtk_tree_row_reference_copy(x.gobject_):0 )
{
-
+
}
void swap(TreeRowReferenceHack & other)
swap(temp);
return *this;
}
-
+
~TreeRowReferenceHack()
{
if(gobject_)
gtk_tree_row_reference_free(gobject_);
}
-
+
Gtk::TreeModel::Path get_path() { return Gtk::TreeModel::Path(gtk_tree_row_reference_get_path(gobject_),false); }
GtkTreeRowReference *gobj() { return gobject_; }
};
if(!gtype_)
{
class_init_func_ = &KeyframeTreeStore_Class::class_init_function;
-
+
const GTypeInfo derived_info =
{
sizeof(GObjectClass),
0,
NULL
};
-
+
gtype_ = g_type_register_static(G_TYPE_OBJECT, "KeyframeTreeStore", &derived_info, GTypeFlags(0));
Gtk::TreeModel::add_interface(get_type());
}
}
void
-KeyframeTreeStore_Class::class_init_function(gpointer g_class, gpointer class_data)
+KeyframeTreeStore_Class::class_init_function(gpointer /*g_class*/, gpointer /*class_data*/)
{
// ???
}
-KeyframeTreeStore::KeyframeTreeStore(etl::loose_handle<sinfgapp::CanvasInterface> canvas_interface_):
+KeyframeTreeStore::KeyframeTreeStore(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface_):
Glib::ObjectBase ("KeyframeTreeStore"),
- Glib::Object (Glib::ConstructParams(keyframe_tree_store_class_.init(), (char*) 0)),
+ //! \todo what is going on here? why the need for this KeyframeTreeStore_Class at all?
+ // Glib::Object (Glib::ConstructParams(keyframe_tree_store_class_.init(), (char*) 0, (char*) 0)),
canvas_interface_ (canvas_interface_)
{
reset_stamp();
KeyframeTreeStore::~KeyframeTreeStore()
{
- sinfg::info("KeyframeTreeStore::~KeyframeTreeStore(): Deleted");
+ if (getenv("SYNFIG_DEBUG_DESTRUCTORS"))
+ synfig::info("KeyframeTreeStore::~KeyframeTreeStore(): Deleted");
}
Glib::RefPtr<KeyframeTreeStore>
-KeyframeTreeStore::create(etl::loose_handle<sinfgapp::CanvasInterface> canvas_interface_)
+KeyframeTreeStore::create(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface_)
{
KeyframeTreeStore *store(new KeyframeTreeStore(canvas_interface_));
Glib::RefPtr<KeyframeTreeStore> ret(store);
void
KeyframeTreeStore::reset_stamp()
{
- stamp_=time(0)+reinterpret_cast<int>(this);
+ stamp_=time(0)+reinterpret_cast<long>(this);
}
/*
{
Gtk::TreeModel::Children::iterator iter;
const Gtk::TreeModel::Children children(children());
- path_table_.clear();
+ path_table_.clear();
for(iter = children.begin(); iter != children.end(); ++iter)
{
Gtk::TreeModel::Row row(*iter);
}
inline void
-KeyframeTreeStore::dump_iterator(const GtkTreeIter* gtk_iter, const Glib::ustring &name)const
+KeyframeTreeStore::dump_iterator(const GtkTreeIter* /*gtk_iter*/, const Glib::ustring &/*name*/)const
{
#if 0
if(!gtk_iter)
KeyframeTreeStore::time_sorter(const Gtk::TreeModel::iterator &rhs,const Gtk::TreeModel::iterator &lhs)
{
const Model model;
-
+
_keyframe_iterator *rhs_iter(static_cast<_keyframe_iterator*>(rhs->gobj()->user_data));
_keyframe_iterator *lhs_iter(static_cast<_keyframe_iterator*>(lhs->gobj()->user_data));
-
+
Time diff(rhs_iter->iter->get_time()-lhs_iter->iter->get_time());
if(diff<0)
return -1;
return 0;
}
+int
+KeyframeTreeStore::description_sorter(const Gtk::TreeModel::iterator &rhs,const Gtk::TreeModel::iterator &lhs)
+{
+ const Model model;
+
+ _keyframe_iterator *rhs_iter(static_cast<_keyframe_iterator*>(rhs->gobj()->user_data));
+ _keyframe_iterator *lhs_iter(static_cast<_keyframe_iterator*>(lhs->gobj()->user_data));
+
+ int comp = rhs_iter->iter->get_description().compare(lhs_iter->iter->get_description());
+ if (comp > 0) return 1;
+ if (comp < 0) return -1;
+ return 0;
+}
+
void
KeyframeTreeStore::set_value_impl(const Gtk::TreeModel::iterator& row, int column, const Glib::ValueBase& value)
{
}
_keyframe_iterator *iter(static_cast<_keyframe_iterator*>(row.gobj()->user_data));
-
+
try
{
if(column==model.time_delta.index())
- {
- Glib::Value<sinfg::Time> x;
+ {
+ Glib::Value<synfig::Time> x;
g_value_init(x.gobj(),model.time.type());
g_value_copy(value.gobj(),x.gobj());
-
+
Time new_delta(x.get());
if(new_delta<=Time::zero()+Time::epsilon())
{
// Bad value
return;
}
-
+
Time old_delta((*row)[model.time_delta]);
if(old_delta<=Time::zero()+Time::epsilon())
{
// Bad old delta
return;
}
+ // row(row) on the next line is bad - don't use it, because it leaves 'row' uninitialized
//Gtk::TreeModel::iterator row(row);
//row++;
//if(!row)return;
-
+
Time change_delta(new_delta-old_delta);
-
+
if(change_delta<=Time::zero()+Time::epsilon() &&change_delta>=Time::zero()-Time::epsilon())
{
// Not an error, just no change
return;
}
-
- // New Method
+
{
Keyframe keyframe((*row)[model.keyframe]);
- sinfgapp::Action::Handle action(sinfgapp::Action::create("keyframe_set_delta"));
-
+ synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_set_delta"));
+
if(!action)return;
-
+
action->set_param("canvas",canvas_interface()->get_canvas());
action->set_param("canvas_interface",canvas_interface());
action->set_param("keyframe",keyframe);
action->set_param("delta",change_delta);
-
+
canvas_interface()->get_instance()->perform_action(action);
}
-
-
- if(0)
- { // Old Method The slowest method EVER!!!
- OneMoment one_moment;
-
- // Create the action group
- sinfgapp::Action::PassiveGrouper group(canvas_interface()->get_instance().get(),_("Adjust Time"));
- sinfgapp::PushMode push_mode(canvas_interface(), sinfgapp::MODE_NORMAL);
-
- Gtk::TreeModel::iterator iter(row);
- if(change_delta<0)
- {
- //DEBUGPOINT();
- KeyframeList keyframe_list(get_canvas()->keyframe_list());
- sinfg::KeyframeList::iterator iter(keyframe_list.find((*row)[model.keyframe]));
- //DEBUGPOINT();
- for(;iter!=keyframe_list.end();++iter)
- {
- //DEBUGPOINT();
- sinfg::Keyframe keyframe(*iter);
-
- keyframe.set_time(keyframe.get_time()+change_delta);
-
- sinfgapp::Action::Handle action(sinfgapp::Action::create("keyframe_set"));
-
- if(!action)return;
-
- action->set_param("canvas",canvas_interface()->get_canvas());
- action->set_param("canvas_interface",canvas_interface());
- action->set_param("keyframe",keyframe);
-
- canvas_interface()->get_instance()->perform_action(action);
- }
- }
- else
- {
- //DEBUGPOINT();
- KeyframeList keyframe_list(get_canvas()->keyframe_list());
- sinfg::KeyframeList::reverse_iterator end(keyframe_list.find((*row)[model.keyframe]));
- sinfg::KeyframeList::reverse_iterator iter(keyframe_list.rbegin());
- //end++;
- //DEBUGPOINT();
- for(;iter!=end;++iter)
- {
- //DEBUGPOINT();
- sinfg::Keyframe keyframe(*iter);
-
- keyframe.set_time(keyframe.get_time()+change_delta);
-
- sinfgapp::Action::Handle action(sinfgapp::Action::create("keyframe_set"));
-
- if(!action)return;
-
- action->set_param("canvas",canvas_interface()->get_canvas());
- action->set_param("canvas_interface",canvas_interface());
- action->set_param("keyframe",keyframe);
-
- canvas_interface()->get_instance()->perform_action(action);
- }
- }
- }
-
+
return;
}
else
{
OneMoment one_moment;
- Glib::Value<sinfg::Time> x;
+ Glib::Value<synfig::Time> x;
g_value_init(x.gobj(),model.time.type());
g_value_copy(value.gobj(),x.gobj());
- sinfg::Keyframe keyframe(*iter->iter);
+ synfig::Keyframe keyframe(*iter->iter);
- sinfg::info("KeyframeTreeStore::set_value_impl():old_time=%s",keyframe.get_time().get_string().c_str());
+ synfig::info("KeyframeTreeStore::set_value_impl():old_time=%s",keyframe.get_time().get_string().c_str());
keyframe.set_time(x.get());
- sinfg::info("KeyframeTreeStore::set_value_impl():new_time=%s",keyframe.get_time().get_string().c_str());
-
- sinfgapp::Action::Handle action(sinfgapp::Action::create("keyframe_set"));
-
+ synfig::info("KeyframeTreeStore::set_value_impl():new_time=%s",keyframe.get_time().get_string().c_str());
+
+ synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_set"));
+
if(!action)
return;
-
+
action->set_param("canvas",canvas_interface()->get_canvas());
action->set_param("canvas_interface",canvas_interface());
action->set_param("keyframe",keyframe);
-
+
canvas_interface()->get_instance()->perform_action(action);
}
else if(column==model.description.index())
Glib::Value<Glib::ustring> x;
g_value_init(x.gobj(),model.description.type());
g_value_copy(value.gobj(),x.gobj());
- sinfg::Keyframe keyframe(*iter->iter);
+ synfig::Keyframe keyframe(*iter->iter);
keyframe.set_description(x.get());
- sinfgapp::Action::Handle action(sinfgapp::Action::create("keyframe_set"));
-
+ synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_set"));
+
if(!action)
return;
-
+
action->set_param("canvas",canvas_interface()->get_canvas());
action->set_param("canvas_interface",canvas_interface());
action->set_param("keyframe",keyframe);
-
+
canvas_interface()->get_instance()->perform_action(action);
}
else if(column==model.keyframe.index())
catch(std::exception x)
{
g_warning(x.what());
- }
+ }
}
Gtk::TreeModelFlags
return false;
_keyframe_iterator *next(new _keyframe_iterator());
- iter_next.gobj()->user_data=static_cast<gpointer>(next);
+ iter_next.gobj()->user_data=static_cast<gpointer>(next);
next->ref_count=1;
next->index=iter->index+1;
next->iter=iter->iter;
if(next->iter==canvas_interface()->get_canvas()->keyframe_list().end())
return false;
-
- iter_next.gobj()->stamp=stamp_;
+
+ iter_next.gobj()->stamp=stamp_;
return true;
}
// If we are already at the end, then we are very invalid
if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
return false;
-
+
++(iter->iter);
-
+
if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
{
--(iter->iter);
clear_iterator(gtk_iter);
return false;
}
-
+
_keyframe_iterator *iter(new _keyframe_iterator());
iter->ref_count=1;
iter->index=0;
iter->iter=canvas_interface()->get_canvas()->keyframe_list().begin();
-
+
gtk_iter->user_data=static_cast<gpointer>(iter);
- gtk_iter->stamp=stamp_;
+ gtk_iter->stamp=stamp_;
- return true;
+ return true;
}
bool
if(parent)
return 0;
-
+
return canvas_interface()->get_canvas()->keyframe_list().size();
}
*/
}
++iter->iter;
}
- xiter.gobj()->user_data=static_cast<gpointer>(iter);
- xiter.gobj()->stamp=stamp_;
+ xiter.gobj()->user_data=static_cast<gpointer>(iter);
+ xiter.gobj()->stamp=stamp_;
return true;
}
}
-
+
_keyframe_iterator *iter(new _keyframe_iterator());
iter->ref_count=1;
iter->index=n;
}
++iter->iter;
}
-
+
gtk_iter->user_data=static_cast<gpointer>(iter);
- gtk_iter->stamp=stamp_;
+ gtk_iter->stamp=stamp_;
return true;
}
if(!iter->ref_count)
{
delete iter;
-
+
// Make this iterator invalid
gtk_iter->stamp=0;
}
}
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;
return path;
_keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->gobj()->user_data));
-
+
path.append_index(iter->index);
return path;
{
case 0: // Time
{
- Glib::Value<sinfg::Time> x;
+ Glib::Value<synfig::Time> x;
g_value_init(x.gobj(),x.value_type());
x.set(iter->iter->get_time());
g_value_init(value.gobj(),x.value_type());
}
case 3: // Time Delta
{
- Glib::Value<sinfg::Time> x;
+ Glib::Value<synfig::Time> x;
g_value_init(x.gobj(),x.value_type());
-
- sinfg::Keyframe prev_keyframe(*iter->iter);
- sinfg::Keyframe keyframe;
+
+ synfig::Keyframe prev_keyframe(*iter->iter);
+ synfig::Keyframe keyframe;
{
KeyframeList::iterator tmp(iter->iter);
tmp++;
}
keyframe=*tmp;
}
-
+
Time delta(0);
try {
delta=keyframe.get_time()-prev_keyframe.get_time();
}
case 2: // Keyframe
{
- Glib::Value<sinfg::Keyframe> x;
+ Glib::Value<synfig::Keyframe> x;
g_value_init(x.gobj(),x.value_type());
x.set(*iter->iter);
g_value_init(value.gobj(),x.value_type());
}
Gtk::TreeModel::Row
-KeyframeTreeStore::find_row(const sinfg::Keyframe &keyframe)
+KeyframeTreeStore::find_row(const synfig::Keyframe &keyframe)
{
Gtk::TreeModel::Row row(*(children().begin()));
dump_iterator(row,"find_row,begin");
const GtkTreeIter *gtk_iter(row.gobj());
if(!iterator_sane(gtk_iter))
throw std::runtime_error(_("Unable to find Keyframe in table"));
-
+
_keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
-
- sinfg::KeyframeList &keyframe_list(canvas_interface()->get_canvas()->keyframe_list());
+
+ synfig::KeyframeList &keyframe_list(canvas_interface()->get_canvas()->keyframe_list());
if(keyframe_list.empty())
throw std::runtime_error(_("There are no keyframes n this canvas"));
iter->index=0;
-
+
for(iter->iter=keyframe_list.begin();iter->iter!=keyframe_list.end() && *iter->iter!=keyframe;++iter->iter)
{
iter->index++;
}
void
-KeyframeTreeStore::add_keyframe(Keyframe keyframe)
+KeyframeTreeStore::add_keyframe(synfig::Keyframe keyframe)
{
try
{
Gtk::TreeRow row(find_row(keyframe));
dump_iterator(row.gobj(),"add_keyframe,row");
Gtk::TreePath path(get_path(row));
-
+
row_inserted(path,row);
old_keyframe_list=get_canvas()->keyframe_list();
catch(std::exception x)
{
g_warning(x.what());
- }
+ }
}
void
-KeyframeTreeStore::remove_keyframe(Keyframe keyframe)
+KeyframeTreeStore::remove_keyframe(synfig::Keyframe keyframe)
{
try
{
if(1)
- {
+ {
Gtk::TreeRow row(find_row(keyframe));
dump_iterator(row,"remove_keyframe,row");
Gtk::TreePath path(get_path(row));
}
catch(std::exception x)
{
- DEBUGPOINT();
g_warning(x.what());
- }
+ }
}
void
-KeyframeTreeStore::change_keyframe(Keyframe keyframe)
+KeyframeTreeStore::change_keyframe(synfig::Keyframe keyframe)
{
try
{
unsigned int new_index(get_index_from_model_iter(row));
unsigned int old_index(0);
- sinfg::KeyframeList::iterator iter;
- for(old_index=0,iter=old_keyframe_list.begin();iter!=old_keyframe_list.end() && (UniqueID)*iter!=(UniqueID)keyframe;++iter,old_index++);
-
+ synfig::KeyframeList::iterator iter;
+ for(old_index=0,iter=old_keyframe_list.begin();iter!=old_keyframe_list.end() && (UniqueID)*iter!=(UniqueID)keyframe;++iter,old_index++)
+ ;
+
if(iter!=old_keyframe_list.end() && new_index!=old_index)
{
- DEBUGPOINT();
std::vector<int> new_order;
for(unsigned int i=0;i<old_keyframe_list.size();i++)
{
{
new_order.erase(new_order.begin()+new_index);
new_order.insert(new_order.begin()+old_index,new_index);
-
+
//new_order[old_index]=
-
+
rows_reordered (Path(), iterator(), &new_order[0]);
}
old_keyframe_list=get_canvas()->keyframe_list();
-
+
row=find_row(keyframe);
}
dump_iterator(row,"change_keyframe,row");
- row_changed(get_path(row),row);
+ row_changed(get_path(row),row);
}
catch(std::exception x)
{
- DEBUGPOINT();
g_warning(x.what());
- }
+ }
}