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