src/components/timeline/framestable.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 "framestable.h"
  22
  23 #include <QPainter>
  24 #include <QPaintEvent>
  25 #include <QItemSelectionModel>
  26 #include <QPainterPath>
  27 #include <QScrollBar>
  28 #include <QHeaderView>
  29 #include <QMenu>
  30 #include <QInputDialog>
  31 #include <QApplication>
  32 #include <QClipboard>
  33
  34 #include <dcore/debug.h>
  35 #include <dcore/algorithm.h>
  36
  37 #include "tlruler.h"
  38
  39 namespace Dash {
  40 namespace Component {
  41
  42 ////////// FramesTableItemDelegate ///////////
  43
  44 class FramesTableItemDelegate : public QAbstractItemDelegate
  45 {
  46         public:
  47                 FramesTableItemDelegate(QObject * parent = 0 );
  48                 ~FramesTableItemDelegate();
  49                 virtual void paint ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const;
  50                 virtual QSize sizeHint ( const QStyleOptionViewItem & option, const QModelIndex & index ) const;
  51 };
  52
  53 /**
  54  *
  55  */
  56 FramesTableItemDelegate::FramesTableItemDelegate(QObject * parent) :  QAbstractItemDelegate(parent)
  57 {
  58 }
  59
  60 FramesTableItemDelegate::~FramesTableItemDelegate()
  61 {
  62 }
  63
  64
  65
  66 void FramesTableItemDelegate::paint ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const
  67 {
  68         Q_ASSERT(index.isValid());
  69
  70         FramesTable *table = qobject_cast<FramesTable *>(index.model()->parent());
  71         FramesTableItem *item = dynamic_cast<FramesTableItem *>(table->itemFromIndex(index));
  72
  73         QVariant value;
  74         QStyleOptionViewItem opt = option;
  75
  76         // draw the background color
  77         value = index.data( Qt::BackgroundColorRole );
  78
  79         if (value.isValid())
  80         {
  81                 painter->save();
  82
  83                 bool sound = table->isSoundLayer(index.row());
  84
  85                 if( !sound )
  86                 {
  87                         painter->fillRect(option.rect, value.value<QColor>() );
  88                 }
  89                 painter->restore();
  90         }
  91         else
  92         {
  93                 painter->save();
  94
  95                 bool sound = table->isSoundLayer(index.row());
  96                 painter->setPen(QPen(Qt::lightGray, 1));
  97                 if( !sound )
  98                 {
  99                         if ( index.column() % 5 == 0 )
 100                         {
 101                                 painter->setBrush(Qt::lightGray);
 102                                 painter->drawRect(option.rect ); //FIXME: user paleta de colores
 103                         }
 104                         else
 105                         {
 106                                 painter->setBrush(Qt::white);
 107                                 painter->drawRect(option.rect);//FIXME: user paleta de color
 108                         }
 109                 }
 110                 else
 111                 {
 112                         painter->fillRect(option.rect, Qt::white);
 113                 }
 114
 115                 painter->restore();
 116         }
 117
 118         // Draw attributes
 119
 120         int offset = option.rect.width() - 4;
 121
 122         if ( item && index.isValid() )
 123         {
 124                 if(item->isUsed() )
 125                 {
 126                         painter->save();
 127                         painter->setBrush(Qt::black);
 128
 129                         if( !item->isSound() )
 130                         {
 131                                 QColor color = Qt::white; //FIXME: user paleta de color
 132                                 if ( item->inGroupPosition() == FramesTableItem::Begin )
 133                                 {
 134                                         painter->fillRect(option.rect, color);
 135                                         painter->drawLine(option.rect.topLeft(), option.rect.bottomLeft());
 136                                         painter->drawEllipse(option.rect.left()+2, option.rect.bottom() - (offset+2), offset, offset);
 137                                 }
 138                                 else if ( item->inGroupPosition() == FramesTableItem::End )
 139                                 {
 140                                         painter->fillRect(option.rect, color );
 141                                         painter->drawLine(option.rect.topRight(), option.rect.bottomRight());
 142                                 }
 143                                 else if( item->inGroupPosition() == FramesTableItem::Intermediate )
 144                                 {
 145                                         painter->fillRect(option.rect, color );
 146                                 }
 147                                 else
 148                                 {
 149                                         painter->drawEllipse(option.rect.left()+2, option.rect.bottom() - (offset+2), offset, offset);
 150                                 }
 151                         }
 152                         else
 153                         {
 154                                 painter->setPen(QPen(Qt::blue, 1));
 155
 156                                 int y = option.rect.center().y();
 157                                 int xi = option.rect.x();
 158                                 int xf = option.rect.width();
 159
 160                                 painter->drawLine(QPoint(xi, y) , QPoint(xf, y));
 161                         }
 162
 163                         painter->restore();
 164                 }
 165
 166                 if ( item->isLocked() )
 167                 {
 168                         painter->save();
 169                         painter->setBrush(Qt::red);
 170
 171                         painter->drawEllipse(option.rect.left()+2, option.rect.bottom() - (offset+2), offset, offset);
 172
 173                         painter->restore();
 174                 }
 175         }
 176
 177         // Selection!
 178         if (option.showDecorationSelected && (option.state & QStyle::State_Selected))
 179         {
 180                 QPalette::ColorGroup cg = option.state & QStyle::State_Enabled ? QPalette::Normal : QPalette::Disabled;
 181
 182                 painter->save();
 183                 painter->setPen(QPen(option.palette.brush(cg, QPalette::Highlight), 2));
 184
 185                 QRectF rectSelection = option.rect.adjusted(1,1,-1,-1);
 186                 painter->drawRect(rectSelection);
 187                 painter->restore();
 188         }
 189
 190         painter->save();
 191         QPalette::ColorGroup cg = option.state & QStyle::State_Enabled ? QPalette::Normal : QPalette::Disabled;
 192         painter->setPen(QPen(option.palette.brush(cg, QPalette::Foreground), 1)),
 193
 194         painter->drawLine(option.rect.bottomLeft(), option.rect.bottomRight());
 195         painter->drawLine(option.rect.topLeft(), option.rect.topRight());
 196         painter->restore();
 197 }
 198
 199 QSize FramesTableItemDelegate::sizeHint ( const QStyleOptionViewItem & option, const QModelIndex & index ) const
 200 {
 201         Q_ASSERT(index.isValid());
 202         const QAbstractItemModel *model = index.model();
 203         Q_ASSERT(model);
 204
 205         QVariant value = model->data(index, Qt::FontRole);
 206         QFont fnt = value.isValid() ? qvariant_cast<QFont>(value) : option.font;
 207         QString text = model->data(index, Qt::DisplayRole).toString();
 208         QRect pixmapRect;
 209         if (model->data(index, Qt::DecorationRole).isValid())
 210                 pixmapRect = QRect(0, 0, option.decorationSize.width(),
 211                                    option.decorationSize.height());
 212
 213         QFontMetrics fontMetrics(fnt);
 214
 215         return (pixmapRect).size();
 216 }
 217
 218
 219 ////////// FramesTableItem ////////
 220
 221 FramesTableItem::FramesTableItem()
 222 {
 223 }
 224
 225 FramesTableItem::~FramesTableItem()
 226 {
 227 }
 228
 229
 230 bool FramesTableItem::isUsed()
 231 {
 232         return data(IsUsed).toBool();
 233 }
 234
 235 bool FramesTableItem::isLocked()
 236 {
 237         return data(IsLocked).toBool();
 238 }
 239
 240 bool FramesTableItem::isVisible()
 241 {
 242         return data(IsVisible).toBool();
 243 }
 244
 245 bool FramesTableItem::isSound()
 246 {
 247         QVariant data = this->data(IsSound);
 248
 249         if( data.canConvert<bool>() )
 250         {
 251                 return data.toBool();
 252         }
 253         return false;
 254 }
 255
 256 bool FramesTableItem::isClone()
 257 {
 258         QVariant data = this->data(IsClone);
 259
 260         if( data.canConvert<bool>() )
 261         {
 262                 return data.toBool();
 263         }
 264         return false;
 265 }
 266
 267 FramesTableItem::InGroupPositionType FramesTableItem::inGroupPosition()
 268 {
 269         QVariant data = this->data(InGroupPosition);
 270
 271         if( data.canConvert<int>() )
 272         {
 273                 return InGroupPositionType(data.toInt());
 274         }
 275         return None;
 276 }
 277
 278
 279 //// FramesTable
 280
 281 struct FramesTable::Private
 282 {
 283         struct LayerItem
 284         {
 285                 LayerItem() : lastItem(-1), sound(false) {};
 286                 int lastItem;
 287                 bool sound;
 288         };
 289
 290
 291         void swapItem( QTableWidgetItem *it, QTableWidgetItem *nextIt  )
 292         {
 293                 QVariant data = it->data(FramesTableItem::IsUsed);
 294
 295                 it->setData(FramesTableItem::IsUsed, nextIt->data(FramesTableItem::IsUsed).toBool() );
 296                 nextIt->setData(FramesTableItem::IsUsed, data);
 297
 298                 data = it->data(FramesTableItem::IsLocked);
 299                 it->setData(FramesTableItem::IsLocked, nextIt->data(FramesTableItem::IsLocked).toBool());
 300                 nextIt->setData(FramesTableItem::IsLocked, data);
 301
 302
 303                 data = it->data(FramesTableItem::IsVisible);
 304                 it->setData(FramesTableItem::IsVisible, nextIt->data(FramesTableItem::IsVisible).toBool());
 305                 nextIt->setData(FramesTableItem::IsVisible, data);
 306
 307                 data = it->data(FramesTableItem::IsSound);
 308                 it->setData(FramesTableItem::IsSound, nextIt->data(FramesTableItem::IsSound).toBool());
 309                 nextIt->setData(FramesTableItem::IsSound, data);
 310
 311                 data = it->data(FramesTableItem::InGroupPosition);
 312                 it->setData(FramesTableItem::InGroupPosition, nextIt->data(FramesTableItem::InGroupPosition));
 313                 nextIt->setData(FramesTableItem::InGroupPosition, data);
 314
 315         }
 316
 317         int groupSize(FramesTable *table, int layer, int beginFrame)
 318         {
 319                 QTableWidgetItem *item = table->item(layer, beginFrame);
 320
 321                 if( ! item )
 322                 {
 323                         return 0;
 324                 }
 325
 326                 int count = 0;
 327
 328                 dfDebug << "begin Frame " << beginFrame << " type " << item->data(FramesTableItem::InGroupPosition).toInt();
 329
 330                 if(item->data(FramesTableItem::InGroupPosition).toInt() == FramesTableItem::Begin)
 331                 {
 332                         while(item && item->data(FramesTableItem::InGroupPosition).toInt() != FramesTableItem::End)
 333                         {
 334                                 count++;
 335                                 item = table->item(layer, beginFrame+count);
 336                         }
 337                 }
 338
 339                 return count+1;
 340         }
 341
 342         int rectWidth, rectHeight;
 343         QList<LayerItem> layers;
 344         TLRuler *ruler;
 345
 346         enum Action {
 347                 InsertFrame = 0,
 348                 RemoveFrame,
 349                 ToggleLockFrame,
 350                 ToggleFrameVisibility,
 351                 ExpandFrame,
 352                 CopyFrame,
 353                 PasteFrame,
 354                 CutFrame
 355         };
 356
 357 };
 358
 359 /**
 360  * @~spanish
 361  * Contructor
 362  */
 363 FramesTable::FramesTable(QWidget *parent) : QTableWidget(0, 100, parent), d(new Private)
 364 {
 365         d->ruler = new TLRuler;
 366         setup();
 367 }
 368
 369 /**
 370  * @~spanish
 371  * Destructor
 372  */
 373 FramesTable::~FramesTable()
 374 {
 375         delete d;
 376 }
 377
 378 /**
 379  * @internal
 380  */
 381 void FramesTable::setup()
 382 {
 383         setItemDelegate( new FramesTableItemDelegate(this) );
 384
 385         setSelectionBehavior(QAbstractItemView::SelectItems);
 386         setSelectionMode (QAbstractItemView::SingleSelection);
 387
 388         setHorizontalHeader(d->ruler);
 389
 390         connect(d->ruler, SIGNAL(logicalSectionSelected( int )), this, SLOT(emitFrameSelected( int )));
 391 //      connect(this, SIGNAL(currentItemChanged( QTableWidgetItem *, QTableWidgetItem *)), this, SLOT(emitFrameSelected(QTableWidgetItem *, QTableWidgetItem *)));
 392         verticalHeader()->hide();
 393
 394
 395         connect(this, SIGNAL(itemSelectionChanged()), this, SLOT(onItemSelectionChanged()));
 396
 397         connect( this, SIGNAL(cellDoubleClicked ( int , int )), this, SLOT(onCellDoubleClicked(int, int)));
 398
 399         setItemSize( 10, 25 );
 400
 401         horizontalHeader()->setResizeMode(QHeaderView::Custom);
 402         verticalHeader()->setResizeMode(QHeaderView::Custom);
 403
 404
 405         setSelectionMode(QAbstractItemView::ContiguousSelection);
 406         setShowGrid(false);
 407 }
 408
 409 /**
 410  * @internal
 411  */
 412 void FramesTable::emitFrameSelected(int col)
 413 {
 414         selectColumn(col);
 415
 416         FramesTableItem *item = dynamic_cast<FramesTableItem *>(this->item(currentRow(), col));
 417
 418         if( item )
 419         {
 420                 if( item->isUsed())
 421                 {
 422                         emit frameSelected(visualRow(this->row(item)), visualColumn(this->column(item)));
 423                 }
 424         }
 425 }
 426
 427 /**
 428  * @internal
 429  */
 430 void FramesTable::onItemSelectionChanged()
 431 {
 432         FramesTableItem *item = dynamic_cast<FramesTableItem *>(currentItem());
 433         if( item )
 434         {
 435                 if( item->isUsed())
 436                 {
 437                         emit frameSelected(visualRow(this->row(item)), visualColumn(this->column(item)));
 438                 }
 439         }
 440         else
 441         {
 442                 emit layerSelected(visualRow(currentRow()));
 443         }
 444 }
 445
 446 /**
 447  * @~spanish
 448  * Función sobrecargada para la implementación del menú contextual.
 449  */
 450 void FramesTable::mousePressEvent ( QMouseEvent * event )
 451 {
 452
 453         QTableWidget::mousePressEvent(event);
 454         if(event->buttons() == Qt::RightButton )
 455         {
 456                 QMenu *menu = new QMenu(tr("Frames"), this);
 457
 458                 FramesTableItem *item = dynamic_cast<FramesTableItem *>(currentItem());
 459
 460                 menu->addAction( tr("Insert frame"))->setData(Private::InsertFrame);
 461
 462                 if(item)
 463                 {
 464                         if( item->isUsed())
 465                         {
 466                                 menu->addAction( tr("Remove frame"))->setData(Private::RemoveFrame);
 467                                 menu->addAction( tr("Expand this frame"))->setData(Private::ExpandFrame);
 468                                 menu->addSeparator();
 469                                 menu->addAction(tr("Copy frame"))->setData(Private::CopyFrame);
 470
 471                                 menu->addAction(tr("Cut frame"))->setData(Private::CutFrame);
 472                         }
 473                         else
 474                         {
 475                                 menu->addSeparator();
 476                         }
 477                 }
 478
 479                 if(const QMimeData *mimeData = QApplication::clipboard()->mimeData())
 480                 {
 481                         if(mimeData->hasFormat("yamf-frame"))
 482                         {
 483                                 menu->addAction( tr("Paste frame"))->setData(Private::PasteFrame);
 484                                 menu->addSeparator();
 485                         }
 486                 }
 487
 488                 if(item)
 489                 {
 490                         if( item->isLocked())
 491                         {
 492                                 menu->addAction( tr("Unlock this frame"))->setData(Private::ToggleLockFrame);
 493                         }
 494                         else
 495                         {
 496                                 menu->addAction( tr("Lock this frame"))->setData(Private::ToggleLockFrame);
 497                         }
 498
 499                         if(item->isVisible())
 500                         {
 501                                 menu->addAction( tr("Hide this frame"))->setData(Private::ToggleFrameVisibility);
 502                         }
 503                         else
 504                         {
 505                                 menu->addAction( tr("Show this frame"))->setData(Private::ToggleFrameVisibility);
 506                         }
 507                 }
 508
 509                 connect(menu, SIGNAL(triggered(QAction *)), this, SLOT(onMenuActionTriggered(QAction * )));
 510
 511                 menu->exec( event->globalPos() );
 512         }
 513 }
 514
 515 /**
 516  * @internal
 517  */
 518 void FramesTable::onCellDoubleClicked(int row, int column)
 519 {
 520         row = visualRow(row);
 521         if( lastFrameByLayer(row)+1 == column )
 522         {
 523                 emit requestInsertFrame(row, column);
 524         }
 525 }
 526
 527 /**
 528  * @internal
 529  */
 530 void FramesTable::onMenuActionTriggered(QAction * action)
 531 {
 532         int layerPos = visualRow(currentRow());
 533         int framePos = visualColumn(currentColumn());
 534
 535         switch(action->data().toInt())
 536         {
 537                 case Private::InsertFrame:
 538                 {
 539                         FramesTableItem *item = dynamic_cast<FramesTableItem *>(currentItem());
 540                         if(item)
 541                         {
 542                                 if(item->isUsed())
 543                                 {
 544                                         emit requestInsertFrame(layerPos, framePos+1);
 545                                 }
 546                         }
 547                         else
 548                         {
 549                                 emit requestInsertFrame(layerPos, framePos);
 550                         }
 551
 552                 }
 553                 break;
 554                 case Private::RemoveFrame:
 555                 {
 556                         emit requestRemoveFrame(layerPos, framePos);
 557                 }
 558                 break;
 559                 case Private::CopyFrame:
 560                 {
 561                         emit requestCopyFrame(layerPos, framePos);
 562                 }
 563                 break;
 564                 case Private::PasteFrame:
 565                 {
 566                         emit requestPasteFrame(layerPos, framePos);
 567                 }
 568                 break;
 569                 case Private::CutFrame:
 570                 {
 571                         emit requestCutFrame(layerPos, framePos);
 572                 }
 573                 break;
 574                 case Private::ToggleLockFrame:
 575                 {
 576                         FramesTableItem *item = dynamic_cast<FramesTableItem *>(currentItem());
 577                         if(item)
 578                         {
 579                                  emit requestLockFrame(layerPos, framePos, !item->isLocked());
 580                         }
 581                 }
 582                 break;
 583                 case Private::ToggleFrameVisibility:
 584                 {
 585                         FramesTableItem *item = dynamic_cast<FramesTableItem *>(currentItem());
 586                         if(item)
 587                         {
 588                                  emit requestChangeFrameVisibility(layerPos, framePos, !item->isVisible());
 589                         }
 590                 }
 591                 break;
 592                 case Private::ExpandFrame:
 593                 {
 594                         FramesTableItem *item = dynamic_cast<FramesTableItem *>(currentItem());
 595                         if(item)
 596                         {
 597                                 bool ok = false;
 598                                 int size = QInputDialog::getInteger ( 0, tr("Expand frame"), tr("number of frames to enlarge this frame?"), 1, 1, 2000, 1,  &ok);
 599                                 if(ok)
 600                                 {
 601                                         emit requestExpandFrame(layerPos, framePos, size);
 602                                 }
 603                         }
 604                 }
 605                 break;
 606         }
 607 }
 608
 609 /**
 610  * @~spanish
 611  * Cambia el tamaño de los frames.
 612  */
 613 void FramesTable::setItemSize(int w, int h)
 614 {
 615         d->rectHeight = h;
 616         d->rectWidth = w;
 617
 618         fixSize();
 619 }
 620
 621 /**
 622  * @~spanish
 623  * Extiende el largo de un frame, para permitir la realimentación gráfica de la expansión del tiempo de un frame.
 624  */
 625 void FramesTable::expandFrame( int layerPosition, int position, int size )
 626 {
 627         groupFrames( layerPosition, position, position+size);
 628
 629         for(int i = position; i < position+size; i++)
 630         {
 631                 QTableWidgetItem *item = this->item(layerPosition, i);
 632                 item->setData(FramesTableItem::IsClone, true);
 633         }
 634
 635 }
 636
 637 /**
 638  * @~spanish
 639  * Agrupa los frames de la posición @p from a la @p to del layer, para permitir la realimentación gráfica de la agrupación de un conjunto de frames.
 640  */
 641 void FramesTable::groupFrames( int layerPosition, int from, int to )
 642 {
 643         for(int i = from+1; i <= to; i++)
 644         {
 645                 QTableWidgetItem *item = this->item(layerPosition, i);
 646
 647                 if(item)
 648                 {
 649                         item->setData(FramesTableItem::InGroupPosition, QVariant(  FramesTableItem::Intermediate));
 650                 }
 651         }
 652
 653         QTableWidgetItem *begin = this->item(layerPosition, from);
 654
 655         if(begin)
 656         {
 657                 begin->setData(FramesTableItem::InGroupPosition ,QVariant(FramesTableItem::Begin));
 658         }
 659
 660         QTableWidgetItem *end = this->item(layerPosition, to);
 661
 662         if(end)
 663         {
 664                 QTableWidgetItem *nextEnd = this->item(layerPosition, to+1);
 665
 666                 if(nextEnd)
 667                 {
 668                         if(nextEnd->data(FramesTableItem::InGroupPosition).toInt() != FramesTableItem::None || nextEnd->data(FramesTableItem::InGroupPosition).toInt() != FramesTableItem::Begin)
 669                         {
 670                                 end->setData(FramesTableItem::InGroupPosition, QVariant(FramesTableItem::Intermediate));
 671                                 viewport()->update();
 672                                 return;
 673                         }
 674                 }
 675                 end->setData(FramesTableItem::InGroupPosition, QVariant(FramesTableItem::End));
 676
 677         }
 678         viewport()->update();
 679 }
 680
 681 /**
 682  * @~spanish
 683  * Destruye el grupo de frames que esta en la posición @p position del layer @p layerPosition, para permitir la realimentación gráfica de la destrucción de un conjunto de frames.
 684  */
 685 void FramesTable::destroyGroupFrames(int layerPosition, int position, int size)
 686 {
 687         for(int i = position; i <= position+size; i++)
 688         {
 689                 QTableWidgetItem *item = this->item(layerPosition, i);
 690
 691                 if(item)
 692                 {
 693                         item->setData(FramesTableItem::InGroupPosition, QVariant(  FramesTableItem::None));
 694                         item->setData(FramesTableItem::IsClone, false);
 695                 }
 696         }
 697 }
 698
 699 /**
 700  * @~spanish
 701  * Retorna verdadero si el layer en la posición @p row es de sonido, falso de lo contrario.
 702  */
 703 bool FramesTable::isSoundLayer(int row)
 704 {
 705         if( row < 0 && row >= d->layers.count() )
 706                 return false;
 707
 708         return d->layers[row].sound;
 709 }
 710
 711 /**
 712  * @~spanish
 713  * Inserta un layer en la posición @p pos con el nombre @p name, permitiendo la realimentación gráfica de la inserción de un layer.
 714  */
 715 void FramesTable::insertLayer(int pos, const QString &name)
 716 {
 717         Q_UNUSED(name);
 718         insertRow( pos );
 719
 720         Private::LayerItem layer;
 721         layer.sound = false;
 722         d->layers.insert(pos, layer);
 723
 724         fixSize();
 725 }
 726
 727 /**
 728  * @~spanish
 729  * Inserta un layer de sonido en la posicion @p pos con el nombre @p name. permitiendo la realimentación gráfica de la inserción de un layer de sonido.
 730  */
 731 void FramesTable::insertSoundLayer(int layerPos, const QString &name)
 732 {
 733         Q_UNUSED(name);
 734         insertRow(layerPos);
 735
 736         Private::LayerItem layer;
 737         layer.sound = true;
 738         d->layers.insert(layerPos, layer);
 739
 740         fixSize();
 741 }
 742
 743 /**
 744  * @~spanish
 745  * Elimina el layer seleccionado actualmente, permitiendo la realimentación gráfica de la eliminación del layer actual.
 746  */
 747 void FramesTable::removeCurrentLayer()
 748 {
 749         int pos = verticalHeader()->logicalIndex(currentRow());
 750         removeLayer(pos);
 751 }
 752
 753 /**
 754  * @~spanish
 755  * Elimina el layer de la posición @p pos, permitiendo la realimentación gráfica de la eliminación de un layer.
 756  */
 757 void FramesTable::removeLayer(int pos)
 758 {
 759         pos = verticalHeader()->logicalIndex(pos);
 760         removeRow( pos );
 761         d->layers.removeAt(pos);
 762 }
 763
 764 /**
 765  * @~spanish
 766  * Mueve el layer de la posición @p position a la posición @p newPosition.
 767  */
 768 void FramesTable::moveLayer(int position, int newPosition)
 769 {
 770         if ( position < 0 || position >= rowCount() || newPosition < 0 || newPosition >= rowCount() ) return;
 771
 772         blockSignals(true);
 773
 774         verticalHeader()->moveSection(position, newPosition);
 775
 776         blockSignals(false);
 777 }
 778
 779 /**
 780  * @~spanish
 781  * Obtiene la posición del ultimo frame del layer que esta en la posición @p layerPos.
 782  */
 783 int FramesTable::lastFrameByLayer(int layerPos)
 784 {
 785         int pos = verticalHeader()->logicalIndex(layerPos);
 786         if ( pos < 0 || pos > d->layers.count() )
 787         {
 788                 return -1;
 789         }
 790         return d->layers[pos].lastItem;
 791 }
 792
 793 // FRAMES
 794
 795 /**
 796  * @~spanish
 797  * Añade un frame al layer de la posicion @p layerPos, con el nombre @p name.
 798  */
 799 void FramesTable::addFrame(int layerPos, const QString &name)
 800 {
 801         Q_UNUSED(name);
 802         if ( layerPos < 0 || layerPos >= d->layers.count() ) return;
 803
 804         insertFrame(layerPos, lastFrameByLayer(verticalHeader()->logicalIndex(layerPos))+1, name)       ;
 805 }
 806
 807 /**
 808  * @~spanish
 809  * Inserta un frame en la posición @p framePos del layer @p layerPos, con el nombre @p name.
 810  */
 811 void FramesTable::insertFrame(int layerPos, int framePos, const QString &name)
 812 {
 813         Q_UNUSED(name);
 814
 815         if ( layerPos < 0 || layerPos >= d->layers.count() ) return;
 816
 817         layerPos = verticalHeader()->logicalIndex(layerPos);
 818
 819         d->layers[layerPos].lastItem++;
 820
 821         int position = framePos;
 822
 823         if(!d->layers[layerPos].sound)
 824         {
 825                 position = d->layers[layerPos].lastItem;
 826         }
 827
 828         setAttribute( layerPos, position, FramesTableItem::IsUsed, true);
 829         setAttribute( layerPos, position, FramesTableItem::IsVisible, true);
 830         setAttribute( layerPos, position, FramesTableItem::IsSound, d->layers[layerPos].sound);
 831         item( layerPos, position)->setData(FramesTableItem::InGroupPosition, FramesTableItem::None);
 832
 833         if(!d->layers[layerPos].sound)
 834         {
 835                 moveFrame(layerPos, position, framePos);
 836         }
 837         if ( d->layers[layerPos].lastItem >= columnCount()-1 )
 838         {
 839                 setColumnCount( d->layers[layerPos].lastItem+50 );
 840                 fixSize();
 841         }
 842
 843         viewport()->update();
 844 }
 845
 846 /**
 847  * @~spanish
 848  * Selecciona el frame, representado por el ítem @p item.
 849  */
 850 void FramesTable::setCurrentFrame(FramesTableItem *item)
 851 {
 852         setCurrentItem(item);
 853 }
 854
 855 /**
 856  * @~spanish
 857  * Selecciona el layer de la posición @p layerPos.
 858  */
 859 void FramesTable::setCurrentLayer(int layerPos)
 860 {
 861         setCurrentItem(item(verticalHeader()->logicalIndex(layerPos), 0));
 862 }
 863
 864 /**
 865  * @~spanish
 866  * Selecciona el frame la posición @p index del layer actual.
 867  */
 868 void FramesTable::selectFrame(int index)
 869 {
 870         setCurrentItem( item( currentRow(), index ) );
 871 }
 872
 873 /**
 874  * @~spanish
 875  * Remueve el frame que esta en la posición @p position del layer @p layerPos.
 876  */
 877 void FramesTable::removeFrame(int layerPos, int position)
 878 {
 879         if ( layerPos < 0 || layerPos >= d->layers.count() )
 880         {
 881                 return;
 882         }
 883
 884         QTableWidgetItem *it = this->item(layerPos, position);
 885
 886         moveFrame(layerPos, position, d->layers[layerPos].lastItem);
 887
 888         QTableWidgetItem *toRemove = takeItem(layerPos, d->layers[layerPos].lastItem);
 889
 890         int type = toRemove->data(FramesTableItem::InGroupPosition).toInt();
 891
 892         if(type == FramesTableItem::Begin)
 893         {
 894                 it = item(layerPos, position);
 895
 896                 if(it)
 897                 {
 898                         if(it->data(FramesTableItem::InGroupPosition).toInt() == FramesTableItem::Intermediate)
 899                         {
 900                                 it->setData(FramesTableItem::InGroupPosition, toRemove->data(FramesTableItem::InGroupPosition));
 901                         }
 902                         else if(it->data(FramesTableItem::InGroupPosition).toInt() == FramesTableItem::End)
 903                         {
 904                                 it->setData(FramesTableItem::InGroupPosition, FramesTableItem::None);
 905                                 it->setData(FramesTableItem::IsClone, false);
 906                         }
 907                 }
 908         }
 909         else if(toRemove->data(FramesTableItem::InGroupPosition).toInt() == FramesTableItem::End)
 910         {
 911                 it = item(layerPos, position);
 912                 if(it)
 913                 {
 914                         if(it->data(FramesTableItem::InGroupPosition).toInt() == FramesTableItem::Begin)
 915                         {
 916                                 it->setData(FramesTableItem::InGroupPosition, FramesTableItem::None);
 917                         }
 918                 }
 919
 920         }
 921
 922         delete toRemove;
 923         toRemove = 0;
 924
 925         d->layers[layerPos].lastItem--;
 926
 927         viewport()->update( visualRect(indexFromItem(item(layerPos, position) )) );
 928         viewport()->update();
 929 }
 930
 931 /**
 932  * @~spanish
 933  * Mueve el frame de la posición @p from a la posición @p to dentro del layer @p layerPos.
 934  */
 935 void FramesTable::moveFrame(int layerPos, int from, int to)
 936 {
 937         if(from == to)
 938         {
 939                 return;
 940         }
 941
 942         layerPos = verticalHeader()->logicalIndex(layerPos);
 943
 944         if(to > from)
 945         {
 946                 int fromSize = d->groupSize(this, layerPos, from);
 947                 int toSize = d->groupSize(this, layerPos, to);
 948
 949                 for(int i = 0; i < fromSize; i++)
 950                 {
 951                         for(int index = from; index < to+toSize-1; index++ )
 952                         {
 953                                 QTableWidgetItem *it = item(layerPos, index);
 954                                 QTableWidgetItem *nextIt = item(layerPos, index+1);
 955                                 if(nextIt)
 956                                 {
 957                                         d->swapItem(it, nextIt);
 958                                 }
 959                         }
 960                 }
 961         }
 962         else
 963         {
 964                 int fromSize = d->groupSize(this, layerPos, from);
 965                 int toSize = d->groupSize(this, layerPos, to);
 966                 Q_UNUSED(toSize);
 967
 968                 for(int i = 0; i < fromSize; i++)
 969                 {
 970                         for(int index = from+i; index > to+i; index-- )
 971                         {
 972                                 QTableWidgetItem *it = item(layerPos, index);
 973                                 QTableWidgetItem *nextIt = item(layerPos, index-1);
 974                                 if(nextIt)
 975                                 {
 976                                         d->swapItem(it, nextIt);
 977                                 }
 978                         }
 979                 }
 980         }
 981
 982         viewport()->update();
 983 }
 984
 985 /**
 986  * @spanish
 987  * Actualiza el estado de bloqueo del frame que esta en la posición @p postín del layer @p layerPos al valor de @p locked.
 988  */
 989 void FramesTable::lockFrame(int layerPos, int position, bool locked)
 990 {
 991         if ( layerPos < 0 || layerPos >= d->layers.count() )
 992         {
 993                 return;
 994         }
 995
 996         layerPos = verticalHeader()->logicalIndex(layerPos);
 997
 998         setAttribute( layerPos, position, FramesTableItem::IsLocked, locked );
 999
1000         viewport()->update();
1001 }
1002
1003 /**
1004  * @~spanish
1005  * Actualiza el estado de visibilidad del frame que esta en la posición @p position del layer @p layerPosition a el valor de @p isVisible.
1006  */
1007 void FramesTable::setFrameVisibility(int layerPosition, int position, bool isVisible)
1008 {
1009         if ( layerPosition < 0 || layerPosition >= d->layers.count() )
1010         {
1011                 return;
1012         }
1013
1014         layerPosition = verticalHeader()->logicalIndex(layerPosition);
1015
1016         setAttribute( layerPosition, position, FramesTableItem::IsVisible, isVisible );
1017
1018         viewport()->update();
1019 }
1020
1021 /**
1022  * @~spanish
1023  * Modifica el estado de un frame.
1024  */
1025 void FramesTable::setAttribute(int row, int col, FramesTableItem::Attributes att, bool value)
1026 {
1027         QTableWidgetItem *item = this->item(row, col);
1028
1029         if( !item )
1030         {
1031                 item = new FramesTableItem;
1032                 setItem(row, col, item);
1033         }
1034
1035         item->setData(att, value);
1036 }
1037
1038 /**
1039  * @~spanish
1040  * Arregla los tamaños de los frames mostrados en la tabla.
1041  */
1042 void FramesTable::fixSize()
1043 {
1044         for(int column = 0; column < columnCount(); column++)
1045         {
1046                 horizontalHeader()->resizeSection(column, d->rectWidth);
1047         }
1048         for( int row = 0; row < rowCount(); row++)
1049         {
1050                 verticalHeader()->resizeSection(row, d->rectHeight);
1051         }
1052 }
1053
1054 }
1055 }