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
  30 #include "tlruler.h"
  31 // #include "ktprojectrequest.h"
  32
  33
  34 namespace Components {
  35
  36 ////////// FramesTableItemDelegate ///////////
  37
  38 class FramesTableItemDelegate : public QAbstractItemDelegate
  39 {
  40         public:
  41                 FramesTableItemDelegate(QObject * parent = 0 );
  42                 ~FramesTableItemDelegate();
  43                 virtual void paint ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const;
  44                 virtual QSize sizeHint ( const QStyleOptionViewItem & option, const QModelIndex & index ) const;
  45 };
  46
  47 FramesTableItemDelegate::FramesTableItemDelegate(QObject * parent) :  QAbstractItemDelegate(parent)
  48 {
  49 }
  50
  51 FramesTableItemDelegate::~FramesTableItemDelegate()
  52 {
  53 }
  54
  55 void FramesTableItemDelegate::paint ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const
  56 {
  57         Q_ASSERT(index.isValid());
  58
  59         FramesTable *table = qobject_cast<FramesTable *>(index.model()->parent());
  60         FramesTableItem *item = dynamic_cast<FramesTableItem *>(table->itemFromIndex(index));
  61
  62         QVariant value;
  63         QStyleOptionViewItem opt = option;
  64
  65         // draw the background color
  66         value = index.data( Qt::BackgroundColorRole );
  67
  68         if (value.isValid())
  69         {
  70                 painter->save();
  71
  72                 bool sound = table->isSoundLayer(index.row());
  73
  74                 if( !sound )
  75                 {
  76                         painter->fillRect(option.rect, value.value<QColor>() );
  77                 }
  78                 else
  79                 {
  80                 }
  81
  82                 painter->restore();
  83         }
  84         else
  85         {
  86                 painter->save();
  87
  88                 bool sound = table->isSoundLayer(index.row());
  89
  90                 if( !sound )
  91                 {
  92                         if ( index.column() % 5 == 0 )
  93                         {
  94                                 painter->fillRect(option.rect, Qt::lightGray );
  95                         }
  96                         else
  97                         {
  98                                 painter->fillRect(option.rect, Qt::white );
  99                         }
 100                 }
 101                 else
 102                 {
 103                 }
 104
 105                 painter->restore();
 106         }
 107
 108         // Selection!
 109         if (option.showDecorationSelected && (option.state & QStyle::State_Selected))
 110         {
 111                 QPalette::ColorGroup cg = option.state & QStyle::State_Enabled ? QPalette::Normal : QPalette::Disabled;
 112
 113                 painter->save();
 114                 painter->setPen(QPen(option.palette.brush(cg, QPalette::Highlight), 3));
 115                 painter->drawRect(option.rect.adjusted(1,1,-2,-2));
 116                 painter->restore();
 117         }
 118
 119         // Draw attributes
 120
 121         int offset = option.rect.width() - 2;
 122
 123         if ( item && index.isValid() )
 124         {
 125                 if(item->isUsed() )
 126                 {
 127                         painter->save();
 128                         painter->setBrush(Qt::black);
 129
 130                         if( !item->isSound() )
 131                         {
 132                                 painter->drawEllipse( option.rect.left(), option.rect.bottom() - offset, offset, offset);
 133                         }
 134                         else
 135                         {
 136                                 painter->setBrush(Qt::blue);
 137                                 painter->drawRect( option.rect.left(), option.rect.bottom() - offset, offset, offset);
 138                         }
 139
 140                         painter->restore();
 141                 }
 142
 143                 if ( item->isLocked() )
 144                 {
 145                         painter->save();
 146                         painter->setBrush(Qt::red);
 147
 148                         painter->drawEllipse( option.rect.left(), option.rect.bottom() - offset, offset, offset);
 149
 150                         painter->restore();
 151                 }
 152         }
 153 }
 154
 155 QSize FramesTableItemDelegate::sizeHint ( const QStyleOptionViewItem & option, const QModelIndex & index ) const
 156 {
 157         Q_ASSERT(index.isValid());
 158         const QAbstractItemModel *model = index.model();
 159         Q_ASSERT(model);
 160
 161         QVariant value = model->data(index, Qt::FontRole);
 162         QFont fnt = value.isValid() ? qvariant_cast<QFont>(value) : option.font;
 163         QString text = model->data(index, Qt::DisplayRole).toString();
 164         QRect pixmapRect;
 165         if (model->data(index, Qt::DecorationRole).isValid())
 166                 pixmapRect = QRect(0, 0, option.decorationSize.width(),
 167                                    option.decorationSize.height());
 168
 169         QFontMetrics fontMetrics(fnt);
 170
 171         return (pixmapRect).size();
 172 }
 173
 174
 175 ////////// FramesTableItem ////////
 176
 177 FramesTableItem::FramesTableItem()
 178 {
 179 }
 180
 181 FramesTableItem::~FramesTableItem()
 182 {
 183 }
 184
 185
 186 bool FramesTableItem::isUsed()
 187 {
 188         return data(IsUsed).toBool();
 189 }
 190
 191 bool FramesTableItem::isLocked()
 192 {
 193         return data(IsLocked).toBool();
 194 }
 195
 196 bool FramesTableItem::isSound()
 197 {
 198         QVariant data = this->data(IsSound);
 199
 200         if( data.canConvert<bool>() )
 201         {
 202                 return data.toBool();
 203         }
 204         return false;
 205 }
 206
 207 //// FramesTable
 208
 209 struct FramesTable::Private
 210 {
 211         struct LayerItem
 212         {
 213                 LayerItem() : lastItem(-1), sound(false) {};
 214                 int lastItem;
 215                 bool sound;
 216         };
 217
 218         int rectWidth, rectHeight;
 219         QList<LayerItem> layers;
 220         TLRuler *ruler;
 221 };
 222
 223 FramesTable::FramesTable(QWidget *parent) : QTableWidget(0, 100, parent), d(new Private)
 224 {
 225         d->ruler = new TLRuler;
 226         setup();
 227 }
 228
 229 FramesTable::~FramesTable()
 230 {
 231         delete d;
 232 }
 233
 234 void FramesTable::setup()
 235 {
 236         setItemDelegate( new FramesTableItemDelegate(this) );
 237
 238         setSelectionBehavior(QAbstractItemView::SelectItems);
 239         setSelectionMode (QAbstractItemView::SingleSelection);
 240
 241         setHorizontalHeader(d->ruler);
 242         connect(d->ruler, SIGNAL(logicalSectionSelected( int )), this, SLOT(emitFrameSelected( int )));
 243         connect(this, SIGNAL(currentItemChanged( QTableWidgetItem *, QTableWidgetItem *)), this, SLOT(emitFrameSelected(QTableWidgetItem *, QTableWidgetItem *)));
 244         verticalHeader()->hide();
 245
 246         setItemSize( 10, 25 );
 247
 248         horizontalHeader()->setResizeMode(QHeaderView::Custom);
 249         verticalHeader()->setResizeMode(QHeaderView::Custom);
 250
 251
 252 }
 253
 254 void FramesTable::emitFrameSelected(int col)
 255 {
 256         selectColumn(col);
 257
 258         FramesTableItem *item = dynamic_cast<FramesTableItem *>(this->item(currentRow(), col));
 259
 260         if( item )
 261         {
 262                 if( item->isUsed())
 263                 {
 264 //                      emit frameRequest(KTProjectRequest::Select, this->column(item), verticalHeader()->visualIndex(this->row(item)),  -1);
 265                 }
 266         }
 267 }
 268
 269 void FramesTable::emitFrameSelected(QTableWidgetItem *curr, QTableWidgetItem *prev)
 270 {
 271         FramesTableItem *item = dynamic_cast<FramesTableItem *>(curr);
 272
 273         if( item )
 274         {
 275                 if( item->isUsed())
 276                 {
 277 //                      emit frameRequest(KTProjectRequest::Select, this->column(item), verticalHeader()->visualIndex(this->row(item)),  -1);
 278                 }
 279         }
 280 }
 281
 282 void FramesTable::setItemSize(int w, int h)
 283 {
 284         d->rectHeight = h;
 285         d->rectWidth = w;
 286
 287         fixSize();
 288 }
 289
 290 bool FramesTable::isSoundLayer(int row)
 291 {
 292         if( row < 0 && row >= d->layers.count() )
 293                 return false;
 294
 295         return d->layers[row].sound;
 296 }
 297
 298 void FramesTable::insertLayer(int pos, const QString &name)
 299 {
 300         insertRow( pos );
 301
 302         Private::LayerItem layer;
 303         layer.sound = false;
 304         d->layers.insert(pos, layer);
 305
 306 //      selectCell( pos, 0 );
 307
 308         fixSize();
 309 }
 310
 311 void FramesTable::insertSoundLayer(int layerPos, const QString &name)
 312 {
 313         insertRow(layerPos);
 314
 315         Private::LayerItem layer;
 316         layer.sound = true;
 317         d->layers.insert(layerPos, layer);
 318
 319         fixSize();
 320 }
 321
 322 void FramesTable::removeCurrentLayer()
 323 {
 324         int pos = verticalHeader()->logicalIndex(currentRow());
 325         removeLayer(pos);
 326 }
 327
 328 void FramesTable::removeLayer(int pos)
 329 {
 330         pos = verticalHeader()->logicalIndex(pos);
 331         removeRow( pos );
 332         d->layers.removeAt(pos);
 333 }
 334
 335 void FramesTable::moveLayer(int position, int newPosition)
 336 {
 337         if ( position < 0 || position >= rowCount() || newPosition < 0 || newPosition >= rowCount() ) return;
 338
 339         blockSignals(true);
 340
 341         verticalHeader()->moveSection(position, newPosition);
 342
 343         blockSignals(false);
 344
 345 //      FramesTableItem *item1 = takeItem(position, 0);
 346 //
 347 //      bool up = true;
 348 //      if ( position > newPosition )
 349 //      {
 350 //              up = false; // down
 351 //      }
 352 //
 353 //      if ( up )
 354 //      {
 355 //              for(int i = position+1; i <= newPosition; i++)
 356 //              {
 357 //                      setItem(i-1, 0, takeItem(i, 0));
 358 //              }
 359 //      }
 360 //      else
 361 //      {
 362 //              for(int i = position-1; i >= newPosition; i-- )
 363 //              {
 364 //                      setItem(i+1, 0, takeItem(i, 0));
 365 //              }
 366 //      }
 367 //
 368 //      setItem(newPosition, 0, item1);
 369 //
 370 //      setCurrentItem(item1);
 371 }
 372
 373 int FramesTable::lastFrameByLayer(int layerPos)
 374 {
 375         int pos = verticalHeader()->logicalIndex(layerPos);
 376         if ( pos < 0 || pos > d->layers.count() )
 377         {
 378                 return -1;
 379         }
 380         return d->layers[pos].lastItem;
 381 }
 382
 383 // FRAMES
 384
 385
 386 void FramesTable::insertFrame(int layerPos, const QString &name)
 387 {
 388         if ( layerPos < 0 || layerPos >= d->layers.count() ) return;
 389
 390         layerPos = verticalHeader()->logicalIndex(layerPos);
 391
 392         d->layers[layerPos].lastItem++;
 393
 394         if ( d->layers[layerPos].lastItem >= columnCount() )
 395         {
 396                 insertColumn( d->layers[layerPos].lastItem );
 397         }
 398
 399         setAttribute( layerPos, d->layers[layerPos].lastItem, FramesTableItem::IsUsed, true);
 400         setAttribute( layerPos, d->layers[layerPos].lastItem, FramesTableItem::IsSound, d->layers[layerPos].sound);
 401
 402         viewport()->update();
 403 }
 404
 405 void FramesTable::setCurrentFrame(FramesTableItem *item)
 406 {
 407         setCurrentItem(item);
 408 }
 409
 410 void FramesTable::setCurrentLayer(int layerPos)
 411 {
 412         setCurrentItem(item(verticalHeader()->logicalIndex(layerPos), 0));
 413 }
 414
 415 void FramesTable::selectFrame(int index)
 416 {
 417         setCurrentItem( item( currentRow(), index ) );
 418 }
 419
 420 void FramesTable::removeFrame(int layerPos, int position)
 421 {
 422 //      for(int frameIndex = position; frameIndex < columnCount(); frameIndex++ )
 423 //      {
 424 //              setAttribute( layerPos, position, FramesTableItem::IsUsed, false);
 425 //      }
 426
 427         if ( layerPos < 0 || layerPos >= d->layers.count() )
 428         {
 429                 return;
 430         }
 431
 432         layerPos = verticalHeader()->logicalIndex(layerPos);
 433
 434         setAttribute( layerPos, d->layers[layerPos].lastItem, FramesTableItem::IsUsed, false );
 435
 436         d->layers[layerPos].lastItem--;
 437
 438 //      viewport()->update( visualRect(indexFromItem( item(layerPos, position) )) );
 439         viewport()->update();
 440 }
 441
 442 void FramesTable::lockFrame(int layerPos, int position, bool lock)
 443 {
 444         if ( layerPos < 0 || layerPos >= d->layers.count() )
 445         {
 446                 return;
 447         }
 448
 449         layerPos = verticalHeader()->logicalIndex(layerPos);
 450
 451         setAttribute( layerPos, position, FramesTableItem::IsLocked, lock );
 452
 453         viewport()->update();
 454 }
 455
 456
 457 void FramesTable::setAttribute(int row, int col, FramesTableItem::Attributes att, bool value)
 458 {
 459         QTableWidgetItem *item = this->item(row, col);
 460
 461         if( !item )
 462         {
 463                 item = new FramesTableItem;
 464                 setItem(row, col, item);
 465         }
 466
 467         item->setData(att, value);
 468 }
 469
 470 void FramesTable::fixSize()
 471 {
 472         for(int column = 0; column < columnCount(); column++)
 473         {
 474                 horizontalHeader()->resizeSection(column, d->rectWidth);
 475         }
 476         for( int row = 0; row < rowCount(); row++)
 477         {
 478                 verticalHeader()->resizeSection(row, d->rectHeight);
 479         }
 480 }
 481
 482 // void FramesTable::fixSectionMoved(int logical, int visual, int newVisual)
 483 // {
 484 //      verticalHeader()->moveSection(newVisual, visual);
 485 // }
 486
 487 }