src/dolphincolumnwidget.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Peter Penz <peter.penz@gmx.at>                  *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  18  ***************************************************************************/
  19
  20 #include "dolphincolumnwidget.h"
  21
  22 #include "dolphinmodel.h"
  23 #include "dolphincolumnview.h"
  24 #include "dolphincontroller.h"
  25 #include "dolphindirlister.h"
  26 #include "dolphinsortfilterproxymodel.h"
  27 #include "dolphinsettings.h"
  28 #include "dolphinviewautoscroller.h"
  29 #include "dolphin_columnmodesettings.h"
  30 #include "dolphin_generalsettings.h"
  31 #include "draganddrophelper.h"
  32 #include "folderexpander.h"
  33 #include "selectionmanager.h"
  34 #include "tooltipmanager.h"
  35
  36 #include <kcolorscheme.h>
  37 #include <kdirlister.h>
  38 #include <kfileitem.h>
  39 #include <kfilepreviewgenerator.h>
  40 #include <kio/previewjob.h>
  41 #include <kiconeffect.h>
  42 #include <kjob.h>
  43 #include <konqmimedata.h>
  44
  45 #include <QApplication>
  46 #include <QClipboard>
  47 #include <QPainter>
  48 #include <QPoint>
  49
  50 DolphinColumnWidget::DolphinColumnWidget(QWidget* parent,
  51                                          DolphinColumnView* columnView,
  52                                          const KUrl& url) :
  53     QListView(parent),
  54     m_active(true),
  55     m_view(columnView),
  56     m_selectionManager(0),
  57     m_url(url),
  58     m_childUrl(),
  59     m_font(),
  60     m_decorationSize(),
  61     m_dirLister(0),
  62     m_dolphinModel(0),
  63     m_proxyModel(0),
  64     m_previewGenerator(0),
  65     m_dropRect()
  66 {
  67     setMouseTracking(true);
  68     setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  69     setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
  70     setSelectionBehavior(SelectItems);
  71     setSelectionMode(QAbstractItemView::ExtendedSelection);
  72     setDragDropMode(QAbstractItemView::DragDrop);
  73     setDropIndicatorShown(false);
  74     setSelectionRectVisible(true);
  75     setEditTriggers(QAbstractItemView::NoEditTriggers);
  76
  77     setVerticalScrollMode(QListView::ScrollPerPixel);
  78     setHorizontalScrollMode(QListView::ScrollPerPixel);
  79
  80     new DolphinViewAutoScroller(this);
  81
  82     // apply the column mode settings to the widget
  83     const ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
  84     Q_ASSERT(settings != 0);
  85
  86     if (settings->useSystemFont()) {
  87         m_font = KGlobalSettings::generalFont();
  88     } else {
  89         m_font = QFont(settings->fontFamily(),
  90                        settings->fontSize(),
  91                        settings->fontWeight(),
  92                        settings->italicFont());
  93     }
  94
  95     const int iconSize = settings->iconSize();
  96     setDecorationSize(QSize(iconSize, iconSize));
  97
  98     KFileItemDelegate* delegate = new KFileItemDelegate(this);
  99     delegate->setShowToolTipWhenElided(false);
 100     setItemDelegate(delegate);
 101
 102     activate();
 103
 104     connect(this, SIGNAL(viewportEntered()),
 105             m_view->m_controller, SLOT(emitViewportEntered()));
 106     connect(this, SIGNAL(entered(const QModelIndex&)),
 107             this, SLOT(slotEntered(const QModelIndex&)));
 108
 109     m_dirLister = new DolphinDirLister();
 110     m_dirLister->setAutoUpdate(true);
 111     m_dirLister->setMainWindow(window());
 112     m_dirLister->setDelayedMimeTypes(true);
 113     const bool showHiddenFiles = m_view->m_controller->dolphinView()->showHiddenFiles();
 114     m_dirLister->setShowingDotFiles(showHiddenFiles);
 115
 116     m_dolphinModel = new DolphinModel(this);
 117     m_dolphinModel->setDirLister(m_dirLister);
 118     m_dolphinModel->setDropsAllowed(DolphinModel::DropOnDirectory);
 119
 120     m_proxyModel = new DolphinSortFilterProxyModel(this);
 121     m_proxyModel->setSourceModel(m_dolphinModel);
 122     m_proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
 123     const DolphinView* dolphinView = m_view->m_controller->dolphinView();
 124     m_proxyModel->setSorting(dolphinView->sorting());
 125     m_proxyModel->setSortOrder(dolphinView->sortOrder());
 126
 127     setModel(m_proxyModel);
 128
 129     if (DolphinSettings::instance().generalSettings()->showSelectionToggle()) {
 130         m_selectionManager = new SelectionManager(this);
 131         connect(m_selectionManager, SIGNAL(selectionChanged()),
 132                 this, SLOT(requestActivation()));
 133         connect(m_view->m_controller, SIGNAL(urlChanged(const KUrl&)),
 134                 m_selectionManager, SLOT(reset()));
 135     }
 136
 137     m_previewGenerator = new KFilePreviewGenerator(this);
 138     m_previewGenerator->setPreviewShown(m_view->m_controller->dolphinView()->showPreview());
 139
 140     if (DolphinSettings::instance().generalSettings()->showToolTips()) {
 141         new ToolTipManager(this, m_proxyModel);
 142     }
 143
 144     m_dirLister->openUrl(url, KDirLister::NoFlags);
 145
 146     connect(KGlobalSettings::self(), SIGNAL(kdisplayFontChanged()),
 147             this, SLOT(updateFont()));
 148
 149     FolderExpander* folderExpander = new FolderExpander(this, m_proxyModel);
 150     folderExpander->setEnabled(DolphinSettings::instance().generalSettings()->autoExpandFolders());
 151     connect (folderExpander, SIGNAL(enterDir(const QModelIndex&)),
 152              m_view->m_controller, SLOT(triggerItem(const QModelIndex&)));
 153 }
 154
 155 DolphinColumnWidget::~DolphinColumnWidget()
 156 {
 157     delete m_proxyModel;
 158     m_proxyModel = 0;
 159     delete m_dolphinModel;
 160     m_dolphinModel = 0;
 161     m_dirLister = 0; // deleted by m_dolphinModel
 162 }
 163
 164 void DolphinColumnWidget::setDecorationSize(const QSize& size)
 165 {
 166     setIconSize(size);
 167     m_decorationSize = size;
 168     doItemsLayout();
 169     if (m_previewGenerator != 0) {
 170         m_previewGenerator->updatePreviews();
 171     }
 172     if (m_selectionManager != 0) {
 173         m_selectionManager->reset();
 174     }
 175 }
 176
 177 void DolphinColumnWidget::setActive(bool active)
 178 {
 179     if (m_active == active) {
 180         return;
 181     }
 182
 183     m_active = active;
 184
 185     if (active) {
 186         activate();
 187     } else {
 188         deactivate();
 189     }
 190 }
 191
 192 void DolphinColumnWidget::reload()
 193 {
 194     m_dirLister->stop();
 195     m_dirLister->openUrl(m_url, KDirLister::Reload);
 196 }
 197
 198 void DolphinColumnWidget::setSorting(DolphinView::Sorting sorting)
 199 {
 200     m_proxyModel->setSorting(sorting);
 201 }
 202
 203 void DolphinColumnWidget::setSortOrder(Qt::SortOrder order)
 204 {
 205     m_proxyModel->setSortOrder(order);
 206 }
 207
 208 void DolphinColumnWidget::setShowHiddenFiles(bool show)
 209 {
 210     if (show != m_dirLister->showingDotFiles()) {
 211         m_dirLister->setShowingDotFiles(show);
 212         m_dirLister->stop();
 213         m_dirLister->openUrl(m_url, KDirLister::Reload);
 214     }
 215 }
 216
 217 void DolphinColumnWidget::setShowPreview(bool show)
 218 {
 219     m_previewGenerator->setPreviewShown(show);
 220
 221     m_dirLister->stop();
 222     m_dirLister->openUrl(m_url, KDirLister::Reload);
 223 }
 224
 225 void DolphinColumnWidget::updateBackground()
 226 {
 227     // TODO: The alpha-value 150 is copied from DolphinView::setActive(). When
 228     // cleaning up the cut-indication of DolphinColumnWidget with the code from
 229     // DolphinView a common helper-class should be available which can be shared
 230     // by all view implementations -> no hardcoded value anymore
 231     const QPalette::ColorRole role = viewport()->backgroundRole();
 232     QColor color = viewport()->palette().color(role);
 233     color.setAlpha((m_active && m_view->m_active) ? 255 : 150);
 234
 235     QPalette palette = viewport()->palette();
 236     palette.setColor(role, color);
 237     viewport()->setPalette(palette);
 238
 239     update();
 240 }
 241
 242 void DolphinColumnWidget::setNameFilter(const QString& nameFilter)
 243 {
 244     m_proxyModel->setFilterRegExp(nameFilter);
 245 }
 246
 247 void DolphinColumnWidget::editItem(const KFileItem& item)
 248 {
 249     const QModelIndex dirIndex = m_dolphinModel->indexForItem(item);
 250     const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
 251     if (proxyIndex.isValid()) {
 252         edit(proxyIndex);
 253     }
 254 }
 255
 256 KFileItem DolphinColumnWidget::itemAt(const QPoint& pos) const
 257 {
 258     KFileItem item;
 259     const QModelIndex index = indexAt(pos);
 260     if (index.isValid() && (index.column() == DolphinModel::Name)) {
 261         const QModelIndex dolphinModelIndex = m_proxyModel->mapToSource(index);
 262         item = m_dolphinModel->itemForIndex(dolphinModelIndex);
 263     }
 264     return item;
 265 }
 266
 267 KFileItemList DolphinColumnWidget::selectedItems() const
 268 {
 269     const QItemSelection selection = m_proxyModel->mapSelectionToSource(selectionModel()->selection());
 270     KFileItemList itemList;
 271
 272     const QModelIndexList indexList = selection.indexes();
 273     foreach (const QModelIndex &index, indexList) {
 274         KFileItem item = m_dolphinModel->itemForIndex(index);
 275         if (!item.isNull()) {
 276             itemList.append(item);
 277         }
 278     }
 279
 280     return itemList;
 281 }
 282
 283 QMimeData* DolphinColumnWidget::selectionMimeData() const
 284 {
 285     const QItemSelection selection = m_proxyModel->mapSelectionToSource(selectionModel()->selection());
 286     return m_dolphinModel->mimeData(selection.indexes());
 287 }
 288
 289 QStyleOptionViewItem DolphinColumnWidget::viewOptions() const
 290 {
 291     QStyleOptionViewItem viewOptions = QListView::viewOptions();
 292     viewOptions.font = m_font;
 293     viewOptions.decorationSize = m_decorationSize;
 294     viewOptions.showDecorationSelected = true;
 295     return viewOptions;
 296 }
 297
 298 void DolphinColumnWidget::startDrag(Qt::DropActions supportedActions)
 299 {
 300     DragAndDropHelper::instance().startDrag(this, supportedActions, m_view->m_controller);
 301 }
 302
 303 void DolphinColumnWidget::dragEnterEvent(QDragEnterEvent* event)
 304 {
 305     if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) {
 306         event->acceptProposedAction();
 307         requestActivation();
 308     }
 309 }
 310
 311 void DolphinColumnWidget::dragLeaveEvent(QDragLeaveEvent* event)
 312 {
 313     QListView::dragLeaveEvent(event);
 314     setDirtyRegion(m_dropRect);
 315 }
 316
 317 void DolphinColumnWidget::dragMoveEvent(QDragMoveEvent* event)
 318 {
 319     QListView::dragMoveEvent(event);
 320
 321     // TODO: remove this code when the issue #160611 is solved in Qt 4.4
 322     const QModelIndex index = indexAt(event->pos());
 323     setDirtyRegion(m_dropRect);
 324
 325     m_dropRect.setSize(QSize()); // set as invalid
 326     if (index.isValid()) {
 327         m_view->m_controller->setItemView(this);
 328         const KFileItem item = m_view->m_controller->itemForIndex(index);
 329         if (!item.isNull() && item.isDir()) {
 330             m_dropRect = visualRect(index);
 331         }
 332     }
 333     setDirtyRegion(m_dropRect);
 334
 335     if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) {
 336         // accept url drops, independently from the destination item
 337         event->acceptProposedAction();
 338     }
 339 }
 340
 341 void DolphinColumnWidget::dropEvent(QDropEvent* event)
 342 {
 343     const QModelIndex index = indexAt(event->pos());
 344     m_view->m_controller->setItemView(this);
 345     const KFileItem item = m_view->m_controller->itemForIndex(index);
 346     m_view->m_controller->indicateDroppedUrls(item, url(), event);
 347     QListView::dropEvent(event);
 348 }
 349
 350 void DolphinColumnWidget::paintEvent(QPaintEvent* event)
 351 {
 352     if (!m_childUrl.isEmpty()) {
 353         // indicate the shown URL of the next column by highlighting the shown folder item
 354         const QModelIndex dirIndex = m_dolphinModel->indexForUrl(m_childUrl);
 355         const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
 356         if (proxyIndex.isValid() && !selectionModel()->isSelected(proxyIndex)) {
 357             const QRect itemRect = visualRect(proxyIndex);
 358             QPainter painter(viewport());
 359             QColor color = KColorScheme(QPalette::Active, KColorScheme::View).foreground().color();
 360             color.setAlpha(32);
 361             painter.setPen(Qt::NoPen);
 362             painter.setBrush(color);
 363             painter.drawRect(itemRect);
 364         }
 365     }
 366
 367     QListView::paintEvent(event);
 368 }
 369
 370 void DolphinColumnWidget::mousePressEvent(QMouseEvent* event)
 371 {
 372     requestActivation();
 373     if (!indexAt(event->pos()).isValid()) {
 374         if (QApplication::mouseButtons() & Qt::MidButton) {
 375             m_view->m_controller->replaceUrlByClipboard();
 376         }
 377     } else if (event->button() == Qt::LeftButton) {
 378         // TODO: see comment in DolphinIconsView::mousePressEvent()
 379         setState(QAbstractItemView::DraggingState);
 380     }
 381     QListView::mousePressEvent(event);
 382 }
 383
 384 void DolphinColumnWidget::keyPressEvent(QKeyEvent* event)
 385 {
 386     QListView::keyPressEvent(event);
 387     requestActivation();
 388     m_view->m_controller->handleKeyPressEvent(event);
 389 }
 390
 391 void DolphinColumnWidget::contextMenuEvent(QContextMenuEvent* event)
 392 {
 393     if (!m_active) {
 394         m_view->requestActivation(this);
 395         Q_ASSERT(m_view->m_controller->itemView() == this);
 396         m_view->m_controller->triggerUrlChangeRequest(m_url);
 397     }
 398     Q_ASSERT(m_active);
 399
 400     QListView::contextMenuEvent(event);
 401
 402     const QModelIndex index = indexAt(event->pos());
 403     if (!index.isValid()) {
 404         clearSelection();
 405     }
 406
 407     const QPoint pos = m_view->viewport()->mapFromGlobal(event->globalPos());
 408     Q_ASSERT(m_view->m_controller->itemView() == this);
 409     m_view->m_controller->triggerContextMenuRequest(pos);
 410 }
 411
 412 void DolphinColumnWidget::wheelEvent(QWheelEvent* event)
 413 {
 414     if (m_selectionManager != 0) {
 415         m_selectionManager->reset();
 416     }
 417
 418     // let Ctrl+wheel events propagate to the DolphinView for icon zooming
 419     if (event->modifiers() & Qt::ControlModifier) {
 420         event->ignore();
 421         return;
 422     }
 423
 424     QListView::wheelEvent(event);
 425 }
 426
 427 void DolphinColumnWidget::leaveEvent(QEvent* event)
 428 {
 429     QListView::leaveEvent(event);
 430     // if the mouse is above an item and moved very fast outside the widget,
 431     // no viewportEntered() signal might be emitted although the mouse has been moved
 432     // above the viewport
 433     m_view->m_controller->emitViewportEntered();
 434 }
 435
 436 void DolphinColumnWidget::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
 437 {
 438     QListView::selectionChanged(selected, deselected);
 439
 440     QItemSelectionModel* selModel = m_view->selectionModel();
 441     selModel->select(selected, QItemSelectionModel::Select);
 442     selModel->select(deselected, QItemSelectionModel::Deselect);
 443 }
 444
 445 void DolphinColumnWidget::slotEntered(const QModelIndex& index)
 446 {
 447     m_view->m_controller->setItemView(this);
 448     m_view->m_controller->emitItemEntered(index);
 449 }
 450
 451 void DolphinColumnWidget::requestActivation()
 452 {
 453     m_view->m_controller->setItemView(this);
 454     m_view->m_controller->requestActivation();
 455     if (!m_active) {
 456         m_view->requestActivation(this);
 457         m_view->m_controller->triggerUrlChangeRequest(m_url);
 458         selectionModel()->clear();
 459     }
 460 }
 461
 462 void DolphinColumnWidget::updateFont()
 463 {
 464     const ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
 465     Q_ASSERT(settings != 0);
 466
 467     if (settings->useSystemFont()) {
 468         m_font = KGlobalSettings::generalFont();
 469     }
 470 }
 471
 472 void DolphinColumnWidget::activate()
 473 {
 474     setFocus(Qt::OtherFocusReason);
 475
 476     connect(this, SIGNAL(clicked(const QModelIndex&)),
 477             m_view->m_controller, SLOT(requestTab(const QModelIndex&)));
 478     if (KGlobalSettings::singleClick()) {
 479         connect(this, SIGNAL(clicked(const QModelIndex&)),
 480                 m_view->m_controller, SLOT(triggerItem(const QModelIndex&)));
 481     } else {
 482         connect(this, SIGNAL(doubleClicked(const QModelIndex&)),
 483                 m_view->m_controller, SLOT(triggerItem(const QModelIndex&)));
 484     }
 485
 486     if (selectionModel() && selectionModel()->currentIndex().isValid())
 487         selectionModel()->setCurrentIndex(selectionModel()->currentIndex(), QItemSelectionModel::SelectCurrent);
 488
 489     updateBackground();
 490 }
 491
 492 void DolphinColumnWidget::deactivate()
 493 {
 494     clearFocus();
 495
 496     // TODO: Connecting to the signal 'activated()' is not possible, as kstyle
 497     // does not forward the single vs. doubleclick to it yet (KDE 4.1?). Hence it is
 498     // necessary connecting the signal 'singleClick()' or 'doubleClick'.
 499     if (KGlobalSettings::singleClick()) {
 500         disconnect(this, SIGNAL(clicked(const QModelIndex&)),
 501                    m_view->m_controller, SLOT(triggerItem(const QModelIndex&)));
 502     } else {
 503         disconnect(this, SIGNAL(doubleClicked(const QModelIndex&)),
 504                    m_view->m_controller, SLOT(triggerItem(const QModelIndex&)));
 505     }
 506
 507     const QModelIndex current = selectionModel()->currentIndex();
 508     selectionModel()->clear();
 509     selectionModel()->setCurrentIndex(current, QItemSelectionModel::NoUpdate);
 510     updateBackground();
 511 }
 512
 513 #include "dolphincolumnwidget.moc"