src/components/timeline/timelinewidget.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Jorge Cuadrado                                  *
   3  *   kuadrosxx@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 "timelinewidget.h"
  22
  23 #include "layermanager.h"
  24 #include "framestable.h"
  25
  26 #include <QStackedWidget>
  27 #include <QTreeWidget>
  28 #include <QHeaderView>
  29 #include <QLayout>
  30 #include <QTimer>
  31
  32 #include <dgui/iconloader.h>
  33 #include <dgui/imagebutton.h>
  34
  35 #include <dcore/debug.h>
  36
  37 #include "ui_frames.h"
  38 #include "ui_layers.h"
  39 #include "ui_scenes.h"
  40
  41 namespace Dash {
  42 namespace Component {
  43
  44 struct TimeLineWidget::Private
  45 {
  46         Ui::Frames frames;
  47         Ui::Layers layers;
  48         Ui::Scenes scenes;
  49
  50         QButtonGroup actions;
  51
  52         QTimer timer;
  53
  54
  55         TimeLineWidget::Event createEvent(TimeLineWidget *tl, TimeLineWidget::Action action)
  56         {
  57                 Event event;
  58                 event.action = Action(action);
  59                 event.scene = tl->scene();
  60                 event.layer = tl->layer();
  61                 event.frame = tl->frame();
  62                 return event;
  63         }
  64 };
  65
  66 /**
  67  * @~spanish
  68  * Constructor
  69  */
  70 TimeLineWidget::TimeLineWidget(QWidget * parent)
  71  : QSplitter(Qt::Horizontal, parent), d(new Private)
  72 {
  73         QWidget *scenesWidget = new QWidget;
  74         d->scenes.setupUi(scenesWidget);
  75         addWidget(scenesWidget);
  76
  77         QWidget *layersWidget = new QWidget;
  78         d->layers.setupUi(layersWidget);
  79         addWidget(layersWidget);
  80
  81         QWidget *framesWidget = new QWidget;
  82         d->frames.setupUi(framesWidget);
  83         addWidget(framesWidget);
  84
  85         d->scenes.container->setHeaderLabels(QStringList() << tr("Scene"));
  86         connect(d->scenes.container, SIGNAL(itemClicked( QTreeWidgetItem *, int)), this, SLOT(onItemClicked(QTreeWidgetItem *, int)));
  87
  88         connect(d->scenes.container, SIGNAL(itemChanged( QTreeWidgetItem *, int)), this, SLOT(onItemChanged(QTreeWidgetItem *, int)));
  89
  90         connect(&d->actions, SIGNAL(buttonClicked(int)), this, SLOT(onButtonClicked(int)));
  91
  92         connect(&d->timer, SIGNAL(timeout()), this, SLOT(nextFrame()));
  93
  94         setupButtons();
  95
  96         setSizes(QList<int>() << 100 << 200 << 800);
  97 }
  98
  99
 100 /**
 101  * @~spanish
 102  * Destructor
 103  */
 104 TimeLineWidget::~TimeLineWidget()
 105 {
 106         delete d;
 107 }
 108
 109 /**
 110  * @~spanish
 111  * Obtiene la posición de la escena actualmente seleccionada.
 112  */
 113 int TimeLineWidget::scene()
 114 {
 115         if(d->scenes.container->topLevelItemCount() == 0)
 116                 return -1;
 117
 118         return d->scenes.container->indexOfTopLevelItem(d->scenes.container->currentItem());
 119 }
 120
 121 /**
 122  * @~spanish
 123  * Obtiene la posición del layer actualmente seleccionad0.
 124  */
 125 int TimeLineWidget::layer()
 126 {
 127         const LayerManager *layers = layerManager(scene());
 128
 129         if(layers )
 130         {
 131                 if( layers->rowCount() == 0 )
 132                 {
 133                         return -1;
 134                 }
 135                 if(layers->currentRow() == -1)
 136                 {
 137                         return -2;
 138                 }
 139                 return layers->visualRow(layers->currentRow());
 140         }
 141         return -1;
 142 }
 143
 144 /**
 145  * @~spanish
 146  * Obtiene la posición del frame actualmente seleccionado.
 147  */
 148 int TimeLineWidget::frame()
 149 {
 150         FramesTable *frames = framesTable(scene());
 151         if(frames)
 152         {
 153                 if(frames->columnCount() == 0)
 154                 {
 155                         return -1;
 156                 }
 157
 158                 if(frames->currentColumn() == -1)
 159                 {
 160                         return -2;
 161                 }
 162
 163                 return frames->visualColumn(frames->currentColumn());
 164         }
 165         return -1;
 166 }
 167
 168 /**
 169  * @~spanish
 170  * Inserta una escena el la posición @p position y con el nombre @p name.
 171  */
 172 void TimeLineWidget::insertScene(int position, const QString &name)
 173 {
 174         if ( position < 0 || position > d->scenes.container->topLevelItemCount())
 175         {
 176                 return;
 177         }
 178
 179         LayerManager *layerManager = new LayerManager( d->layers.container );
 180
 181         connect(layerManager, SIGNAL(layerRenamed(int, const QString &)), this, SLOT(onLayerRenamed(int , const QString &)));
 182         connect(layerManager, SIGNAL(layerLocked(int, bool)), this, SLOT(onLayerLocked(int , bool)));
 183         connect(layerManager, SIGNAL(layerVisibilityChanged(int, bool)), this, SLOT(onLayerVisibilityChanged(int , bool)));
 184
 185         layerManager->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 186
 187         FramesTable *framesTable = new FramesTable();
 188
 189         connect(framesTable, SIGNAL(frameSelected(int , int)), this, SLOT(onFrameSelected(int , int )));
 190         connect(framesTable, SIGNAL(layerSelected(int)), this, SLOT(onLayerSelected(int)));
 191         connect(framesTable, SIGNAL(requestInsertFrame(int, int)), this, SLOT(onRequestInsertFrame(int, int)));
 192         connect(framesTable, SIGNAL(requestRemoveFrame(int, int)), this, SLOT(onRequestRemoveFrame(int, int)));
 193
 194         connect(framesTable, SIGNAL(requestCopyFrame(int, int)), this, SLOT(onRequestCopyFrame(int, int)));
 195         connect(framesTable, SIGNAL(requestPasteFrame(int, int)), this, SLOT(onRequestPasteFrame(int, int)));
 196         connect(framesTable, SIGNAL(requestCutFrame(int, int)), this, SLOT(onRequestCutFrame(int, int)));
 197
 198         connect(framesTable, SIGNAL(requestChangeFrameVisibility(int, int, bool)), this, SLOT(onRequestChangeFrameVisibility(int, int, bool)));
 199         connect(framesTable, SIGNAL(requestLockFrame(int, int, bool)), this, SLOT(onRequestLockFrame(int, int, bool)));
 200
 201         connect(framesTable, SIGNAL(requestExpandFrame(int, int, int)), this, SLOT(onRequestExpandFrame(int, int, int)));
 202
 203         framesTable->setItemSize( 10, 20);
 204         layerManager->setRowHeight( 20 );
 205
 206         connect(layerManager->verticalScrollBar(), SIGNAL(valueChanged (int)), framesTable->verticalScrollBar(), SLOT(setValue(int)));
 207         connect(framesTable->verticalScrollBar(), SIGNAL(valueChanged (int)), layerManager->verticalScrollBar(), SLOT(setValue(int)));
 208
 209
 210         d->frames.container->insertWidget(position, framesTable);
 211         d->layers.container->insertWidget(position, layerManager);
 212
 213         QTreeWidgetItem *newScene = new QTreeWidgetItem;
 214         newScene->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 215         newScene->setText(0, name);
 216         d->scenes.container->insertTopLevelItem(position, newScene);
 217 }
 218
 219
 220 /**
 221  * @~spanish
 222  * Elimina la escena que esta en la posición @p position.
 223  */
 224 void TimeLineWidget::removeScene(int position)
 225 {
 226         if ( position >= 0 && position < d->frames.container->count() && position < d->layers.container->count() )
 227         {
 228                 QWidget *w = d->frames.container->widget(position);
 229                 d->frames.container->removeWidget(w);
 230                 delete w;
 231
 232                 w = d->layers.container->widget(position);
 233                 d->layers.container->removeWidget(w);
 234                 delete w;
 235
 236                 delete d->scenes.container->topLevelItem(position);
 237         }
 238
 239 }
 240
 241 /**
 242  * @~spanish
 243  * Cambia el nombre de la escena que esta en la posición @p position a @p name.
 244  */
 245 void TimeLineWidget::renameScene(int position, const QString &name)
 246 {
 247         if(position < 0 || position >= d->scenes.container->topLevelItemCount() ) return;
 248         d->scenes.container->topLevelItem(position)->setText(0, name);
 249 }
 250
 251 /**
 252  * @~spanish
 253  * Mueve la escena de la posición @p from a la posición @p to.
 254  */
 255 void TimeLineWidget::moveScene(int from, int to)
 256 {
 257         if(to < from)
 258         {
 259                 int swap = to;
 260                 to = from;
 261                 from = swap;
 262         }
 263
 264         for(int i = from; i < to; i++)
 265         {
 266                 d->scenes.container->insertTopLevelItem(i, d->scenes.container->takeTopLevelItem(i+1) );
 267
 268                 d->frames.container->insertWidget(i, d->frames.container->widget(i+1));
 269
 270                 d->layers.container->insertWidget(i, d->layers.container->widget(i+1));
 271         }
 272 }
 273
 274 /**
 275  * @~spanish
 276  * Selecciona la escena que esta en la posición @p position.
 277  */
 278 void TimeLineWidget::setScene(int position)
 279 {
 280         QTreeWidgetItem *item = d->scenes.container->topLevelItem ( position );
 281         if(item)
 282         {
 283                 d->scenes.container->setCurrentItem(item);
 284         }
 285
 286         d->frames.container->setCurrentIndex(position);
 287         d->layers.container->setCurrentIndex(position);
 288 }
 289
 290
 291 /**
 292  * @~spanish
 293  * Cierra todas las escenas.
 294  */
 295 void TimeLineWidget::closeAllScenes()
 296 {
 297         while(d->frames.container->currentWidget())
 298         {
 299                 delete d->frames.container->currentWidget();
 300         }
 301
 302         while(d->layers.container->currentWidget())
 303         {
 304                 delete d->layers.container->currentWidget();
 305         }
 306         d->scenes.container->clear();
 307 }
 308
 309 /**
 310  * @~spanish
 311  * Inserta un layer en la posición @p position de la escena @p scenePos, con el nombre @p name.
 312  */
 313 void TimeLineWidget::insertLayer(int scenePos, int position, const QString &name)
 314 {
 315         LayerManager *layerManager = this->layerManager(scenePos);
 316         if(layerManager)
 317         {
 318                 layerManager->insertLayer(position, name);
 319         }
 320
 321         FramesTable *fst = framesTable( scenePos );
 322         if( fst )
 323         {
 324                 fst->insertLayer(position, name);
 325         }
 326 }
 327
 328 /**
 329  * @~spanish
 330  * Inserta un layer de audio en la posición @p position de la escena @p scenePos, con el nombre @p name y la posición del frame donde inicia el audio.
 331  */
 332 void TimeLineWidget::insertAudioLayer(int scenePos, int position, const QString &name, int startFrame)
 333 {
 334         LayerManager *layerManager = this->layerManager(scenePos);
 335         if(layerManager)
 336         {
 337                 layerManager->insertSoundLayer(position, name);
 338         }
 339
 340         FramesTable *fst = framesTable( scenePos );
 341         if( fst )
 342         {
 343                 fst->insertSoundLayer(position, name);
 344                 for(int i = startFrame; i < fst->columnCount(); i++)
 345                 {
 346                         fst->insertFrame(position, i, tr(" "));
 347                 }
 348         }
 349 }
 350
 351 /**
 352  * @~spanish
 353  * Elimina el layer que esta en la posicion @p position de la escena @p scenePos.
 354  */
 355 void TimeLineWidget::removeLayer(int scenePos, int position)
 356 {
 357         LayerManager *layerManager = this->layerManager(scenePos);
 358         if(layerManager)
 359         {
 360                 layerManager->removeLayer(position);
 361         }
 362
 363         FramesTable *fst = framesTable( scenePos );
 364         if( fst )
 365         {
 366                 fst->removeLayer(position);
 367         }
 368 }
 369
 370 /**
 371  * @~spanish
 372  * Cambia el nombre del layer que se encuentra en la posicion @p layerPos de la escena @p scenePos, por @p name.
 373  */
 374 void TimeLineWidget::renameLayer(int scenePos, int layerPos, const QString &name)
 375 {
 376         LayerManager *layerManager = this->layerManager(scenePos);
 377         if(layerManager)
 378         {
 379                 layerManager->renameLayer(layerPos, name);
 380         }
 381 }
 382
 383 /**
 384  * @~spanish
 385  * Cambia el estado de visibilidad del layer que esta en la posición @p position de la escena @p scenePos, si @p isVisible es verdadero muestra el layer como visible y si es falso lo muestra como no visible.
 386  */
 387 void TimeLineWidget::setLayerVisibility(int scenePos, int position, bool isVisible)
 388 {
 389         LayerManager *layerManager = this->layerManager(scenePos);
 390         layerManager->blockSignals(true);
 391         if(layerManager)
 392         {
 393                 QTableWidgetItem *item = layerManager->item(layerManager->visualRow(position), 2);
 394                 if(isVisible)
 395                 {
 396                         item->setCheckState(Qt::Checked);
 397                 }
 398                 else
 399                 {
 400                         item->setCheckState(Qt::Unchecked);
 401                 }
 402
 403         }
 404         layerManager->blockSignals(false);
 405 }
 406
 407 /**
 408  * @~spanish
 409  * Cambia el estado de bloqueo del layer que esta en la posición @p position de la escena @p scenePos, si @p locked es verdadero muestra el layer como bloqueado y si es falso lo muestra como desbloqueado.
 410  */
 411 void TimeLineWidget::setLayerLocked(int scenePos, int position, bool locked)
 412 {
 413         LayerManager *layerManager = this->layerManager(scenePos);
 414         layerManager->blockSignals(true);
 415         if(layerManager)
 416         {
 417                 QTableWidgetItem *item = layerManager->item(layerManager->visualRow( position ), 1);
 418                 if(locked)
 419                 {
 420                         item->setCheckState(Qt::Checked);
 421                 }
 422                 else
 423                 {
 424                         item->setCheckState(Qt::Unchecked);
 425                 }
 426         }
 427         layerManager->blockSignals(false);
 428 }
 429
 430 /**
 431  * @~spanish
 432  * Mueve el layer de la posición @p from a la posición @p to.
 433  */
 434 void TimeLineWidget::moveLayer(int scenePos, int from, int to)
 435 {
 436         LayerManager *layerManager = this->layerManager( scenePos );
 437         if ( layerManager )
 438         {
 439                 layerManager->moveLayer( from, to);
 440         }
 441
 442         FramesTable *framesTable = this->framesTable( scenePos );
 443         if ( framesTable )
 444         {
 445                 framesTable->moveLayer(from, to);
 446         }
 447 }
 448
 449 /**
 450  * @~spanish
 451  * Selecciona el layer que esta en la posición @p position, de la escena @p scenePos.
 452  */
 453 void TimeLineWidget::setLayer(int scenePos, int position)
 454 {
 455         setScene(scenePos);
 456
 457         LayerManager *layerManager = this->layerManager( scenePos );
 458         if(layerManager)
 459         {
 460                 layerManager->setCurrentCell(layerManager->verticalHeader()->logicalIndex(position) , 0);
 461         }
 462 }
 463
 464 /**
 465  * @~spanish
 466  * Inserta un frame en la posición @p position, del layer @p layerPos de la escena @p scenePos, con nombre @p name.
 467  */
 468 void TimeLineWidget::insertFrame(int scenePos, int layerPos, int position, const QString &name)
 469 {
 470         FramesTable *framesTable = this->framesTable( scenePos );
 471         if ( framesTable )
 472         {
 473                 framesTable->insertFrame(layerPos, position, name);
 474         }
 475 }
 476
 477 /**
 478  * @~spanish
 479  * Elimina el frame que se encuentra en la posición @p position, del layer @p layerPos de la escena @p scenePos.
 480  */
 481 void TimeLineWidget::removeFrame(int scenePos, int layerPos, int position)
 482 {
 483         FramesTable *framesTable = this->framesTable( scenePos );
 484         if ( framesTable )
 485         {
 486                 framesTable->removeFrame( layerPos, position );
 487         }
 488 }
 489
 490 /**
 491  * @~spanish
 492  * Cambia el nombre del frame que se encuentra en la posición @p position, del layer @p layerPos de la escena @p scenePos, por @p name.
 493  */
 494 void TimeLineWidget::renameFrame(int scenePos, int layerPos, int position, const QString &name)
 495 {
 496         Q_UNUSED(layerPos);
 497         Q_UNUSED(position);
 498         Q_UNUSED(name);
 499         FramesTable *framesTable = this->framesTable( scenePos );
 500         if ( framesTable )
 501         {
 502 //              framesTable->renameFrame( layerPos, position );
 503                 //TODO: poner nombre en el item
 504         }
 505 }
 506
 507 /**
 508  * @~spanish
 509  * Mueve el frame de la posición @p from a la posición @p to.
 510  */
 511 void TimeLineWidget::moveFrame(int scenePos, int layerPos, int from, int to)
 512 {
 513         FramesTable *framesTable = this->framesTable( scenePos );
 514         if ( framesTable )
 515         {
 516                 framesTable->moveFrame(layerPos, from, to);
 517         }
 518 }
 519
 520 /**
 521  * @~spanish
 522  * Selecciona el frame que se encuentra en la posición @p position, del layer @p layerPos de la escena @p scenePos.
 523  */
 524 void TimeLineWidget::setFrame(int scenePos, int layerPos, int position)
 525 {
 526         setLayer(scenePos, layerPos);
 527
 528         FramesTable *framesTable = this->framesTable( scenePos );
 529         if ( framesTable )
 530         {
 531                 framesTable->setCurrentCell( framesTable->visualRow(layerPos), position );
 532         }
 533 }
 534
 535 /**
 536  * @~spanish
 537  * Cambia el estado de visibilidad del frame que se encuentra en la posición @p position, del layer @p layerPos de la escena @p scenePos por @p isVisible, si es verdadero el frame se mostrara como visible, de lo contrario se mostrara como no visible.
 538  */
 539 void TimeLineWidget::setFrameVisibility(int scenePos, int layerPos, int position, bool isVisible)
 540 {
 541         FramesTable *framesTable = this->framesTable( scenePos );
 542         if ( framesTable )
 543         {
 544                 framesTable->setFrameVisibility(layerPos, position, isVisible);
 545         }
 546 }
 547
 548 /**
 549  * @~spanish
 550  * Cambia el estado de bloqueo del frame que se encuentra en la posición @p position, del layer @p layerPos de la escena @p scenePos por @p locked, si es verdadero el frame se mostrara como bloqueado, de lo contrario se mostrara como desbloqueado.
 551  */
 552 void TimeLineWidget::setFrameLocked(int scenePos, int layerPos, int position, bool locked)
 553 {
 554         FramesTable *framesTable = this->framesTable( scenePos );
 555         if ( framesTable )
 556         {
 557                 framesTable->lockFrame(layerPos, position, locked);
 558         }
 559 }
 560
 561 /**
 562  * @~spanish
 563  * Agrupa los frames desde la posición @p from hasta la posición @p to.
 564  */
 565 void TimeLineWidget::groupFrames(int scenePos, int layerPos, int from, int to)
 566 {
 567         FramesTable *framesTable = this->framesTable( scenePos );
 568         if ( framesTable )
 569         {
 570                 framesTable->groupFrames(layerPos, from, to);
 571         }
 572 }
 573
 574 /**
 575  * @~spanish
 576  * Aumenta la duración del frame que se encuentra en la posición @p position, del layer @p layerPos de la escena @p scenePos a @p size.
 577  */
 578 void TimeLineWidget::expandFrame(int scenePos, int layerPos, int position, int size)
 579 {
 580         FramesTable *framesTable = this->framesTable( scenePos );
 581         if ( framesTable )
 582         {
 583                 framesTable->expandFrame(layerPos, position, size);
 584         }
 585 }
 586
 587 /**
 588  * @~spanish
 589  * Destruye el grupo de frames que se encuentra en la posición @p position, del layer @p layerPos de la escena @p scenePos.
 590  */
 591 void TimeLineWidget::destroyGroupFrames(int scenePos, int layerPos, int position, int size)
 592 {
 593         FramesTable *framesTable = this->framesTable( scenePos );
 594         if ( framesTable )
 595         {
 596                 framesTable->destroyGroupFrames(layerPos, position, size);
 597         }
 598 }
 599
 600 /**
 601  *
 602  */
 603 void TimeLineWidget::playScene()
 604 {
 605         if(d->timer.isActive ())
 606         {
 607                 d->timer.stop();
 608                 d->scenes.play->setIcon(DGui::IconLoader::self()->load("media-playback-start.svg"));
 609                 return;
 610         }
 611
 612         int scenePos = scene();
 613
 614         FramesTable *framesTable = this->framesTable( scenePos );
 615         int layer = 0;
 616         if ( framesTable )
 617         {
 618                 int maxFrames = 0;
 619
 620                 for(int i = 0; i < framesTable->rowCount(); i++)
 621                 {
 622                         int lastFrame = framesTable->lastFrameByLayer(i);
 623
 624                         if(maxFrames < lastFrame && !framesTable->isSoundLayer(i))
 625                         {
 626                                 maxFrames = lastFrame;
 627                                 layer = i;
 628                         }
 629                 }
 630
 631                 setFrame(scenePos, layer, frame());
 632                 d->scenes.play->setIcon(DGui::IconLoader::self()->load("media-playback-pause.svg"));
 633                 d->timer.start(200);
 634         }
 635 }
 636
 637 /**
 638  * @internal
 639  */
 640 void TimeLineWidget::onItemClicked(QTreeWidgetItem *item, int)
 641 {
 642         int index = d->scenes.container->indexOfTopLevelItem(item);
 643         d->frames.container->setCurrentIndex(index);
 644         d->layers.container->setCurrentIndex(index);
 645 }
 646
 647 /**
 648  * @internal
 649  */
 650 void TimeLineWidget::onItemChanged(QTreeWidgetItem *item, int column)
 651 {
 652         Event event;
 653         event.scene = d->scenes.container->indexOfTopLevelItem(item);
 654         event.action = RenameScene;
 655         event.data = item->text(column);
 656         emit postEvent(event);
 657 }
 658
 659 /**
 660  * @internal
 661  */
 662 void TimeLineWidget::onFrameSelected(int layerPosition, int framePosition)
 663 {
 664 //      int lastFrame = 0;
 665
 666         emit frameSelected(d->frames.container->currentIndex(), layerPosition, framePosition);
 667         setLayer(d->frames.container->currentIndex(), layerPosition);
 668 }
 669
 670 /**
 671  * @internal
 672  */
 673 void TimeLineWidget::onLayerSelected(int layerPosition)
 674 {
 675         setLayer(d->frames.container->currentIndex(), layerPosition);
 676 }
 677
 678 /**
 679  * @internal
 680  */
 681 void TimeLineWidget::onLayerRenamed(int layerPosition, const QString &newName)
 682 {
 683         Event event;
 684         event.scene = d->layers.container->currentIndex();
 685         event.layer = layerPosition;
 686         event.action = RenameLayer;
 687         event.data = newName;
 688
 689         emit postEvent(event);
 690 }
 691
 692 /**
 693  * @internal
 694  */
 695 void TimeLineWidget::onLayerLocked(int layerPosition, bool locked)
 696 {
 697         Event event;
 698         event.scene = d->layers.container->currentIndex();
 699         event.layer = layerPosition;
 700         event.action = LockLayer;
 701         event.data = locked;
 702
 703         emit postEvent(event);
 704 }
 705
 706 /**
 707  * @internal
 708  */
 709 void TimeLineWidget::onLayerVisibilityChanged(int layerPosition, bool isVisible)
 710 {
 711         Event event;
 712         event.scene = d->layers.container->currentIndex();
 713         event.layer = layerPosition;
 714         event.action = ChangeLayerVisibility;
 715         event.data = isVisible;
 716
 717         emit postEvent(event);
 718 }
 719
 720 /**
 721  * @internal
 722  */
 723 void TimeLineWidget::onButtonClicked(int action)
 724 {
 725         Event e = d->createEvent(this, Action(action));
 726
 727         if(e.action == InsertFrame)
 728         {
 729                 int lastFrame = 0;
 730
 731                 FramesTable *frames = framesTable(scene());
 732                 if(frames)
 733                 {
 734                         lastFrame = frames->lastFrameByLayer(e.layer);
 735                 }
 736
 737                 int frame = e.frame;
 738
 739                 if(lastFrame < e.frame )
 740                 {
 741                         for(int i = lastFrame+1; i < frame+1; i++)
 742                         {
 743                                 e.frame = i;
 744                                 emit postEvent(e);
 745                         }
 746                         return;
 747                 }
 748                 else
 749                 {
 750                         e.frame++;
 751                 }
 752         }
 753
 754         emit postEvent(e);
 755
 756 }
 757
 758 /**
 759  * @internal
 760  */
 761 void TimeLineWidget::onRequestInsertFrame(int layerPosition, int framePosition)
 762 {
 763         Event e = d->createEvent(this, InsertFrame);
 764
 765         int lastFrame = 0;
 766
 767         FramesTable *frames = framesTable(scene());
 768         if(frames)
 769         {
 770                 lastFrame = frames->lastFrameByLayer(e.layer);
 771         }
 772
 773         int frame = e.frame;
 774
 775         if(lastFrame < e.frame )
 776         {
 777                 for(int i = lastFrame+1; i < frame+1; i++)
 778                 {
 779                         e.frame = i;
 780                         emit postEvent(e);
 781                 }
 782                 return;
 783         }
 784         else
 785         {
 786                 e.frame++;
 787         }
 788
 789         emit postEvent(e);
 790 }
 791
 792 /**
 793  * @internal
 794  */
 795 void TimeLineWidget::onRequestRemoveFrame(int layerPosition, int framePosition)
 796 {
 797         Event event;
 798         event.scene = d->layers.container->currentIndex();
 799         event.layer = layerPosition;
 800         event.frame = framePosition;
 801         event.action = RemoveFrame;
 802
 803         emit postEvent(event);
 804 }
 805
 806 /**
 807  * @internal
 808  */
 809 void TimeLineWidget::onRequestCopyFrame(int layerPosition, int framePosition)
 810 {
 811         Event event;
 812         event.scene = d->layers.container->currentIndex();
 813         event.layer = layerPosition;
 814         event.frame = framePosition;
 815         event.action = CopyFrame;
 816
 817         emit postEvent(event);
 818 }
 819
 820 /**
 821  * @internal
 822  */
 823 void TimeLineWidget::onRequestPasteFrame(int layerPosition, int framePosition)
 824 {
 825         Event e = d->createEvent(this, PasteFrame);
 826
 827         int lastFrame = 0;
 828
 829         FramesTable *frames = framesTable(scene());
 830         if(frames)
 831         {
 832                 lastFrame = frames->lastFrameByLayer(e.layer);
 833         }
 834
 835         int frame = e.frame;
 836
 837         if(lastFrame < e.frame )
 838         {
 839                 for(int i = lastFrame+1; i < frame+1; i++)
 840                 {
 841                         e.frame = i;
 842                         emit postEvent(e);
 843                 }
 844                 return;
 845         }
 846         else
 847         {
 848                 e.frame++;
 849         }
 850
 851         emit postEvent(e);
 852         /*
 853         Event event;
 854         event.scene = d->layers.container->currentIndex();
 855         event.layer = layerPosition;
 856         event.frame = framePosition;
 857         event.action = PasteFrame;
 858
 859         emit postEvent(event);*/
 860 }
 861
 862 /**
 863  * @internal
 864  */
 865 void TimeLineWidget::onRequestCutFrame(int layerPosition, int framePosition)
 866 {
 867         Event event;
 868         event.scene = d->layers.container->currentIndex();
 869         event.layer = layerPosition;
 870         event.frame = framePosition;
 871         event.action = CutFrame;
 872
 873         emit postEvent(event);
 874 }
 875
 876 /**
 877  * @internal
 878  */
 879 void TimeLineWidget::onRequestLockFrame(int layerPosition, int framePosition, bool locked)
 880 {
 881         Event event;
 882         event.scene = d->layers.container->currentIndex();
 883         event.layer = layerPosition;
 884         event.frame = framePosition;
 885         event.action = LockFrame;
 886         event.data = locked;
 887
 888         emit postEvent(event);
 889 }
 890
 891 /**
 892  * @internal
 893  */
 894 void TimeLineWidget::onRequestChangeFrameVisibility(int layerPosition, int framePosition, bool visibility)
 895 {
 896         Event event;
 897         event.scene = d->layers.container->currentIndex();
 898         event.layer = layerPosition;
 899         event.frame = framePosition;
 900         event.action = ChangeFrameVisibility;
 901         event.data = visibility;
 902
 903         emit postEvent(event);
 904 }
 905
 906 /**
 907  * @internal
 908  */
 909 void TimeLineWidget::onRequestExpandFrame(int layerPosition, int framePosition, int size)
 910 {
 911         Event event;
 912         event.scene = d->layers.container->currentIndex();
 913         event.layer = layerPosition;
 914         event.frame = framePosition;
 915         event.action = ExpandFrame;
 916
 917         event.data = size;
 918
 919         emit postEvent(event);
 920 }
 921
 922 /**
 923  * @internal
 924  */
 925 void TimeLineWidget::nextFrame()
 926 {
 927         int scenePos = scene();
 928         int layerPos = layer();
 929         int framePos = frame();
 930
 931         FramesTable *framesTable = this->framesTable(scenePos);
 932
 933         if(framesTable)
 934         {
 935                 if(framePos < framesTable->lastFrameByLayer(layerPos))
 936                 {
 937                         setFrame(scenePos, layerPos, framePos+1);
 938                 }
 939                 else
 940                 {
 941                         setFrame(scenePos, layerPos, 0);
 942                         d->scenes.play->setIcon(DGui::IconLoader::self()->load("media-playback-start.svg"));
 943                         d->timer.stop();
 944                 }
 945         }
 946 }
 947
 948 /**
 949  * @internal
 950  */
 951 LayerManager *TimeLineWidget::layerManager(int sceneIndex)
 952 {
 953         return qobject_cast<LayerManager *>(d->layers.container->widget(sceneIndex));
 954 }
 955
 956 /**
 957  * @internal
 958  */
 959 FramesTable *TimeLineWidget::framesTable(int sceneIndex)
 960 {
 961         return qobject_cast<FramesTable *>(d->frames.container->widget(sceneIndex));
 962 }
 963
 964 /**
 965  * @internal
 966  */
 967 void TimeLineWidget::setupButtons()
 968 {
 969         d->scenes.insert->setIcon(DGui::IconLoader::self()->load("list-add.svg"));
 970         d->scenes.insert->setToolTip(tr("Insert a scene"));
 971
 972         d->scenes.remove->setIcon(DGui::IconLoader::self()->load("list-remove.svg"));
 973         d->scenes.remove->setToolTip(tr("Remove the scene"));
 974
 975         d->scenes.up->setIcon(DGui::IconLoader::self()->load("go-up.svg"));
 976         d->scenes.up->setToolTip(tr("Move up scene"));
 977
 978         d->scenes.down->setIcon(DGui::IconLoader::self()->load("go-down.svg"));
 979         d->scenes.down->setToolTip(tr("Move down scene"));
 980
 981         d->scenes.play->setIcon(DGui::IconLoader::self()->load("media-playback-start.svg"));
 982         d->scenes.play->setToolTip(tr("Play scene"));
 983
 984         connect(d->scenes.play, SIGNAL(clicked()), this, SLOT(playScene()));
 985
 986         d->layers.insert->setIcon(DGui::IconLoader::self()->load("add-layer.svg"));
 987         d->layers.insert->setToolTip(tr("Insert a layer"));
 988
 989         d->layers.remove->setIcon(DGui::IconLoader::self()->load("list-remove.svg"));
 990         d->layers.remove->setToolTip(tr("Remove the layer"));
 991
 992         d->layers.up->setIcon(DGui::IconLoader::self()->load("go-up.svg"));
 993         d->layers.up->setToolTip(tr("Move up layer"));
 994
 995         d->layers.down->setIcon(DGui::IconLoader::self()->load("go-down.svg"));
 996         d->layers.down->setToolTip(tr("Move down layer"));
 997
 998         d->frames.insert->setIcon(DGui::IconLoader::self()->load("list-add.svg"));
 999         d->frames.insert->setToolTip(tr("Insert a frame"));
1000
1001         d->frames.remove->setIcon(DGui::IconLoader::self()->load("list-remove.svg"));
1002         d->frames.remove->setToolTip(tr("Remove the frame"));
1003
1004         d->frames.up->setIcon(DGui::IconLoader::self()->load("go-previous.svg"));
1005         d->frames.up->setToolTip(tr("Move up frame"));
1006
1007         d->frames.down->setIcon(DGui::IconLoader::self()->load("go-next.svg"));
1008         d->frames.down->setToolTip(tr("Move down frame"));
1009
1010         d->actions.addButton(d->scenes.insert, InsertScene);
1011         d->actions.addButton(d->scenes.remove, RemoveScene);
1012         d->actions.addButton(d->scenes.up, MoveSceneUp);
1013         d->actions.addButton(d->scenes.down, MoveSceneDown);
1014
1015         d->actions.addButton(d->layers.insert, InsertLayer);
1016         d->actions.addButton(d->layers.remove, RemoveLayer);
1017         d->actions.addButton(d->layers.up, MoveLayerUp);
1018         d->actions.addButton(d->layers.down, MoveLayerDown);
1019
1020         d->actions.addButton(d->frames.insert, InsertFrame);
1021         d->actions.addButton(d->frames.remove, RemoveFrame);
1022         d->actions.addButton(d->frames.up, MoveFrameUp);
1023         d->actions.addButton(d->frames.down, MoveFrameDown);
1024 }
1025
1026 }
1027 }