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 int
 312 KeyframeTreeStore::description_sorter(const Gtk::TreeModel::iterator &rhs,const Gtk::TreeModel::iterator &lhs)
 313 {
 314         const Model model;
 315
 316         _keyframe_iterator *rhs_iter(static_cast<_keyframe_iterator*>(rhs->gobj()->user_data));
 317         _keyframe_iterator *lhs_iter(static_cast<_keyframe_iterator*>(lhs->gobj()->user_data));
 318
 319         int comp = rhs_iter->iter->get_description().compare(lhs_iter->iter->get_description());
 320         if (comp > 0) return 1;
 321         if (comp < 0) return -1;
 322         return 0;
 323 }
 324
 325 void
 326 KeyframeTreeStore::set_value_impl(const Gtk::TreeModel::iterator& row, int column, const Glib::ValueBase& value)
 327 {
 328         if(!iterator_sane(row))
 329                 return;
 330
 331         if(column>=get_n_columns_vfunc())
 332         {
 333                 g_warning("KeyframeTreeStore::set_value_impl: Bad column (%d)",column);
 334                 return;
 335         }
 336
 337         if(!g_value_type_compatible(G_VALUE_TYPE(value.gobj()),get_column_type_vfunc(column)))
 338         {
 339                 g_warning("KeyframeTreeStore::set_value_impl: Bad value type");
 340                 return;
 341         }
 342
 343         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(row.gobj()->user_data));
 344
 345         try
 346         {
 347                 if(column==model.time_delta.index())
 348                 {
 349                         Glib::Value<synfig::Time> x;
 350                         g_value_init(x.gobj(),model.time.type());
 351                         g_value_copy(value.gobj(),x.gobj());
 352
 353                         Time new_delta(x.get());
 354                         if(new_delta<=Time::zero()+Time::epsilon())
 355                         {
 356                                 // Bad value
 357                                 return;
 358                         }
 359
 360                         Time old_delta((*row)[model.time_delta]);
 361                         if(old_delta<=Time::zero()+Time::epsilon())
 362                         {
 363                                 // Bad old delta
 364                                 return;
 365                         }
 366                         // row(row) on the next line is bad - don't use it, because it leaves 'row' uninitialized
 367                         //Gtk::TreeModel::iterator row(row);
 368                         //row++;
 369                         //if(!row)return;
 370
 371                         Time change_delta(new_delta-old_delta);
 372
 373                         if(change_delta<=Time::zero()+Time::epsilon() &&change_delta>=Time::zero()-Time::epsilon())
 374                         {
 375                                 // Not an error, just no change
 376                                 return;
 377                         }
 378
 379                         {
 380                                 Keyframe keyframe((*row)[model.keyframe]);
 381                                 synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_set_delta"));
 382
 383                                 if(!action)return;
 384
 385                                 action->set_param("canvas",canvas_interface()->get_canvas());
 386                                 action->set_param("canvas_interface",canvas_interface());
 387                                 action->set_param("keyframe",keyframe);
 388                                 action->set_param("delta",change_delta);
 389
 390                                 canvas_interface()->get_instance()->perform_action(action);
 391                         }
 392
 393                         return;
 394                 }
 395                 else
 396                 if(column==model.time.index())
 397                 {
 398                         OneMoment one_moment;
 399
 400                         Glib::Value<synfig::Time> x;
 401                         g_value_init(x.gobj(),model.time.type());
 402                         g_value_copy(value.gobj(),x.gobj());
 403                         synfig::Keyframe keyframe(*iter->iter);
 404
 405                         synfig::info("KeyframeTreeStore::set_value_impl():old_time=%s",keyframe.get_time().get_string().c_str());
 406                         keyframe.set_time(x.get());
 407                         synfig::info("KeyframeTreeStore::set_value_impl():new_time=%s",keyframe.get_time().get_string().c_str());
 408
 409                         synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_set"));
 410
 411                         if(!action)
 412                                 return;
 413
 414                         action->set_param("canvas",canvas_interface()->get_canvas());
 415                         action->set_param("canvas_interface",canvas_interface());
 416                         action->set_param("keyframe",keyframe);
 417
 418                         canvas_interface()->get_instance()->perform_action(action);
 419                 }
 420                 else if(column==model.description.index())
 421                 {
 422                         Glib::Value<Glib::ustring> x;
 423                         g_value_init(x.gobj(),model.description.type());
 424                         g_value_copy(value.gobj(),x.gobj());
 425                         synfig::Keyframe keyframe(*iter->iter);
 426                         keyframe.set_description(x.get());
 427
 428                         synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_set"));
 429
 430                         if(!action)
 431                                 return;
 432
 433                         action->set_param("canvas",canvas_interface()->get_canvas());
 434                         action->set_param("canvas_interface",canvas_interface());
 435                         action->set_param("keyframe",keyframe);
 436
 437                         canvas_interface()->get_instance()->perform_action(action);
 438                 }
 439                 else if(column==model.keyframe.index())
 440                 {
 441                         g_warning("KeyframeTreeStore::set_value_impl: This column is read-only");
 442                 }
 443                 else
 444                 {
 445                         assert(0);
 446                 }
 447         }
 448         catch(std::exception x)
 449         {
 450                 g_warning(x.what());
 451         }
 452 }
 453
 454 Gtk::TreeModelFlags
 455 KeyframeTreeStore::get_flags_vfunc ()
 456 {
 457         return Gtk::TREE_MODEL_LIST_ONLY;
 458 }
 459
 460 int
 461 KeyframeTreeStore::get_n_columns_vfunc ()
 462 {
 463         return model.size();
 464 }
 465
 466 GType
 467 KeyframeTreeStore::get_column_type_vfunc (int index)
 468 {
 469         return model.types()[index];
 470 }
 471
 472 bool
 473 KeyframeTreeStore::iter_next_vfunc (const iterator& xiter, iterator& iter_next) const
 474 {
 475         if(!iterator_sane(xiter)) return false;
 476
 477         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(xiter.gobj()->user_data));
 478
 479         if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 480                 return false;
 481
 482         _keyframe_iterator *next(new _keyframe_iterator());
 483         iter_next.gobj()->user_data=static_cast<gpointer>(next);
 484         next->ref_count=1;
 485         next->index=iter->index+1;
 486         next->iter=iter->iter;
 487         ++next->iter;
 488
 489         if(next->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 490                 return false;
 491
 492         iter_next.gobj()->stamp=stamp_;
 493
 494         return true;
 495 }
 496
 497 /*
 498 bool
 499 KeyframeTreeStore::iter_next_vfunc (GtkTreeIter* gtk_iter)
 500 {
 501         if(!iterator_sane(gtk_iter)) return false;
 502
 503         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
 504
 505         // If we are already at the end, then we are very invalid
 506         if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 507                 return false;
 508
 509         ++(iter->iter);
 510
 511         if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 512         {
 513                 --(iter->iter);
 514                 return false;
 515         }
 516         (iter->index)++;
 517         return true;
 518 }
 519
 520 bool
 521 KeyframeTreeStore::iter_children_vfunc (GtkTreeIter* gtk_iter, const GtkTreeIter* parent)
 522 {
 523         dump_iterator(gtk_iter,"gtk_iter");
 524         dump_iterator(parent,"parent");
 525
 526         if(!parent || !iterator_sane(parent))
 527         {
 528                 clear_iterator(gtk_iter);
 529                 return false;
 530         }
 531
 532         _keyframe_iterator *iter(new _keyframe_iterator());
 533         iter->ref_count=1;
 534         iter->index=0;
 535         iter->iter=canvas_interface()->get_canvas()->keyframe_list().begin();
 536
 537         gtk_iter->user_data=static_cast<gpointer>(iter);
 538         gtk_iter->stamp=stamp_;
 539
 540         return true;
 541 }
 542
 543 bool
 544 KeyframeTreeStore::iter_has_child_vfunc (const GtkTreeIter*parent)
 545 {
 546         dump_iterator(parent,"parent");
 547
 548         if(parent)
 549                 return false;
 550
 551         return true;
 552 }
 553
 554 int
 555 KeyframeTreeStore::iter_n_children_vfunc (const GtkTreeIter* parent)
 556 {
 557         dump_iterator(parent,"parent");
 558
 559         if(parent)
 560                 return 0;
 561
 562         return canvas_interface()->get_canvas()->keyframe_list().size();
 563 }
 564 */
 565
 566 int
 567 KeyframeTreeStore::iter_n_root_children_vfunc () const
 568 {
 569         return canvas_interface()->get_canvas()->keyframe_list().size();
 570 }
 571
 572 bool
 573 KeyframeTreeStore::iter_nth_root_child_vfunc (int n, iterator& xiter)const
 574 {
 575         if(canvas_interface()->get_canvas()->keyframe_list().size()==0)
 576         {
 577                 return false;
 578         }
 579
 580         if(n<0)
 581         {
 582                 g_warning("KeyframeTreeStore::iter_nth_root_child_vfunc: Out of range (negative index)");
 583                 return false;
 584         }
 585         if(n && (unsigned)n>=canvas_interface()->get_canvas()->keyframe_list().size())
 586         {
 587                 g_warning("KeyframeTreeStore::iter_nth_child_vfunc: Out of range (large index)");
 588                 return false;
 589         }
 590
 591         _keyframe_iterator *iter(new _keyframe_iterator());
 592         iter->ref_count=1;
 593         iter->index=n;
 594         iter->iter=canvas_interface()->get_canvas()->keyframe_list().begin();
 595         while(n--)
 596         {
 597                 if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 598                 {
 599                         g_warning("KeyframeTreeStore::iter_nth_child_vfunc: >>>BUG<<< in %s on line %d",__FILE__,__LINE__);
 600                         delete iter;
 601                         return false;
 602                 }
 603                 ++iter->iter;
 604         }
 605         xiter.gobj()->user_data=static_cast<gpointer>(iter);
 606         xiter.gobj()->stamp=stamp_;
 607         return true;
 608 }
 609
 610 /*
 611 bool
 612 KeyframeTreeStore::iter_nth_child_vfunc (GtkTreeIter* gtk_iter, const GtkTreeIter* parent, int n)
 613 {
 614         dump_iterator(parent,"parent");
 615
 616         if(parent)
 617         {
 618                 g_warning("KeyframeTreeStore::iter_nth_child_vfunc: I am a list");
 619                 clear_iterator(gtk_iter);
 620                 return false;
 621         }
 622
 623
 624
 625         _keyframe_iterator *iter(new _keyframe_iterator());
 626         iter->ref_count=1;
 627         iter->index=n;
 628         iter->iter=canvas_interface()->get_canvas()->keyframe_list().begin();
 629         while(n--)
 630         {
 631                 if(iter->iter==canvas_interface()->get_canvas()->keyframe_list().end())
 632                 {
 633                         g_warning("KeyframeTreeStore::iter_nth_child_vfunc: >>>BUG<<< in %s on line %d",__FILE__,__LINE__);
 634                         delete iter;
 635                         clear_iterator(gtk_iter);
 636                         return false;
 637                 }
 638                 ++iter->iter;
 639         }
 640
 641         gtk_iter->user_data=static_cast<gpointer>(iter);
 642         gtk_iter->stamp=stamp_;
 643         return true;
 644 }
 645
 646 bool
 647 KeyframeTreeStore::iter_parent_vfunc (GtkTreeIter* gtk_iter, const GtkTreeIter* child)
 648 {
 649         dump_iterator(child,"child");
 650         iterator_sane(child);
 651         clear_iterator(gtk_iter);
 652         return false;
 653 }
 654 */
 655
 656 void
 657 KeyframeTreeStore::ref_node_vfunc (iterator& xiter)const
 658 {
 659         GtkTreeIter* gtk_iter(xiter.gobj());
 660         if(!gtk_iter || !iterator_sane(gtk_iter)) return;
 661
 662         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
 663         iter->ref_count++;
 664 }
 665
 666 void
 667 KeyframeTreeStore::unref_node_vfunc (iterator& xiter)const
 668 {
 669         GtkTreeIter* gtk_iter(xiter.gobj());
 670         if(!gtk_iter || !iterator_sane(gtk_iter)) return;
 671
 672         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
 673         iter->ref_count--;
 674         if(!iter->ref_count)
 675         {
 676                 delete iter;
 677
 678                 // Make this iterator invalid
 679                 gtk_iter->stamp=0;
 680         }
 681 }
 682
 683 Gtk::TreeModel::Path
 684 KeyframeTreeStore::get_path_vfunc (const iterator& gtk_iter)const
 685 {
 686         Gtk::TreeModel::Path path;
 687
 688         // If this is the root node, then return
 689         // a root path
 690         if(!iterator_sane(gtk_iter))
 691                 return path;
 692
 693         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->gobj()->user_data));
 694
 695         path.append_index(iter->index);
 696
 697         return path;
 698 }
 699
 700 bool
 701 KeyframeTreeStore::get_iter_vfunc (const Gtk::TreeModel::Path& path, iterator& iter)const
 702 {
 703         if(path.get_depth()>=1)
 704                 return iter_nth_root_child_vfunc(path.front(),iter);
 705
 706         // Error case
 707         g_warning("KeyframeTreeStore::get_iter_vfunc(): Bad path \"%s\"",path.to_string().c_str());
 708         //clear_iterator(iter);
 709         return false;
 710 }
 711
 712 bool
 713 KeyframeTreeStore::iter_is_valid (const iterator& iter) const
 714 {
 715         return iterator_sane(iter);
 716 }
 717
 718 void
 719 KeyframeTreeStore::get_value_vfunc (const Gtk::TreeModel::iterator& gtk_iter, int column, Glib::ValueBase& value)const
 720 {
 721         dump_iterator(gtk_iter,"gtk_iter");
 722         if(!iterator_sane(gtk_iter))
 723                 return;
 724
 725         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->gobj()->user_data));
 726
 727         switch(column)
 728         {
 729         case 0:         // Time
 730         {
 731                 Glib::Value<synfig::Time> x;
 732                 g_value_init(x.gobj(),x.value_type());
 733                 x.set(iter->iter->get_time());
 734                 g_value_init(value.gobj(),x.value_type());
 735                 g_value_copy(x.gobj(),value.gobj());
 736                 return;
 737         }
 738         case 3:         // Time Delta
 739         {
 740                 Glib::Value<synfig::Time> x;
 741                 g_value_init(x.gobj(),x.value_type());
 742
 743                 synfig::Keyframe prev_keyframe(*iter->iter);
 744                 synfig::Keyframe keyframe;
 745                 {
 746                         KeyframeList::iterator tmp(iter->iter);
 747                         tmp++;
 748                         if(tmp==get_canvas()->keyframe_list().end())
 749                         {
 750                                 x.set(Time(0));
 751                                 g_value_init(value.gobj(),x.value_type());
 752                                 g_value_copy(x.gobj(),value.gobj());
 753                                 return;
 754                         }
 755                         keyframe=*tmp;
 756                 }
 757
 758                 Time delta(0);
 759                 try {
 760                         delta=keyframe.get_time()-prev_keyframe.get_time();
 761                 }catch(...) { }
 762                 x.set(delta);
 763                 g_value_init(value.gobj(),x.value_type());
 764                 g_value_copy(x.gobj(),value.gobj());
 765                 return;
 766         }
 767         case 1:         // Description
 768         {
 769                 g_value_init(value.gobj(),G_TYPE_STRING);
 770                 g_value_set_string(value.gobj(),iter->iter->get_description().c_str());
 771                 return;
 772         }
 773         case 2:         // Keyframe
 774         {
 775                 Glib::Value<synfig::Keyframe> x;
 776                 g_value_init(x.gobj(),x.value_type());
 777                 x.set(*iter->iter);
 778                 g_value_init(value.gobj(),x.value_type());
 779                 g_value_copy(x.gobj(),value.gobj());
 780                 return;
 781         }
 782         default:
 783                 break;
 784         }
 785 }
 786
 787 Gtk::TreeModel::Row
 788 KeyframeTreeStore::find_row(const synfig::Keyframe &keyframe)
 789 {
 790         Gtk::TreeModel::Row row(*(children().begin()));
 791         dump_iterator(row,"find_row,begin");
 792         const GtkTreeIter *gtk_iter(row.gobj());
 793         if(!iterator_sane(gtk_iter))
 794                 throw std::runtime_error(_("Unable to find Keyframe in table"));
 795
 796         _keyframe_iterator *iter(static_cast<_keyframe_iterator*>(gtk_iter->user_data));
 797
 798         synfig::KeyframeList &keyframe_list(canvas_interface()->get_canvas()->keyframe_list());
 799         if(keyframe_list.empty())
 800                 throw std::runtime_error(_("There are no keyframes n this canvas"));
 801
 802         iter->index=0;
 803
 804         for(iter->iter=keyframe_list.begin();iter->iter!=keyframe_list.end() && *iter->iter!=keyframe;++iter->iter)
 805         {
 806                 iter->index++;
 807         }
 808         if(iter->iter==keyframe_list.end())
 809                 throw std::runtime_error(_("Unable to find Keyframe in table"));
 810         return row;
 811 }
 812
 813 void
 814 KeyframeTreeStore::add_keyframe(synfig::Keyframe keyframe)
 815 {
 816         try
 817         {
 818                 Gtk::TreeRow row(find_row(keyframe));
 819                 dump_iterator(row.gobj(),"add_keyframe,row");
 820                 Gtk::TreePath path(get_path(row));
 821
 822                 row_inserted(path,row);
 823
 824                 old_keyframe_list=get_canvas()->keyframe_list();
 825                 //old_keyframe_list.add(keyframe);
 826                 //old_keyframe_list.sort();
 827         }
 828         catch(std::exception x)
 829         {
 830                 g_warning(x.what());
 831         }
 832 }
 833
 834 void
 835 KeyframeTreeStore::remove_keyframe(synfig::Keyframe keyframe)
 836 {
 837         try
 838         {
 839                 if(1)
 840                 {
 841                         Gtk::TreeRow row(find_row(keyframe));
 842                         dump_iterator(row,"remove_keyframe,row");
 843                         Gtk::TreePath path(get_path(row));
 844                         row_deleted(path);
 845
 846                         old_keyframe_list.erase(keyframe);
 847                 }
 848                 else
 849                 {
 850                         g_warning("KeyframeTreeStore::remove_keyframe: Keyframe not in table");
 851                 }
 852         }
 853         catch(std::exception x)
 854         {
 855                 g_warning(x.what());
 856         }
 857 }
 858
 859 void
 860 KeyframeTreeStore::change_keyframe(synfig::Keyframe keyframe)
 861 {
 862         try
 863         {
 864                 Gtk::TreeRow row(find_row(keyframe));
 865
 866                 unsigned int new_index(get_index_from_model_iter(row));
 867                 unsigned int old_index(0);
 868                 synfig::KeyframeList::iterator iter;
 869                 for(old_index=0,iter=old_keyframe_list.begin();iter!=old_keyframe_list.end() && (UniqueID)*iter!=(UniqueID)keyframe;++iter,old_index++)
 870                         ;
 871
 872                 if(iter!=old_keyframe_list.end() && new_index!=old_index)
 873                 {
 874                         std::vector<int> new_order;
 875                         for(unsigned int i=0;i<old_keyframe_list.size();i++)
 876                         {
 877                                 new_order.push_back(i);
 878                         }
 879                         if(new_order.size()>new_index)
 880                         {
 881                                 new_order.erase(new_order.begin()+new_index);
 882                                 new_order.insert(new_order.begin()+old_index,new_index);
 883
 884                                 //new_order[old_index]=
 885
 886                                 rows_reordered (Path(), iterator(), &new_order[0]);
 887                         }
 888                         old_keyframe_list=get_canvas()->keyframe_list();
 889
 890                         row=find_row(keyframe);
 891                 }
 892
 893                 dump_iterator(row,"change_keyframe,row");
 894                 row_changed(get_path(row),row);
 895         }
 896         catch(std::exception x)
 897         {
 898                 g_warning(x.what());
 899         }
 900 }