synfig-studio/trunk/src/gtkmm/keyframetreestore.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file keyframetreestore.cpp
   3 **      \brief Template File
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **      Copyright (c) 2007 Chris Moore
  10 **
  11 **      This package is free software; you can redistribute it and/or
  12 **      modify it under the terms of the GNU General Public License as
  13 **      published by the Free Software Foundation; either version 2 of
  14 **      the License, or (at your option) any later version.
  15 **
  16 **      This package is distributed in the hope that it will be useful,
  17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19 **      General Public License for more details.
  20 **      \endlegal
  21 */
  22 /* ========================================================================= */
  23
  24 /* === H E A D E R S ======================================================= */
  25
  26 #ifdef USING_PCH
  27 #       include "pch.h"
  28 #else
  29 #ifdef HAVE_CONFIG_H
  30 #       include <config.h>
  31 #endif
  32
  33 #include "keyframetreestore.h"
  34 #include <synfig/valuenode.h>
  35 #include "iconcontroller.h"
  36 #include <synfig/valuenode_timedswap.h>
  37 #include <gtkmm/button.h>
  38 #include <gtkmm/treerowreference.h>
  39 #include <synfig/canvas.h>
  40 #include <synfig/keyframe.h>
  41 #include <time.h>
  42 #include <cstdlib>
  43 #include <ETL/smart_ptr>
  44 #include <synfigapp/action.h>
  45 #include <synfigapp/instance.h>
  46 #include "onemoment.h"
  47 #include <synfig/exception.h>
  48
  49 #include "general.h"
  50
  51 #endif
  52
  53 /* === U S I N G =========================================================== */
  54
  55 using namespace std;
  56 using namespace etl;
  57 using namespace synfig;
  58 using namespace studio;
  59
  60 /* === M A C R O S ========================================================= */
  61
  62 /* === G L O B A L S ======================================================= */
  63
  64 // KeyframeTreeStore_Class KeyframeTreeStore::keyframe_tree_store_class_;
  65
  66 /* === C L A S S E S & S T R U C T S ======================================= */
  67
  68 struct _keyframe_iterator
  69 {
  70         synfig::KeyframeList::iterator iter;
  71         int ref_count;
  72         int index;
  73 };
  74
  75 /*
  76 Gtk::TreeModel::iterator keyframe_iter_2_model_iter(synfig::KeyframeList::iterator iter,int index)
  77 {
  78         Gtk::TreeModel::iterator ret;
  79
  80         _keyframe_iterator*& data(static_cast<_keyframe_iterator*&>(ret->gobj()->user_data));
  81         data=new _keyframe_iterator();
  82         data->ref_count=1;
  83         data->iter=iter;
  84         data->index=index;
  85
  86         return ret;
  87 }
  88 */
  89
  90 synfig::KeyframeList::iterator model_iter_2_keyframe_iter(Gtk::TreeModel::iterator iter)
  91 {
  92         _keyframe_iterator* data(static_cast<_keyframe_iterator*>(iter->gobj()->user_data));
  93         if(!data)
  94                 throw std::runtime_error("bad data");
  95         return data->iter;
  96 }
  97
  98 int get_index_from_model_iter(Gtk::TreeModel::iterator iter)
  99 {
 100         _keyframe_iterator* data(static_cast<_keyframe_iterator*>(iter->gobj()->user_data));
 101         if(!data)
 102                 throw std::runtime_error("bad data");
 103         return data->index;
 104 }
 105
 106
 107 /*
 108 #ifndef TreeRowReferenceHack
 109 class TreeRowReferenceHack
 110 {
 111         GtkTreeRowReference *gobject_;
 112 public:
 113         TreeRowReferenceHack():
 114                 gobject_(0)
 115         {
 116         }
 117
 118         TreeRowReferenceHack(const Glib::RefPtr<Gtk::TreeModel>& model, const Gtk::TreeModel::Path& path):
 119                 gobject_ ( gtk_tree_row_reference_new(model->gobj(), const_cast<GtkTreePath*>(path.gobj())) )
 120         {
 121         }
 122
 123         TreeRowReferenceHack(const TreeRowReferenceHack &x):
 124                 gobject_ ( x.gobject_?gtk_tree_row_reference_copy(x.gobject_):0 )
 125         {
 126
 127         }
 128
 129         void swap(TreeRowReferenceHack & other)
 130         {
 131                 GtkTreeRowReference *const temp = gobject_;
 132                 gobject_ = other.gobject_;
 133                 other.gobject_ = temp;
 134         }
 135
 136         const TreeRowReferenceHack &
 137         operator=(const TreeRowReferenceHack &rhs)
 138         {
 139                 TreeRowReferenceHack temp (rhs);
 140                 swap(temp);
 141                 return *this;
 142         }
 143
 144         ~TreeRowReferenceHack()
 145         {
 146                 if(gobject_)
 147                         gtk_tree_row_reference_free(gobject_);
 148         }
 149
 150         Gtk::TreeModel::Path get_path() { return Gtk::TreeModel::Path(gtk_tree_row_reference_get_path(gobject_),false); }
 151         GtkTreeRowReference *gobj() { return gobject_; }
 152 };
 153 #endif
 154 */
 155
 156 /* === P R O C E D U R E S ================================================= */
 157
 158 void clear_iterator(GtkTreeIter* iter)
 159 {
 160         iter->stamp=0;
 161         iter->user_data=iter->user_data2=iter->user_data3=0;
 162 }
 163
 164 /* === M E T H O D S ======================================================= */
 165
 166 const Glib::Class&
 167 KeyframeTreeStore_Class::init()
 168 {
 169         if(!gtype_)
 170         {
 171                 class_init_func_ = &KeyframeTreeStore_Class::class_init_function;
 172
 173                 const GTypeInfo derived_info =
 174                 {
 175                         sizeof(GObjectClass),
 176                         NULL,
 177                         NULL,
 178                         class_init_func_,
 179                         NULL,
 180                         NULL,
 181                         sizeof(GObject),
 182                         0,
 183                         0,
 184                         NULL
 185                 };
 186
 187                 gtype_ = g_type_register_static(G_TYPE_OBJECT, "KeyframeTreeStore", &derived_info, GTypeFlags(0));
 188                 Gtk::TreeModel::add_interface(get_type());
 189         }
 190         return *this;
 191 }
 192
 193 void
 194 KeyframeTreeStore_Class::class_init_function(gpointer /*g_class*/, gpointer /*class_data*/)
 195 {
 196         // ???
 197 }
 198
 199 KeyframeTreeStore::KeyframeTreeStore(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface_):
 200         Glib::ObjectBase        ("KeyframeTreeStore"),
 201         //! \todo what is going on here?  why the need for this KeyframeTreeStore_Class at all?
 202         // Glib::Object         (Glib::ConstructParams(keyframe_tree_store_class_.init(), (char*) 0, (char*) 0)),
 203         canvas_interface_       (canvas_interface_)
 204 {
 205         reset_stamp();
 206         //reset_path_table();
 207
 208         canvas_interface()->signal_keyframe_added().connect(sigc::mem_fun(*this,&studio::KeyframeTreeStore::add_keyframe));
 209         canvas_interface()->signal_keyframe_removed().connect(sigc::mem_fun(*this,&studio::KeyframeTreeStore::remove_keyframe));
 210         canvas_interface()->signal_keyframe_changed().connect(sigc::mem_fun(*this,&studio::KeyframeTreeStore::change_keyframe));
 211 }
 212
 213 KeyframeTreeStore::~KeyframeTreeStore()
 214 {
 215         synfig::info("KeyframeTreeStore::~KeyframeTreeStore(): Deleted");
 216 }
 217
 218 Glib::RefPtr<KeyframeTreeStore>
 219 KeyframeTreeStore::create(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface_)
 220 {
 221         KeyframeTreeStore *store(new KeyframeTreeStore(canvas_interface_));
 222         Glib::RefPtr<KeyframeTreeStore> ret(store);
 223         assert(ret);
 224         return ret;
 225 }
 226
 227 void
 228 KeyframeTreeStore::reset_stamp()
 229 {
 230         stamp_=time(0)+reinterpret_cast<long>(this);
 231 }
 232
 233 /*
 234 void
 235 KeyframeTreeStore::reset_path_table()
 236 {
 237         Gtk::TreeModel::Children::iterator iter;
 238         const Gtk::TreeModel::Children children(children());
 239         path_table_.clear();
 240         for(iter = children.begin(); iter != children.end(); ++iter)
 241         {
 242                 Gtk::TreeModel::Row row(*iter);
 243                 path_table_[(Keyframe)row[model.keyframe]]=TreeRowReferenceHack(Glib::RefPtr<KeyframeTreeStore>(this),Gtk::TreePath(row));
 244         }
 245 }
 246 */
 247
 248
 249 inline bool
 250 KeyframeTreeStore::iterator_sane(const GtkTreeIter* iter)const
 251 {
 252         if(iter && iter->stamp==stamp_)
 253                 return true;
 254         g_warning("KeyframeTreeStore::iterator_sane(): Bad iterator stamp");
 255         return false;
 256 }
 257
 258 inline bool
 259 KeyframeTreeStore::iterator_sane(const Gtk::TreeModel::iterator& iter)const
 260 {
 261         return iterator_sane(iter->gobj());
 262 }
 263
 264 inline void
 265 KeyframeTreeStore::dump_iterator(const GtkTreeIter* /*gtk_iter*/, const Glib::ustring &/*name*/)const
 266 {
 267 #if 0
 268         if(!gtk_iter)
 269         {
 270                 g_warning("KeyframeTreeStore::dump_iterator: \"%s\" is NULL (Root?)",name.c_str());
 271                 return;
 272         }
 273
 274         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
 275
 276         if(gtk_iter->stamp!=stamp_ || !iter)
 277         {
 278                 g_warning("KeyframeTreeStore::dump_iterator: \"%s\" is INVALID",name.c_str());
 279                 return;
 280         }
 281
 282         if((unsigned)iter->index>=canvas_interface()->get_canvas()->keyframe_list().size())
 283                 g_warning("KeyframeTreeStore::dump_iterator: \"%s\"(%p) has bad index(index:%d)",name.c_str(),gtk_iter,iter->index);
 284
 285         g_warning("KeyframeTreeStore::dump_iterator: \"%s\"(%p) ref:%d, index:%d, time:%s",name.c_str(),gtk_iter,iter->ref_count,iter->index,iter->iter->get_time().get_string().c_str());
 286 #endif
 287 }
 288
 289 inline void
 290 KeyframeTreeStore::dump_iterator(const Gtk::TreeModel::iterator& iter, const Glib::ustring &name)const
 291 {
 292         dump_iterator(iter->gobj(),name);
 293 }
 294
 295 int
 296 KeyframeTreeStore::time_sorter(const Gtk::TreeModel::iterator &rhs,const Gtk::TreeModel::iterator &lhs)
 297 {
 298         const Model model;
 299
 300         _keyframe_iterator *rhs_iter(static_cast<_keyframe_iterator*>(rhs->gobj()->user_data));
 301         _keyframe_iterator *lhs_iter(static_cast<_keyframe_iterator*>(lhs->gobj()->user_data));
 302
 303         Time diff(rhs_iter->iter->get_time()-lhs_iter->iter->get_time());
 304         if(diff<0)
 305                 return -1;
 306         if(diff>0)
 307                 return 1;
 308         return 0;
 309 }
 310
 311 void
 312 KeyframeTreeStore::set_value_impl(const Gtk::TreeModel::iterator& row, int column, const Glib::ValueBase& value)
 313 {
 314         if(!iterator_sane(row))
 315                 return;
 316
 317         if(column>=get_n_columns_vfunc())
 318         {
 319                 g_warning("KeyframeTreeStore::set_value_impl: Bad column (%d)",column);
 320                 return;
 321         }
 322
 323         if(!g_value_type_compatible(G_VALUE_TYPE(value.gobj()),get_column_type_vfunc(column)))
 324         {
 325                 g_warning("KeyframeTreeStore::set_value_impl: Bad value type");
 326                 return;
 327         }
 328
 329         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(row.gobj()->user_data));
 330
 331         try
 332         {
 333                 if(column==model.time_delta.index())
 334                 {
 335                         Glib::Value<synfig::Time> x;
 336                         g_value_init(x.gobj(),model.time.type());
 337                         g_value_copy(value.gobj(),x.gobj());
 338
 339                         Time new_delta(x.get());
 340                         if(new_delta<=Time::zero()+Time::epsilon())
 341                         {
 342                                 // Bad value
 343                                 return;
 344                         }
 345
 346                         Time old_delta((*row)[model.time_delta]);
 347                         if(old_delta<=Time::zero()+Time::epsilon())
 348                         {
 349                                 // Bad old delta
 350                                 return;
 351                         }
 352                         // row(row) on the next line is bad - don't use it, because it leaves 'row' uninitialized
 353                         //Gtk::TreeModel::iterator row(row);
 354                         //row++;
 355                         //if(!row)return;
 356
 357                         Time change_delta(new_delta-old_delta);
 358
 359                         if(change_delta<=Time::zero()+Time::epsilon() &&change_delta>=Time::zero()-Time::epsilon())
 360                         {
 361                                 // Not an error, just no change
 362                                 return;
 363                         }
 364
 365                         {
 366                                 Keyframe keyframe((*row)[model.keyframe]);
 367                                 synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_set_delta"));
 368
 369                                 if(!action)return;
 370
 371                                 action->set_param("canvas",canvas_interface()->get_canvas());
 372                                 action->set_param("canvas_interface",canvas_interface());
 373                                 action->set_param("keyframe",keyframe);
 374                                 action->set_param("delta",change_delta);
 375
 376                                 canvas_interface()->get_instance()->perform_action(action);
 377                         }
 378
 379                         return;
 380                 }
 381                 else
 382                 if(column==model.time.index())
 383                 {
 384                         OneMoment one_moment;
 385
 386                         Glib::Value<synfig::Time> x;
 387                         g_value_init(x.gobj(),model.time.type());
 388                         g_value_copy(value.gobj(),x.gobj());
 389                         synfig::Keyframe keyframe(*iter->iter);
 390
 391                         synfig::info("KeyframeTreeStore::set_value_impl():old_time=%s",keyframe.get_time().get_string().c_str());
 392                         keyframe.set_time(x.get());
 393                         synfig::info("KeyframeTreeStore::set_value_impl():new_time=%s",keyframe.get_time().get_string().c_str());
 394
 395                         synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_set"));
 396
 397                         if(!action)
 398                                 return;
 399
 400                         action->set_param("canvas",canvas_interface()->get_canvas());
 401                         action->set_param("canvas_interface",canvas_interface());
 402                         action->set_param("keyframe",keyframe);
 403
 404                         canvas_interface()->get_instance()->perform_action(action);
 405                 }
 406                 else if(column==model.description.index())
 407                 {
 408                         Glib::Value<Glib::ustring> x;
 409                         g_value_init(x.gobj(),model.description.type());
 410                         g_value_copy(value.gobj(),x.gobj());
 411                         synfig::Keyframe keyframe(*iter->iter);
 412                         keyframe.set_description(x.get());
 413
 414                         synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_set"));
 415
 416                         if(!action)
 417                                 return;
 418
 419                         action->set_param("canvas",canvas_interface()->get_canvas());
 420                         action->set_param("canvas_interface",canvas_interface());
 421                         action->set_param("keyframe",keyframe);
 422
 423                         canvas_interface()->get_instance()->perform_action(action);
 424                 }
 425                 else if(column==model.keyframe.index())
 426                 {
 427                         g_warning("KeyframeTreeStore::set_value_impl: This column is read-only");
 428                 }
 429                 else
 430                 {
 431                         assert(0);
 432                 }
 433         }
 434         catch(std::exception x)
 435         {
 436                 g_warning(x.what());
 437         }
 438 }
 439
 440 Gtk::TreeModelFlags
 441 KeyframeTreeStore::get_flags_vfunc ()
 442 {
 443         return Gtk::TREE_MODEL_LIST_ONLY;
 444 }
 445
 446 int
 447 KeyframeTreeStore::get_n_columns_vfunc ()
 448 {
 449         return model.size();
 450 }
 451
 452 GType
 453 KeyframeTreeStore::get_column_type_vfunc (int index)
 454 {
 455         return model.types()[index];
 456 }
 457
 458 bool
 459 KeyframeTreeStore::iter_next_vfunc (const iterator& xiter, iterator& iter_next) const
 460 {
 461         if(!iterator_sane(xiter)) return false;
 462
 463         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(xiter.gobj()->user_data));
 464
 465         if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 466                 return false;
 467
 468         _keyframe_iterator *next(new _keyframe_iterator());
 469         iter_next.gobj()->user_data=static_cast<gpointer>(next);
 470         next->ref_count=1;
 471         next->index=iter->index+1;
 472         next->iter=iter->iter;
 473         ++next->iter;
 474
 475         if(next->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 476                 return false;
 477
 478         iter_next.gobj()->stamp=stamp_;
 479
 480         return true;
 481 }
 482
 483 /*
 484 bool
 485 KeyframeTreeStore::iter_next_vfunc (GtkTreeIter* gtk_iter)
 486 {
 487         if(!iterator_sane(gtk_iter)) return false;
 488
 489         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
 490
 491         // If we are already at the end, then we are very invalid
 492         if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 493                 return false;
 494
 495         ++(iter->iter);
 496
 497         if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 498         {
 499                 --(iter->iter);
 500                 return false;
 501         }
 502         (iter->index)++;
 503         return true;
 504 }
 505
 506 bool
 507 KeyframeTreeStore::iter_children_vfunc (GtkTreeIter* gtk_iter, const GtkTreeIter* parent)
 508 {
 509         dump_iterator(gtk_iter,"gtk_iter");
 510         dump_iterator(parent,"parent");
 511
 512         if(!parent || !iterator_sane(parent))
 513         {
 514                 clear_iterator(gtk_iter);
 515                 return false;
 516         }
 517
 518         _keyframe_iterator *iter(new _keyframe_iterator());
 519         iter->ref_count=1;
 520         iter->index=0;
 521         iter->iter=canvas_interface()->get_canvas()->keyframe_list().begin();
 522
 523         gtk_iter->user_data=static_cast<gpointer>(iter);
 524         gtk_iter->stamp=stamp_;
 525
 526         return true;
 527 }
 528
 529 bool
 530 KeyframeTreeStore::iter_has_child_vfunc (const GtkTreeIter*parent)
 531 {
 532         dump_iterator(parent,"parent");
 533
 534         if(parent)
 535                 return false;
 536
 537         return true;
 538 }
 539
 540 int
 541 KeyframeTreeStore::iter_n_children_vfunc (const GtkTreeIter* parent)
 542 {
 543         dump_iterator(parent,"parent");
 544
 545         if(parent)
 546                 return 0;
 547
 548         return canvas_interface()->get_canvas()->keyframe_list().size();
 549 }
 550 */
 551
 552 int
 553 KeyframeTreeStore::iter_n_root_children_vfunc () const
 554 {
 555         return canvas_interface()->get_canvas()->keyframe_list().size();
 556 }
 557
 558 bool
 559 KeyframeTreeStore::iter_nth_root_child_vfunc (int n, iterator& xiter)const
 560 {
 561         if(canvas_interface()->get_canvas()->keyframe_list().size()==0)
 562         {
 563                 return false;
 564         }
 565
 566         if(n<0)
 567         {
 568                 g_warning("KeyframeTreeStore::iter_nth_root_child_vfunc: Out of range (negative index)");
 569                 return false;
 570         }
 571         if(n && (unsigned)n>=canvas_interface()->get_canvas()->keyframe_list().size())
 572         {
 573                 g_warning("KeyframeTreeStore::iter_nth_child_vfunc: Out of range (large index)");
 574                 return false;
 575         }
 576
 577         _keyframe_iterator *iter(new _keyframe_iterator());
 578         iter->ref_count=1;
 579         iter->index=n;
 580         iter->iter=canvas_interface()->get_canvas()->keyframe_list().begin();
 581         while(n--)
 582         {
 583                 if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 584                 {
 585                         g_warning("KeyframeTreeStore::iter_nth_child_vfunc: >>>BUG<<< in %s on line %d",__FILE__,__LINE__);
 586                         delete iter;
 587                         return false;
 588                 }
 589                 ++iter->iter;
 590         }
 591         xiter.gobj()->user_data=static_cast<gpointer>(iter);
 592         xiter.gobj()->stamp=stamp_;
 593         return true;
 594 }
 595
 596 /*
 597 bool
 598 KeyframeTreeStore::iter_nth_child_vfunc (GtkTreeIter* gtk_iter, const GtkTreeIter* parent, int n)
 599 {
 600         dump_iterator(parent,"parent");
 601
 602         if(parent)
 603         {
 604                 g_warning("KeyframeTreeStore::iter_nth_child_vfunc: I am a list");
 605                 clear_iterator(gtk_iter);
 606                 return false;
 607         }
 608
 609
 610
 611         _keyframe_iterator *iter(new _keyframe_iterator());
 612         iter->ref_count=1;
 613         iter->index=n;
 614         iter->iter=canvas_interface()->get_canvas()->keyframe_list().begin();
 615         while(n--)
 616         {
 617                 if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 618                 {
 619                         g_warning("KeyframeTreeStore::iter_nth_child_vfunc: >>>BUG<<< in %s on line %d",__FILE__,__LINE__);
 620                         delete iter;
 621                         clear_iterator(gtk_iter);
 622                         return false;
 623                 }
 624                 ++iter->iter;
 625         }
 626
 627         gtk_iter->user_data=static_cast<gpointer>(iter);
 628         gtk_iter->stamp=stamp_;
 629         return true;
 630 }
 631
 632 bool
 633 KeyframeTreeStore::iter_parent_vfunc (GtkTreeIter* gtk_iter, const GtkTreeIter* child)
 634 {
 635         dump_iterator(child,"child");
 636         iterator_sane(child);
 637         clear_iterator(gtk_iter);
 638         return false;
 639 }
 640 */
 641
 642 void
 643 KeyframeTreeStore::ref_node_vfunc (iterator& xiter)const
 644 {
 645         GtkTreeIter* gtk_iter(xiter.gobj());
 646         if(!gtk_iter || !iterator_sane(gtk_iter)) return;
 647
 648         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
 649         iter->ref_count++;
 650 }
 651
 652 void
 653 KeyframeTreeStore::unref_node_vfunc (iterator& xiter)const
 654 {
 655         GtkTreeIter* gtk_iter(xiter.gobj());
 656         if(!gtk_iter || !iterator_sane(gtk_iter)) return;
 657
 658         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
 659         iter->ref_count--;
 660         if(!iter->ref_count)
 661         {
 662                 delete iter;
 663
 664                 // Make this iterator invalid
 665                 gtk_iter->stamp=0;
 666         }
 667 }
 668
 669 Gtk::TreeModel::Path
 670 KeyframeTreeStore::get_path_vfunc (const iterator& gtk_iter)const
 671 {
 672         Gtk::TreeModel::Path path;
 673
 674         // If this is the root node, then return
 675         // a root path
 676         if(!iterator_sane(gtk_iter))
 677                 return path;
 678
 679         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->gobj()->user_data));
 680
 681         path.append_index(iter->index);
 682
 683         return path;
 684 }
 685
 686 bool
 687 KeyframeTreeStore::get_iter_vfunc (const Gtk::TreeModel::Path& path, iterator& iter)const
 688 {
 689         if(path.get_depth()>=1)
 690                 return iter_nth_root_child_vfunc(path.front(),iter);
 691
 692         // Error case
 693         g_warning("KeyframeTreeStore::get_iter_vfunc(): Bad path \"%s\"",path.to_string().c_str());
 694         //clear_iterator(iter);
 695         return false;
 696 }
 697
 698 bool
 699 KeyframeTreeStore::iter_is_valid (const iterator& iter) const
 700 {
 701         return iterator_sane(iter);
 702 }
 703
 704 void
 705 KeyframeTreeStore::get_value_vfunc (const Gtk::TreeModel::iterator& gtk_iter, int column, Glib::ValueBase& value)const
 706 {
 707         dump_iterator(gtk_iter,"gtk_iter");
 708         if(!iterator_sane(gtk_iter))
 709                 return;
 710
 711         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->gobj()->user_data));
 712
 713         switch(column)
 714         {
 715         case 0:         // Time
 716         {
 717                 Glib::Value<synfig::Time> x;
 718                 g_value_init(x.gobj(),x.value_type());
 719                 x.set(iter->iter->get_time());
 720                 g_value_init(value.gobj(),x.value_type());
 721                 g_value_copy(x.gobj(),value.gobj());
 722                 return;
 723         }
 724         case 3:         // Time Delta
 725         {
 726                 Glib::Value<synfig::Time> x;
 727                 g_value_init(x.gobj(),x.value_type());
 728
 729                 synfig::Keyframe prev_keyframe(*iter->iter);
 730                 synfig::Keyframe keyframe;
 731                 {
 732                         KeyframeList::iterator tmp(iter->iter);
 733                         tmp++;
 734                         if(tmp==get_canvas()->keyframe_list().end())
 735                         {
 736                                 x.set(Time(0));
 737                                 g_value_init(value.gobj(),x.value_type());
 738                                 g_value_copy(x.gobj(),value.gobj());
 739                                 return;
 740                         }
 741                         keyframe=*tmp;
 742                 }
 743
 744                 Time delta(0);
 745                 try {
 746                         delta=keyframe.get_time()-prev_keyframe.get_time();
 747                 }catch(...) { }
 748                 x.set(delta);
 749                 g_value_init(value.gobj(),x.value_type());
 750                 g_value_copy(x.gobj(),value.gobj());
 751                 return;
 752         }
 753         case 1:         // Description
 754         {
 755                 g_value_init(value.gobj(),G_TYPE_STRING);
 756                 g_value_set_string(value.gobj(),iter->iter->get_description().c_str());
 757                 return;
 758         }
 759         case 2:         // Keyframe
 760         {
 761                 Glib::Value<synfig::Keyframe> x;
 762                 g_value_init(x.gobj(),x.value_type());
 763                 x.set(*iter->iter);
 764                 g_value_init(value.gobj(),x.value_type());
 765                 g_value_copy(x.gobj(),value.gobj());
 766                 return;
 767         }
 768         default:
 769                 break;
 770         }
 771 }
 772
 773 Gtk::TreeModel::Row
 774 KeyframeTreeStore::find_row(const synfig::Keyframe &keyframe)
 775 {
 776         Gtk::TreeModel::Row row(*(children().begin()));
 777         dump_iterator(row,"find_row,begin");
 778         const GtkTreeIter *gtk_iter(row.gobj());
 779         if(!iterator_sane(gtk_iter))
 780                 throw std::runtime_error(_("Unable to find Keyframe in table"));
 781
 782         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
 783
 784         synfig::KeyframeList &keyframe_list(canvas_interface()->get_canvas()->keyframe_list());
 785         if(keyframe_list.empty())
 786                 throw std::runtime_error(_("There are no keyframes n this canvas"));
 787
 788         iter->index=0;
 789
 790         for(iter->iter=keyframe_list.begin();iter->iter!=keyframe_list.end() && *iter->iter!=keyframe;++iter->iter)
 791         {
 792                 iter->index++;
 793         }
 794         if(iter->iter==keyframe_list.end())
 795                 throw std::runtime_error(_("Unable to find Keyframe in table"));
 796         return row;
 797 }
 798
 799 void
 800 KeyframeTreeStore::add_keyframe(synfig::Keyframe keyframe)
 801 {
 802         try
 803         {
 804                 Gtk::TreeRow row(find_row(keyframe));
 805                 dump_iterator(row.gobj(),"add_keyframe,row");
 806                 Gtk::TreePath path(get_path(row));
 807
 808                 row_inserted(path,row);
 809
 810                 old_keyframe_list=get_canvas()->keyframe_list();
 811                 //old_keyframe_list.add(keyframe);
 812                 //old_keyframe_list.sort();
 813         }
 814         catch(std::exception x)
 815         {
 816                 g_warning(x.what());
 817         }
 818 }
 819
 820 void
 821 KeyframeTreeStore::remove_keyframe(synfig::Keyframe keyframe)
 822 {
 823         try
 824         {
 825                 if(1)
 826                 {
 827                         Gtk::TreeRow row(find_row(keyframe));
 828                         dump_iterator(row,"remove_keyframe,row");
 829                         Gtk::TreePath path(get_path(row));
 830                         row_deleted(path);
 831
 832                         old_keyframe_list.erase(keyframe);
 833                 }
 834                 else
 835                 {
 836                         g_warning("KeyframeTreeStore::remove_keyframe: Keyframe not in table");
 837                 }
 838         }
 839         catch(std::exception x)
 840         {
 841                 g_warning(x.what());
 842         }
 843 }
 844
 845 void
 846 KeyframeTreeStore::change_keyframe(synfig::Keyframe keyframe)
 847 {
 848         try
 849         {
 850                 Gtk::TreeRow row(find_row(keyframe));
 851
 852                 unsigned int new_index(get_index_from_model_iter(row));
 853                 unsigned int old_index(0);
 854                 synfig::KeyframeList::iterator iter;
 855                 for(old_index=0,iter=old_keyframe_list.begin();iter!=old_keyframe_list.end() && (UniqueID)*iter!=(UniqueID)keyframe;++iter,old_index++)
 856                         ;
 857
 858                 if(iter!=old_keyframe_list.end() && new_index!=old_index)
 859                 {
 860                         std::vector<int> new_order;
 861                         for(unsigned int i=0;i<old_keyframe_list.size();i++)
 862                         {
 863                                 new_order.push_back(i);
 864                         }
 865                         if(new_order.size()>new_index)
 866                         {
 867                                 new_order.erase(new_order.begin()+new_index);
 868                                 new_order.insert(new_order.begin()+old_index,new_index);
 869
 870                                 //new_order[old_index]=
 871
 872                                 rows_reordered (Path(), iterator(), &new_order[0]);
 873                         }
 874                         old_keyframe_list=get_canvas()->keyframe_list();
 875
 876                         row=find_row(keyframe);
 877                 }
 878
 879                 dump_iterator(row,"change_keyframe,row");
 880                 row_changed(get_path(row),row);
 881         }
 882         catch(std::exception x)
 883         {
 884                 g_warning(x.what());
 885         }
 886 }