src/components/timeline/timeline.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by David Cuadrado                                  *
   3  *   krawek@gmail.com                                                     *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include <QList>
  22 #include <QHeaderView>
  23 #include <QVBoxLayout>
  24 #include <QButtonGroup>
  25
  26 #include "timeline.h"
  27 #include <dgui/application.h>
  28 #include <dcore/debug.h>
  29 #include <dgui/iconloader.h>
  30
  31 #include <yamf/model/scene.h>
  32 #include <yamf/model/layer.h>
  33 #include <yamf/model/frame.h>
  34 #include <yamf/model/library.h>
  35 #include <yamf/model/libraryobject.h>
  36
  37 // Dash
  38 #include "dash/datasource.h"
  39 #include "dash/project.h"
  40
  41 #include <QDebug>
  42 #include <QXmlStreamReader>
  43
  44
  45 namespace Dash {
  46 namespace Component {
  47
  48 struct TimeLine::Private
  49 {
  50         Private(TimeLine *q) :  q(q), tlWidget(0) {}
  51
  52
  53         TimeLine *q;
  54         TimeLineWidget *tlWidget;
  55
  56         void updateScene( const Dash::DataSource * datasource, bool undo )
  57         {
  58                 int visualIndex = datasource->values("location")["scene"].toInt();
  59
  60                 QString root = datasource->values("command")["name"];
  61                 if( root == "insertscene")
  62                 {
  63                         if( undo )
  64                         {
  65                                 tlWidget->removeScene(visualIndex);
  66                         }
  67                         else
  68                         {
  69                                 tlWidget->insertScene(visualIndex, datasource->values("scene")["name"]);
  70                                 tlWidget->setScene(visualIndex);
  71                         }
  72                 }
  73                 else if(root == "removescene")
  74                 {
  75                         if( undo )
  76                         {
  77
  78                                 YAMF::Model::Scene *scene = q->project()->scene(visualIndex);
  79
  80                                 tlWidget->insertScene(visualIndex, scene->sceneName());
  81
  82                                 foreach(YAMF::Model::Layer *layer , scene->layers().values())
  83                                 {
  84                                         int layerIndex = layer->visualIndex();
  85                                         tlWidget->insertLayer(visualIndex, layerIndex, layer->layerName());
  86
  87                                         tlWidget->setLayerVisibility(visualIndex, layerIndex, layer->isVisible());
  88                                         tlWidget->setLayerLocked(visualIndex, layerIndex, layer->isLocked());
  89
  90                                         foreach(YAMF::Model::Frame *frame, layer->frames().values())
  91                                         {
  92                                                 tlWidget->insertFrame(visualIndex, layerIndex, frame->visualIndex(), frame->frameName());
  93
  94                                                 tlWidget->setFrameVisibility(visualIndex, layerIndex, frame->visualIndex(), frame->isVisible());
  95                                                 tlWidget->setFrameLocked(visualIndex, layerIndex, frame->visualIndex(),frame->isLocked());
  96                                         }
  97                                 }
  98                                 tlWidget->setScene(visualIndex);
  99                         }
 100                         else
 101                         {
 102                                 tlWidget->removeScene(visualIndex);
 103                         }
 104                 }
 105                 else if(root == "movescene")
 106                 {
 107                         int to = datasource->values("information")["to"].toInt();
 108                         int from = datasource->values("information")["from"].toInt();
 109
 110                         if( undo )
 111                         {
 112                                 tlWidget->moveScene(to, from);
 113                                 tlWidget->setScene(from);
 114                         }
 115                         else
 116                         {
 117                                 tlWidget->moveScene(from, to);
 118                                 tlWidget->setScene(to);
 119                         }
 120                 }
 121                 else if(root == "renamescene")
 122                 {
 123                         tlWidget->blockSignals(true);
 124                         if(undo)
 125                         {
 126                                 tlWidget->renameScene(datasource->values("location")["scene"].toInt(), datasource->values("information")["oldname"]);
 127                         }
 128                         else
 129                         {
 130                                 tlWidget->renameScene(datasource->values("location")["scene"].toInt(), datasource->values("information")["newname"]);
 131                         }
 132                         tlWidget->blockSignals(false);
 133                 }
 134         }
 135
 136         void updateLayer( const Dash::DataSource * datasource, bool undo )
 137         {
 138                 int index = datasource->values("location")["layer"].toInt();
 139                 QString root = datasource->values("command")["name"];
 140
 141                 if(root == "insertlayer")
 142                 {
 143                         int scene = datasource->values("location")["scene"].toInt();
 144                         int type = datasource->values("layer")["type"].toInt();
 145
 146                         if( undo )
 147                         {
 148                                 tlWidget->removeLayer(scene, index);
 149                         }
 150                         else
 151                         {
 152                                 switch(type)
 153                                 {
 154                                         case YAMF::Model::Layer::Vectorial:
 155                                         {
 156                                                 tlWidget->insertLayer(scene, index, datasource->values("layer")["name"]);
 157                                                 tlWidget->setLayer(scene, index);
 158                                         }
 159                                         break;
 160                                         case YAMF::Model::Layer::Audio:
 161                                         {
 162                                                 tlWidget->insertAudioLayer(scene, index, datasource->values("layer")["name"], 0);
 163                                                 tlWidget->setLayer(scene, index);
 164                                         }
 165                                 }
 166                         }
 167                 }
 168                 else if(root == "removelayer")
 169                 {
 170                         int sceneIndex = datasource->values("location")["scene"].toInt();
 171 //                      int type = datasource->values("layer")["type"].toInt();
 172
 173                         if( undo )
 174                         {
 175                                 YAMF::Model::Scene *scene = q->project()->scene(sceneIndex);
 176                                 YAMF::Model::Layer *layer = scene->layer( index );
 177
 178                                 tlWidget->insertLayer(sceneIndex, index, layer->layerName());
 179
 180                                 foreach(YAMF::Model::Frame *frame, layer->frames().values())
 181                                 {
 182                                         tlWidget->insertFrame(sceneIndex, index, frame->visualIndex(), frame->frameName());
 183
 184                                         tlWidget->setFrameVisibility(sceneIndex, index, frame->visualIndex(), frame->isVisible());
 185                                         tlWidget->setFrameLocked(sceneIndex, index, frame->visualIndex(),frame->isLocked());
 186                                 }
 187
 188                                 tlWidget->setLayer(sceneIndex, index);
 189                         }
 190                         else
 191                         {
 192                                 tlWidget->removeLayer(sceneIndex, index);
 193                         }
 194                 }
 195                 else if( root == "locklayer")
 196                 {
 197                         int scene = datasource->values("location")["scene"].toInt();
 198                         bool locked(datasource->values("information")["locked"].toInt());
 199
 200                         if( undo )
 201                         {
 202                                 tlWidget->setLayerLocked(scene, index, !locked);
 203                         }
 204                         else
 205                         {
 206                                 tlWidget->setLayerLocked(scene, index, locked);
 207                         }
 208                 }
 209                 else if( root == "changelayervisibility")
 210                 {
 211                         int scene = datasource->values("location")["scene"].toInt();
 212
 213                         bool visible(datasource->values("information")["visible"].toInt());
 214
 215                         if( undo )
 216                         {
 217                                 tlWidget->setLayerVisibility(scene, index, !visible);
 218                         }
 219                         else
 220                         {
 221                                 tlWidget->setLayerVisibility(scene,  index, visible);
 222                         }
 223                 }
 224                 else if(root == "movelayer")
 225                 {
 226                         int scene = datasource->values("location")["scene"].toInt();
 227
 228                         int from = datasource->values("information")["from"].toInt();
 229                         int to = datasource->values("information")["to"].toInt();
 230
 231                         if( undo )
 232                         {
 233                                 tlWidget->moveLayer(scene, to, from);
 234
 235                                 tlWidget->setLayer(scene, to);
 236                         }
 237                         else
 238                         {
 239                                 tlWidget->moveLayer(scene, from, to);
 240
 241                                 tlWidget->setLayer(scene, to);
 242
 243                         }
 244                 }
 245                 else if(root == "renamelayer")
 246                 {
 247                         int scene = datasource->values("location")["scene"].toInt();
 248                         int index = datasource->values("location")["layer"].toInt();
 249
 250                         tlWidget->blockSignals(true);
 251                         if(undo)
 252                         {
 253                                 tlWidget->renameLayer(scene, index, datasource->values("information")["oldname"]);
 254                         }
 255                         else
 256                         {
 257                                 tlWidget->renameLayer(scene, index, datasource->values("information")["newname"]);
 258                         }
 259                         tlWidget->blockSignals(false);
 260                 }
 261         }
 262
 263         void updateFrame( const Dash::DataSource * datasource, bool undo )
 264         {
 265                 int visualIndex = datasource->values("location")["frame"].toInt();
 266
 267                 QString root = datasource->values("command")["name"];
 268                 if(root == "insertframe")
 269                 {
 270                         int scene = datasource->values("location")["scene"].toInt();
 271                         int layer = datasource->values("location")["layer"].toInt();
 272
 273                         if( undo )
 274                         {
 275                                 tlWidget->removeFrame(scene, layer, visualIndex);
 276                         }
 277                         else
 278                         {
 279                                 tlWidget->insertFrame(scene, layer, visualIndex, datasource->values("frame")["name"]);
 280                                 tlWidget->setFrame(scene, layer, visualIndex);
 281                         }
 282                 }
 283                 else if(root == "removeframe")
 284                 {
 285                         int sceneIndex = datasource->values("location")["scene"].toInt();
 286                         int layerIndex = datasource->values("location")["layer"].toInt();
 287
 288                         if( undo )
 289                         {
 290                                 tlWidget->insertFrame(sceneIndex, layerIndex, visualIndex, datasource->values("frame")["name"]);
 291                         }
 292                         else
 293                         {
 294                                 tlWidget->removeFrame(sceneIndex, layerIndex, visualIndex);
 295                         }
 296                 }
 297                 else if( root == "lockframe")
 298                 {
 299                         int scene = datasource->values("location")["scene"].toInt();
 300                         int layer = datasource->values("location")["layer"].toInt();
 301
 302                         bool locked(datasource->values("information")["locked"].toInt());
 303
 304                         if( undo )
 305                         {
 306                                 tlWidget->setFrameLocked(scene, layer, visualIndex, !locked);
 307                         }
 308                         else
 309                         {
 310                                 tlWidget->setFrameLocked(scene, layer, visualIndex, locked);
 311                         }
 312                 }
 313                 else if( root == "changeframevisibility")
 314                 {
 315                         int scene = datasource->values("location")["scene"].toInt();
 316                         int layer = datasource->values("location")["layer"].toInt();
 317
 318                         bool visible(datasource->values("information")["visible"].toInt());
 319
 320                         if( undo )
 321                         {
 322                                 tlWidget->setFrameVisibility(scene, layer, visualIndex, !visible);
 323                         }
 324                         else
 325                         {
 326                                 tlWidget->setFrameVisibility(scene, layer, visualIndex, visible);
 327                         }
 328                 }
 329                 else if(root == "moveframe")
 330                 {
 331                         int scene = datasource->values("location")["scene"].toInt();
 332                         int layer = datasource->values("location")["layer"].toInt();
 333
 334                         int from = datasource->values("information")["from"].toInt();
 335                         int to = datasource->values("information")["to"].toInt();
 336
 337                         dfDebug << "move from " << from << " to " << to;
 338
 339                         if( undo )
 340                         {
 341                                 tlWidget->moveFrame(scene, layer, to, from);
 342                                 tlWidget->setFrame(scene, layer, from);
 343                         }
 344                         else
 345                         {
 346                                 tlWidget->moveFrame(scene, layer, from, to);
 347                                 tlWidget->setFrame(scene, layer, to);
 348                         }
 349                 }
 350
 351                 else if(root == "renameframe")
 352                 {
 353                         tlWidget->blockSignals(true);
 354                         int scene = datasource->values("location")["scene"].toInt();
 355                         int layer = datasource->values("location")["layer"].toInt();
 356
 357                         if(undo)
 358                         {
 359                                 tlWidget->renameFrame(scene, layer, datasource->values("location")["frame"].toInt(), datasource->values("information")["oldname"]);
 360                         }
 361                         else
 362                         {
 363                                 tlWidget->renameFrame(scene, layer, datasource->values("location")["frame"].toInt(), datasource->values("information")["newname"]);
 364                         }
 365                         tlWidget->blockSignals(false);
 366                 }
 367                 else if(root == "expandframe")
 368                 {
 369                         int scene = datasource->values("location")["scene"].toInt();
 370                         int layer = datasource->values("location")["layer"].toInt();
 371                         int size = datasource->values("information")["size"].toInt();
 372
 373                         if( undo )
 374                         {
 375                                 for(int i = 0; i < size; i++)
 376                                 {
 377                                         tlWidget->removeFrame(scene, layer, visualIndex+1);
 378                                 }
 379                                 tlWidget->destroyGroupFrames(scene, layer, visualIndex, size);
 380                         }
 381                         else
 382                         {
 383                                 for(int i = 1; i < size+1; i++)
 384                                 {
 385                                         tlWidget->insertFrame(scene, layer, visualIndex+i, datasource->values("information")["name"]);
 386                                         tlWidget->setFrame(scene, layer, visualIndex+i);
 387                                 }
 388                                 tlWidget->groupFrames(scene, layer, visualIndex, visualIndex+size);
 389                         }
 390                 }
 391         }
 392 };
 393
 394 /**
 395  * @~spanish
 396  * Constructor
 397  */
 398 TimeLine::TimeLine(Dash::Project *const project, QWidget *parent) : Widget(project, parent), d(new Private(this))
 399 {
 400         QVBoxLayout *layout = new QVBoxLayout(this);
 401         setWindowTitle(tr("&Time Line"));
 402         setWindowIcon( DGui::IconLoader::self()->load("time_line.png"));
 403         d->tlWidget = new TimeLineWidget(this);
 404         layout->addWidget(d->tlWidget);
 405
 406         connect(d->tlWidget, SIGNAL(postEvent(const TimeLineWidget::Event &)), this, SLOT(onEvent(const TimeLineWidget::Event &)));
 407         connect(d->tlWidget, SIGNAL(frameSelected(int , int , int)), this, SLOT(onFrameSelected(int , int , int)));
 408 }
 409
 410 /**
 411  * @~spanish
 412  * Destructor
 413  */
 414 TimeLine::~TimeLine()
 415 {
 416         delete d;
 417 }
 418
 419 /**
 420  * @~spanish
 421  * Retorna los espacios de trabajo donde sera visible el componente, este componente sera visible en todos los espacios de trabajo.
 422  */
 423 Dash::Workspace TimeLine::workspace() const
 424 {
 425         return Dash::All;
 426 }
 427
 428 /**
 429  * @~spanish
 430  * Retorna la posición inicial del componente, la cual es en la parte abajo de la ventana principal.
 431  */
 432 Qt::DockWidgetArea TimeLine::area() const
 433 {
 434         return Qt::BottomDockWidgetArea;
 435 }
 436
 437
 438 /**
 439  * @~spanish
 440  * Retorna el tipo de comandos de los interesa que el componente sea notificado de su ejecución, para este componente se notificara de la ejecución todos los comandos.
 441  */
 442 Dash::DataSource::Types TimeLine::sources() const
 443 {
 444         Dash::DataSource::Type type = Dash::DataSource::All;
 445         return type;
 446 }
 447
 448 /**
 449  * @~spanish
 450  * Actualiza el componente despues de la ejecución de un comando.
 451  */
 452 void TimeLine::update(const Dash::DataSource *datasource, bool undo)
 453 {
 454 //      dfDebug << undo;
 455 //      dfDebug << datasource->data("root").toString();
 456 //      dfDebug << datasource->values("location")["index"];
 457 //      dfDebug << "xml" << datasource->data("xml").toString();
 458
 459         switch (datasource->type())
 460         {
 461                         case DataSource::Scene:
 462                         {
 463                                 d->updateScene(datasource, undo);
 464                         }
 465                         break;
 466                         case DataSource::Layer:
 467                         {
 468                                 d->updateLayer(datasource, undo);
 469                         }
 470                         break;
 471                         case DataSource::Frame:
 472                         {
 473                                 d->updateFrame(datasource, undo);
 474                         }
 475                         break;
 476                         case DataSource::Library:
 477                         case DataSource::Project:
 478                         case DataSource::Object:
 479                         case DataSource::Unknown:
 480                         {
 481                                 dfDebug << "Unhandled package: " << datasource->values("command")["name"];
 482                         }
 483                         break;
 484                         default:
 485                         {
 486
 487                         }
 488         }
 489 }
 490
 491 /**
 492  * @~spanish
 493  * Reinicia el componente, borra todas las escenas, frames y layers.
 494  */
 495 void TimeLine::reset()
 496 {
 497         d->tlWidget->closeAllScenes();
 498 }
 499
 500 /**
 501  * @internal
 502  */
 503 void TimeLine::onFrameSelected(int scenePos, int layerPos, int framePos)
 504 {
 505         emit frameSelected(scenePos, layerPos, framePos);
 506 }
 507
 508 /**
 509  * @internal
 510  */
 511 void TimeLine::onEvent(const TimeLineWidget::Event &event )
 512 {
 513         dfDebug << "scene = " << event.scene << " layer = " << event.layer << " frame = " << event.frame << " action " << event.action << " data " << event.data.toString();
 514
 515         switch(event.action)
 516         {
 517                 case TimeLineWidget::InsertFrame:
 518                 {
 519                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 520                         if(scene)
 521                         {
 522                                 YAMF::Model::Layer *layer = scene->layer(event.layer);
 523                                 if(layer)
 524                                 {
 525                                         layer->createFrame(event.frame);
 526                                 }
 527                         }
 528                 }
 529                 break;
 530                 case TimeLineWidget::RemoveFrame:
 531                 {
 532                         if(event.scene > -1 && event.layer > -1 &&  event.frame > -1)
 533                         {
 534                                 YAMF::Model::Scene *scene = project()->scene(event.scene);
 535                                 if( scene )
 536                                 {
 537                                         YAMF::Model::Layer *layer = scene->layer(event.layer);
 538                                         if( layer )
 539                                         {
 540                                                 YAMF::Model::Frame *frame = layer->frame(event.frame);
 541                                                 if( frame )
 542                                                 {
 543                                                         layer->removeFrame(frame);
 544                                                 }
 545                                         }
 546                                 }
 547                         }
 548                 }
 549                 case TimeLineWidget::CopyFrame:
 550                 {
 551                         project()->copyFrameToClipboard(event.scene, event.layer, event.frame);
 552                 }
 553                 break;
 554                 case TimeLineWidget::PasteFrame:
 555                 {
 556                         project()->pasteFrameFromClipboard(event.scene, event.layer, event.frame);
 557                 }
 558                 break;
 559                 case TimeLineWidget::CutFrame:
 560                 {
 561                         project()->cutFrame(event.scene, event.layer, event.frame);
 562                 }
 563                 break;
 564                 case TimeLineWidget::MoveFrameUp:
 565                 {
 566                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 567                         YAMF::Model::Layer *layer = scene->layer(event.layer);
 568
 569                         YAMF::Model::Frame *frame = layer->frame(event.frame);
 570                         if(frame)
 571                         {
 572 //                              int nclones = layer->clones(frame);
 573                                 layer->moveFrame(frame->visualIndex(), frame->visualIndex()-1);
 574                         }
 575                 }
 576                 break;
 577                 case TimeLineWidget::MoveFrameDown:
 578                 {
 579                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 580                         YAMF::Model::Layer *layer = scene->layer(event.layer);
 581                         YAMF::Model::Frame *frame = layer->frame(event.frame);
 582
 583                         if(frame)
 584                         {
 585                                 int nclones = layer->clones(frame);
 586                                 layer->moveFrame(frame->visualIndex(), frame->visualIndex()+nclones+1);
 587                         }
 588                 }
 589                 break;
 590                 case TimeLineWidget::LockFrame:
 591                 {
 592                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 593                         YAMF::Model::Layer *layer = scene->layer(event.layer);
 594                         YAMF::Model::Frame *frame = layer->frame(event.frame);
 595                         frame->setLocked(event.data.toBool());
 596                 }
 597                 break;
 598                 case TimeLineWidget::RenameFrame:
 599                 {
 600                 }
 601                 break;
 602                 case TimeLineWidget::ChangeFrameVisibility:
 603                 {
 604                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 605                         YAMF::Model::Layer *layer = scene->layer(event.layer);
 606                         YAMF::Model::Frame *frame = layer->frame(event.frame);
 607                         frame->setVisible(event.data.toBool());
 608                 }
 609                 break;
 610                 case TimeLineWidget::ExpandFrame:
 611                 {
 612                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 613                         YAMF::Model::Layer *layer = scene->layer(event.layer);
 614                         layer->expandFrame(event.frame, event.data.toInt());
 615                 }
 616                 break;
 617                 case TimeLineWidget::InsertLayer:
 618                 {
 619                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 620                         if(scene)
 621                         {
 622                                 YAMF::Model::Layer *layer = scene->createLayer( event.layer+1 );
 623                                 if(layer)
 624                                 {
 625                                         layer->createFrame();
 626                                 }
 627                         }
 628                 }
 629                 break;
 630                 case TimeLineWidget::RemoveLayer:
 631                 {
 632                         if(event.scene > -1 && event.layer > -1)
 633                         {
 634                                 YAMF::Model::Scene *scene = project()->scene(event.scene);
 635                                 YAMF::Model::Layer *layer = scene->layer(event.layer);
 636                                 scene->removeLayer(layer);
 637                         }
 638                 }
 639                 break;
 640                 case TimeLineWidget::MoveLayerUp:
 641                 {
 642                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 643                         scene->moveLayer(event.layer, event.layer-1);
 644                 }
 645                 break;
 646                 case TimeLineWidget::MoveLayerDown:
 647                 {
 648                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 649                         scene->moveLayer(event.layer, event.layer+1);
 650                 }
 651                 break;
 652                 case TimeLineWidget::LockLayer:
 653                 {
 654                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 655                         YAMF::Model::Layer *layer = scene->layer(event.layer);
 656                         layer->setLocked(event.data.toBool());
 657                 }
 658                 break;
 659                 case TimeLineWidget::RenameLayer:
 660                 {
 661                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 662                         YAMF::Model::Layer *layer = scene->layer(event.layer);
 663                         layer->setLayerName(event.data.toString());
 664                 }
 665                 break;
 666                 case TimeLineWidget::ChangeLayerVisibility:
 667                 {
 668                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 669                         YAMF::Model::Layer *layer = scene->layer(event.layer);
 670                         layer->setVisible(event.data.toBool());
 671                 }
 672                 break;
 673
 674                 case TimeLineWidget::InsertScene:
 675                 {
 676                         YAMF::Model::Scene *scene = project()->createScene(event.scene+1);
 677                         YAMF::Model::Layer *layer = scene->createLayer();
 678                         layer->createFrame();
 679                 }
 680                 break;
 681                 case TimeLineWidget::RemoveScene:
 682                 {
 683                         if(event.scene > -1)
 684                         {
 685                                 YAMF::Model::Scene *scene = project()->scene(event.scene);
 686                                 if(scene)
 687                                 {
 688                                         project()->removeScene(scene);
 689                                 }
 690                         }
 691                 }
 692                 break;
 693                 case TimeLineWidget::MoveSceneUp:
 694                 {
 695                         project()->moveScene(event.scene, event.scene-1);
 696                 }
 697                 break;
 698                 case TimeLineWidget::MoveSceneDown:
 699                 {
 700                         project()->moveScene(event.scene, event.scene+1);
 701                 }
 702                 break;
 703                 case TimeLineWidget::LockScene:
 704                 {
 705                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 706                         scene->setLocked(event.data.toBool());
 707                 }
 708                 break;
 709                 case TimeLineWidget::RenameScene:
 710                 {
 711                         YAMF::Model::Scene *scene = project()->scene(event.scene);
 712                         scene->setSceneName(event.data.toString());
 713                 }
 714                 break;
 715         }
 716
 717 }
 718
 719 }
 720 }