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