src/components/timeline/layermanager.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 "layermanager.h"
  22
  23 #include <QLabel>
  24 #include <QLayout>
  25
  26 #include <QPixmap>
  27 #include <QHeaderView>
  28 #include <QPainter>
  29 #include <QItemDelegate>
  30 #include <QLineEdit>
  31
  32 #include <dgui/separator.h>
  33 #include <dgui/application.h>
  34 #include <dgui/iconloader.h>
  35 #include <dcore/debug.h>
  36
  37 namespace Dash {
  38 namespace Component {
  39
  40 const int LAYER_COLUMN = 0;
  41 const int LOCK_COLUMN = 1;
  42 const int VIEW_COLUMN = 2;
  43
  44 // Header
  45
  46 class LayerManagerHeader : public QHeaderView
  47 {
  48         public:
  49                 LayerManagerHeader(QWidget * parent = 0);
  50                  ~LayerManagerHeader();
  51
  52                  void paintSection(QPainter *painter, const QRect & rect, int logicalIndex ) const;
  53
  54         private:
  55                 QIcon m_lockIcon;
  56                 QIcon m_viewIcon;
  57 };
  58
  59 LayerManagerHeader::LayerManagerHeader(QWidget * parent ) : QHeaderView(Qt::Horizontal , parent)
  60 {
  61         setClickable(true);
  62         setCascadingSectionResizes(true);
  63
  64         m_lockIcon = DGui::IconLoader::self()->load("lock.png");
  65         m_viewIcon = DGui::IconLoader::self()->load("show_hide_all_layers.png");
  66
  67
  68 }
  69
  70
  71 LayerManagerHeader::~LayerManagerHeader()
  72 {
  73 }
  74
  75 void LayerManagerHeader::paintSection ( QPainter * painter, const QRect & rect, int logicalIndex ) const
  76 {
  77         if ( !rect.isValid() ) return;
  78
  79         QStyleOptionHeader headerOption;
  80         headerOption.rect = rect;
  81         headerOption.orientation = Qt::Horizontal;
  82         headerOption.position = QStyleOptionHeader::Middle;
  83
  84         QStyle::State state = QStyle::State_None;
  85         if (isEnabled())
  86                 state |= QStyle::State_Enabled;
  87         if (window()->isActiveWindow())
  88                 state |= QStyle::State_Active;
  89
  90         style()->drawControl ( QStyle::CE_HeaderSection, &headerOption, painter );
  91
  92         painter->drawRect( rect.normalized().adjusted(0, 1, 0, -1) );
  93
  94         QString text = model()->headerData(logicalIndex, orientation(), Qt::DisplayRole).toString();;
  95
  96         QFontMetrics fm( painter->font() );
  97
  98         int x = rect.x() + (sectionSize(logicalIndex) - fm.width( text ))/2;
  99         int y = fm.height() + ( rect.y() / 2);
 100
 101         painter->drawText( x, y, text);
 102
 103         QPen originalPen = painter->pen();
 104
 105         painter->setPen(QPen(palette().text().color(), 2) );
 106 //      painter->drawRect(rect.normalized().adjusted(1, 1, -2, -2));
 107
 108
 109         painter->setPen(originalPen);
 110
 111         switch(logicalIndex)
 112         {
 113                 case LAYER_COLUMN:
 114                 {
 115                         // nothing...
 116                 }
 117                 break;
 118                 case LOCK_COLUMN:
 119                 {
 120                         m_lockIcon.paint( painter, rect.normalized().adjusted(3,3, -3, -3));
 121                 }
 122                 break;
 123                 case VIEW_COLUMN:
 124                 {
 125                         m_viewIcon.paint( painter, rect.normalized().adjusted(3,3, -3, -3));
 126                 }
 127                 break;
 128         }
 129 }
 130
 131
 132 // DELEGATE
 133
 134 /*
 135 class LayerManagerItemDelegate : public QItemDelegate
 136 {
 137         public:
 138                 LayerManagerItemDelegate(QObject * parent = 0 );
 139                 ~LayerManagerItemDelegate();
 140                 virtual void paint ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const;
 141 };
 142
 143 LayerManagerItemDelegate::LayerManagerItemDelegate(QObject * parent) :  QItemDelegate(parent)
 144 {
 145 }
 146
 147 LayerManagerItemDelegate::~LayerManagerItemDelegate()
 148 {
 149 }
 150
 151 void LayerManagerItemDelegate::paint ( QPainter *painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const
 152 {
 153
 154         QItemDelegate::paint(painter, option, index);
 155
 156         LayerManager *table = qobject_cast<LayerManager *>(index.model()->parent());
 157
 158         QTableWidgetItem *item = table->itemFromIndex(index);
 159
 160         if ( item )
 161         {
 162                 switch( index.column() )
 163                 {
 164                         case LAYER_COLUMN:
 165                         {
 166                                 if ( item->isSelected() )
 167                                 {
 168                                         painter->drawRect(option.rect.normalized().adjusted(1,1,-2, -2 ));
 169                                 }
 170                         }
 171                         break;
 172                         case LOCK_COLUMN:
 173                         case VIEW_COLUMN:
 174                         {
 175                                 QStyleOptionButton checkOption;
 176
 177                                 checkOption.state = option.state;
 178
 179                                 if ( item->checkState() == Qt::Checked )
 180                                 {
 181                                         checkOption.state |= QStyle::State_On;
 182                                 }
 183
 184                                 checkOption.rect = option.rect.normalized().adjusted(2,2,-2,-2);
 185
 186                                 table->style()->drawPrimitive ( QStyle::PE_IndicatorCheckBox, &checkOption, painter);
 187                         }
 188                         break;
 189                 }
 190         }
 191 }
 192
 193 */
 194
 195 ////////////////////////////////
 196
 197
 198 struct LayerManager::Private
 199 {
 200         Private() : allSelected(false), allVisible(true), allLock(false), rowHeight(20) {}
 201
 202         bool allSelected, allVisible, allLock;
 203         int rowHeight;
 204
 205 };
 206
 207 LayerManager::LayerManager(QWidget *parent) : QTableWidget(0, 3, parent), d(new Private)
 208 {
 209 //      DINIT;
 210
 211         QTableWidgetItem *prototype = new QTableWidgetItem;
 212         prototype->setTextAlignment(Qt::AlignCenter);
 213 //      prototype->setBackgroundColor( palette().text().color() );
 214 //      prototype->setTextColor(palette().background().color() );
 215
 216         setItemPrototype(prototype);
 217
 218         setHorizontalHeaderLabels(QStringList() << tr("Layer") << tr("L") << tr("V") );
 219         verticalHeader()->hide();
 220
 221 //      setHorizontalHeader(new LayerManagerHeader(this));
 222 //      setItemDelegate(new LayerManagerItemDelegate(this));
 223
 224         connect(this, SIGNAL(itemChanged ( QTableWidgetItem *  )), this, SLOT(onItemChanged( QTableWidgetItem * )));
 225
 226 }
 227
 228
 229 LayerManager::~LayerManager()
 230 {
 231 //      DEND;
 232         delete d;
 233 }
 234
 235
 236 void LayerManager::insertLayer(int position, const QString &name)
 237 {
 238         blockSignals(true);
 239         if (  position >= 0 && position <= rowCount())
 240         {
 241
 242                 QTableWidgetItem *newLayer = new QTableWidgetItem(name);
 243                 newLayer->setIcon(DGui::IconLoader::self()->load("applications-graphics.svg"));
 244
 245                 newLayer->setTextAlignment(Qt::AlignCenter);
 246
 247                 newLayer->setBackgroundColor( palette().background().color() );
 248                 newLayer->setTextColor(palette().foreground().color() );
 249
 250                 insertRow(position);
 251                 setItem(position, 0, newLayer);
 252                 fixSize();
 253
 254                 QTableWidgetItem *lockItem = new QTableWidgetItem;
 255                 lockItem->setFlags(Qt::ItemIsUserCheckable  | Qt::ItemIsEnabled);
 256                 lockItem->setCheckState( Qt::Unchecked);
 257                 lockItem->setTextAlignment(Qt::AlignCenter);
 258                 lockItem->setText("  ");
 259                 setItem(position, 1, lockItem);
 260
 261                 QTableWidgetItem *viewItem = new QTableWidgetItem;
 262                 viewItem->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
 263                 viewItem->setCheckState( Qt::Checked);
 264                 viewItem->setTextAlignment(Qt::AlignCenter);
 265                 viewItem->setText("  ");
 266                 setItem(position, 2, viewItem);
 267         }
 268         blockSignals(false);
 269 }
 270
 271 void LayerManager::insertSoundLayer(int position, const QString &name)
 272 {
 273         blockSignals(true);
 274         if (  position >= 0 && position <= rowCount() )
 275         {
 276                 QTableWidgetItem *newLayer = new QTableWidgetItem(name);
 277                 newLayer->setTextAlignment(Qt::AlignCenter);
 278
 279                 newLayer->setBackgroundColor( palette().background().color() );
 280                 newLayer->setTextColor(palette().foreground().color() );
 281
 282                 insertRow(position);
 283                 setItem(position, 0, newLayer);
 284                 fixSize();
 285
 286                 newLayer->setIcon( DGui::IconLoader::self()->load("audio-volume-high.svg") );
 287
 288                 QTableWidgetItem *lockItem = new QTableWidgetItem;
 289                 lockItem->setFlags(Qt::ItemIsUserCheckable  | Qt::ItemIsEnabled);
 290                 lockItem->setCheckState( Qt::Unchecked);
 291
 292                 setItem(position, 1, lockItem);
 293
 294                 QTableWidgetItem *viewItem = new QTableWidgetItem;
 295                 viewItem->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
 296                 viewItem->setCheckState( Qt::Checked);
 297
 298                 setItem(position, 2, viewItem);
 299         }
 300         blockSignals(false);
 301 }
 302
 303 void LayerManager::removeLayer(int position)
 304 {
 305         removeRow( verticalHeader()->logicalIndex(position) );
 306 }
 307
 308 void LayerManager::renameLayer(int position, const QString &name)
 309 {
 310         QTableWidgetItem *item = this->item(verticalHeader()->logicalIndex(position), 0);
 311
 312         if ( item )
 313         {
 314                 item->setText(name);
 315         }
 316 }
 317
 318 void LayerManager::resizeEvent( QResizeEvent *)
 319 {
 320         fixSize();
 321 }
 322
 323 void LayerManager::fixSize()
 324 {
 325         int offset = 0;
 326         if ( verticalScrollBar()->isVisible() )
 327         {
 328                 offset = verticalScrollBar()->width()-2;
 329         }
 330         else
 331         {
 332                 offset = -2;
 333         }
 334
 335         int width = this->width() - offset;
 336
 337         horizontalHeader()->resizeSection(0, width-(d->rowHeight*2)-8 );
 338         horizontalHeader()->resizeSection(1, d->rowHeight );
 339         horizontalHeader()->resizeSection(2, d->rowHeight );
 340
 341         for(int row = 0; row < rowCount(); row++)
 342         {
 343                 verticalHeader()->resizeSection(row, d->rowHeight);
 344         }
 345 }
 346
 347
 348 void LayerManager::setRowHeight(int rowHeight)
 349 {
 350         d->rowHeight = rowHeight;
 351 }
 352
 353
 354 void LayerManager::commitData( QWidget *editor )
 355 {
 356         QLineEdit *lineEdit = qobject_cast<QLineEdit *>(editor);
 357
 358         QTableWidget::commitData(0); // Don't rename
 359
 360         if ( lineEdit )
 361         {
 362                 emit layerRenamed( verticalHeader()->visualIndex(currentRow()), lineEdit->text() );
 363         }
 364 }
 365
 366
 367 void LayerManager::onItemChanged( QTableWidgetItem * item)
 368 {
 369         if( item->column() == LOCK_COLUMN)
 370         {
 371                 emit layerLocked(visualRow(item->row()), item->checkState() == Qt::Checked );
 372         }
 373         else if(item->column() == VIEW_COLUMN)
 374         {
 375                 emit layerVisibilityChanged(visualRow(item->row()), item->checkState() == Qt::Checked );
 376         }
 377
 378 }
 379
 380
 381 void LayerManager::moveLayer(int position, int newPosition)
 382 {
 383         if ( position < 0 || position >= rowCount() || newPosition < 0 || newPosition >= rowCount() ) return;
 384
 385         verticalHeader()->moveSection( (position), (newPosition) );
 386
 387 //      QTableWidgetItem *item1 = takeItem(position, 0);
 388 //
 389 //      bool up = true;
 390 //      if ( position > newPosition )
 391 //      {
 392 //              up = false; // down
 393 //      }
 394 //
 395 //      if ( up )
 396 //      {
 397 //              for(int i = position+1; i <= newPosition; i++)
 398 //              {
 399 //                      setItem(i-1, 0, takeItem(i, 0));
 400 //              }
 401 //      }
 402 //      else
 403 //      {
 404 //              for(int i = position-1; i >= newPosition; i-- )
 405 //              {
 406 //                      setItem(i+1, 0, takeItem(i, 0));
 407 //              }
 408 //      }
 409 //
 410 //      setItem(newPosition, 0, item1);
 411 //
 412 //      setCurrentItem(item1);
 413 }
 414
 415
 416 void LayerManager::lockLayer(int position, bool locked)
 417 {
 418         if ( position < 0 || position >= rowCount() ) return;
 419
 420         QTableWidgetItem *item = this->item(verticalHeader()->logicalIndex(position), LOCK_COLUMN);
 421
 422         if ( item )
 423         {
 424                 if ( locked )
 425                 {
 426                         item->setCheckState (Qt::Checked);
 427                 }
 428                 else
 429                 {
 430                         item->setCheckState (Qt::Unchecked);
 431                 }
 432         }
 433 }
 434
 435 }
 436 }