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