src/dolphincolumnview.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 "dolphincolumnview.h"
  21
  22 #include "dolphincontroller.h"
  23 #include "dolphinsettings.h"
  24
  25 #include "dolphin_columnmodesettings.h"
  26
  27 #include <kcolorutils.h>
  28 #include <kcolorscheme.h>
  29 #include <kdirlister.h>
  30 #include <kdirmodel.h>
  31
  32 #include <QAbstractProxyModel>
  33 #include <QApplication>
  34 #include <QPoint>
  35 #include <QScrollBar>
  36 #include <QTimeLine>
  37
  38 /**
  39  * Represents one column inside the DolphinColumnView and has been
  40  * extended to respect view options and hovering information.
  41  */
  42 class ColumnWidget : public QListView
  43 {
  44 public:
  45     ColumnWidget(QWidget* parent,
  46                  DolphinColumnView* columnView,
  47                  const KUrl& url);
  48     virtual ~ColumnWidget();
  49
  50     /** Sets the size of the icons. */
  51     void setDecorationSize(const QSize& size);
  52
  53     /**
  54      * An active column is defined as column, which shows the same URL
  55      * as indicated by the URL navigator. The active column is usually
  56      * drawn in a lighter color. All operations are applied to this column.
  57      */
  58     void setActive(bool active);
  59     inline bool isActive() const;
  60
  61     /**
  62      * Sets the directory URL of the child column that is shown next to
  63      * this column. This property is only used for a visual indication
  64      * of the shown directory, it does not trigger a loading of the model.
  65      */
  66     inline void setChildUrl(const KUrl& url);
  67     inline const KUrl& childUrl() const;
  68
  69     /**
  70      * Returns the directory URL that is shown inside the column widget.
  71      */
  72     inline const KUrl& url() const;
  73
  74 protected:
  75     virtual QStyleOptionViewItem viewOptions() const;
  76     virtual void dragEnterEvent(QDragEnterEvent* event);
  77     virtual void dragLeaveEvent(QDragLeaveEvent* event);
  78     virtual void dragMoveEvent(QDragMoveEvent* event);
  79     virtual void dropEvent(QDropEvent* event);
  80     virtual void paintEvent(QPaintEvent* event);
  81     virtual void mousePressEvent(QMouseEvent* event);
  82     virtual void contextMenuEvent(QContextMenuEvent* event);
  83     virtual void selectionChanged(const QItemSelection& selected, const QItemSelection& deselected);
  84
  85 private:
  86     /** Used by ColumnWidget::setActive(). */
  87     void activate();
  88
  89     /** Used by ColumnWidget::setActive(). */
  90     void deactivate();
  91
  92 private:
  93     bool m_active;
  94     DolphinColumnView* m_view;
  95     KUrl m_url;      // URL of the directory that is shown
  96     KUrl m_childUrl; // URL of the next column that is shown
  97     QStyleOptionViewItem m_viewOptions;
  98
  99     bool m_dragging;   // TODO: remove this property when the issue #160611 is solved in Qt 4.4
 100     QRect m_dropRect;  // TODO: remove this property when the issue #160611 is solved in Qt 4.4
 101 };
 102
 103 ColumnWidget::ColumnWidget(QWidget* parent,
 104                            DolphinColumnView* columnView,
 105                            const KUrl& url) :
 106     QListView(columnView),
 107     m_active(true),
 108     m_view(columnView),
 109     m_url(url),
 110     m_childUrl(),
 111     m_dragging(false),
 112     m_dropRect()
 113 {
 114     setMouseTracking(true);
 115     viewport()->setAttribute(Qt::WA_Hover);
 116     setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 117     setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 118     setSelectionMode(QAbstractItemView::ExtendedSelection);
 119
 120     // apply the column mode settings to the widget
 121     const ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
 122     Q_ASSERT(settings != 0);
 123
 124     m_viewOptions = QListView::viewOptions();
 125
 126     QFont font(settings->fontFamily(), settings->fontSize());
 127     font.setItalic(settings->italicFont());
 128     font.setBold(settings->boldFont());
 129     m_viewOptions.font = font;
 130
 131     const int iconSize = settings->iconSize();
 132     m_viewOptions.decorationSize = QSize(iconSize, iconSize);
 133
 134     KFileItemDelegate* delegate = new KFileItemDelegate(this);
 135     setItemDelegate(delegate);
 136
 137     activate();
 138
 139     connect(this, SIGNAL(entered(const QModelIndex&)),
 140             m_view->m_controller, SLOT(emitItemEntered(const QModelIndex&)));
 141     connect(this, SIGNAL(viewportEntered()),
 142             m_view->m_controller, SLOT(emitViewportEntered()));
 143 }
 144
 145 ColumnWidget::~ColumnWidget()
 146 {
 147 }
 148
 149 void ColumnWidget::setDecorationSize(const QSize& size)
 150 {
 151     m_viewOptions.decorationSize = size;
 152     doItemsLayout();
 153 }
 154
 155 void ColumnWidget::setActive(bool active)
 156 {
 157     if (m_active == active) {
 158         return;
 159     }
 160
 161     m_active = active;
 162
 163     if (active) {
 164         activate();
 165     } else {
 166         deactivate();
 167     }
 168 }
 169
 170 inline bool ColumnWidget::isActive() const
 171 {
 172     return m_active;
 173 }
 174
 175 inline void ColumnWidget::setChildUrl(const KUrl& url)
 176 {
 177     m_childUrl = url;
 178 }
 179
 180 inline const KUrl& ColumnWidget::childUrl() const
 181 {
 182     return m_childUrl;
 183 }
 184
 185 const KUrl& ColumnWidget::url() const
 186 {
 187     return m_url;
 188 }
 189
 190 QStyleOptionViewItem ColumnWidget::viewOptions() const
 191 {
 192     return m_viewOptions;
 193 }
 194
 195 void ColumnWidget::dragEnterEvent(QDragEnterEvent* event)
 196 {
 197     if (event->mimeData()->hasUrls()) {
 198         event->acceptProposedAction();
 199     }
 200
 201     m_dragging = true;
 202 }
 203
 204 void ColumnWidget::dragLeaveEvent(QDragLeaveEvent* event)
 205 {
 206     QListView::dragLeaveEvent(event);
 207
 208     // TODO: remove this code when the issue #160611 is solved in Qt 4.4
 209     m_dragging = false;
 210     setDirtyRegion(m_dropRect);
 211 }
 212
 213 void ColumnWidget::dragMoveEvent(QDragMoveEvent* event)
 214 {
 215     QListView::dragMoveEvent(event);
 216
 217     // TODO: remove this code when the issue #160611 is solved in Qt 4.4
 218     const QModelIndex index = indexAt(event->pos());
 219     setDirtyRegion(m_dropRect);
 220     m_dropRect = visualRect(index);
 221     setDirtyRegion(m_dropRect);
 222 }
 223
 224 void ColumnWidget::dropEvent(QDropEvent* event)
 225 {
 226     const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData());
 227     if (!urls.isEmpty()) {
 228         event->acceptProposedAction();
 229         m_view->m_controller->indicateDroppedUrls(urls,
 230                                                   indexAt(event->pos()),
 231                                                   event->source());
 232     }
 233     QListView::dropEvent(event);
 234     m_dragging = false;
 235 }
 236
 237 void ColumnWidget::paintEvent(QPaintEvent* event)
 238 {
 239     if (!m_childUrl.isEmpty()) {
 240         // indicate the shown URL of the next column by highlighting the shown folder item
 241         const QAbstractProxyModel* proxyModel = static_cast<const QAbstractProxyModel*>(m_view->model());
 242         const KDirModel* dirModel = static_cast<const KDirModel*>(proxyModel->sourceModel());
 243         const QModelIndex dirIndex = dirModel->indexForUrl(m_childUrl);
 244         const QModelIndex proxyIndex = proxyModel->mapFromSource(dirIndex);
 245         if (proxyIndex.isValid() && !selectionModel()->isSelected(proxyIndex)) {
 246             const QRect itemRect = visualRect(proxyIndex);
 247             QPainter painter(viewport());
 248             painter.save();
 249
 250             QColor color = KColorScheme(QPalette::Active, KColorScheme::View).foreground().color();
 251             color.setAlpha(32);
 252             painter.setPen(Qt::NoPen);
 253             painter.setBrush(color);
 254             painter.drawRect(itemRect);
 255
 256             painter.restore();
 257         }
 258     }
 259
 260     QListView::paintEvent(event);
 261
 262     // TODO: remove this code when the issue #160611 is solved in Qt 4.4
 263     if (m_dragging) {
 264         const QBrush& brush = m_viewOptions.palette.brush(QPalette::Normal, QPalette::Highlight);
 265         DolphinController::drawHoverIndication(viewport(), m_dropRect, brush);
 266     }
 267 }
 268
 269 void ColumnWidget::mousePressEvent(QMouseEvent* event)
 270 {
 271     if (!m_active) {
 272         m_view->requestActivation(this);
 273     }
 274
 275     QListView::mousePressEvent(event);
 276 }
 277
 278 void ColumnWidget::contextMenuEvent(QContextMenuEvent* event)
 279 {
 280     if (!m_active) {
 281         m_view->requestActivation(this);
 282     }
 283
 284     QListView::contextMenuEvent(event);
 285
 286     const QModelIndex index = indexAt(event->pos());
 287     if (index.isValid() || m_active) {
 288         // Only open a context menu above an item or if the mouse is above
 289         // the active column.
 290         const QPoint pos = m_view->viewport()->mapFromGlobal(event->globalPos());
 291         m_view->m_controller->triggerContextMenuRequest(pos);
 292     }
 293 }
 294
 295 void ColumnWidget::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
 296 {
 297     QListView::selectionChanged(selected, deselected);
 298
 299     QItemSelectionModel* selModel = m_view->selectionModel();
 300     selModel->select(selected, QItemSelectionModel::Select);
 301     selModel->select(deselected, QItemSelectionModel::Deselect);
 302 }
 303
 304 void ColumnWidget::activate()
 305 {
 306     // TODO: Connecting to the signal 'activated()' is not possible, as kstyle
 307     // does not forward the single vs. doubleclick to it yet (KDE 4.1?). Hence it is
 308     // necessary connecting the signal 'singleClick()' or 'doubleClick'.
 309     if (KGlobalSettings::singleClick()) {
 310         connect(this, SIGNAL(clicked(const QModelIndex&)),
 311                 m_view, SLOT(triggerItem(const QModelIndex&)));
 312     } else {
 313         connect(this, SIGNAL(doubleClicked(const QModelIndex&)),
 314                 m_view, SLOT(triggerItem(const QModelIndex&)));
 315     }
 316
 317     const QColor bgColor = KColorScheme(QPalette::Active, KColorScheme::View).background().color();
 318     QPalette palette = viewport()->palette();
 319     palette.setColor(viewport()->backgroundRole(), bgColor);
 320     viewport()->setPalette(palette);
 321
 322     update();
 323 }
 324
 325 void ColumnWidget::deactivate()
 326 {
 327     // TODO: Connecting to the signal 'activated()' is not possible, as kstyle
 328     // does not forward the single vs. doubleclick to it yet (KDE 4.1?). Hence it is
 329     // necessary connecting the signal 'singleClick()' or 'doubleClick'.
 330     if (KGlobalSettings::singleClick()) {
 331         disconnect(this, SIGNAL(clicked(const QModelIndex&)),
 332                    m_view, SLOT(triggerItem(const QModelIndex&)));
 333     } else {
 334         disconnect(this, SIGNAL(doubleClicked(const QModelIndex&)),
 335                    m_view, SLOT(triggerItem(const QModelIndex&)));
 336     }
 337
 338     QColor bgColor = KColorScheme(QPalette::Active, KColorScheme::View).background().color();
 339     const QColor fgColor = KColorScheme(QPalette::Active, KColorScheme::View).foreground().color();
 340     bgColor = KColorUtils::mix(bgColor, fgColor, 0.04);
 341
 342     QPalette palette = viewport()->palette();
 343     palette.setColor(viewport()->backgroundRole(), bgColor);
 344     viewport()->setPalette(palette);
 345
 346     selectionModel()->clear();
 347
 348     update();
 349 }
 350
 351 // ---
 352
 353 DolphinColumnView::DolphinColumnView(QWidget* parent, DolphinController* controller) :
 354     QAbstractItemView(parent),
 355     m_controller(controller),
 356     m_index(-1),
 357     m_contentX(0),
 358     m_columns(),
 359     m_animation(0)
 360 {
 361     Q_ASSERT(controller != 0);
 362
 363     setAcceptDrops(true);
 364     setDragDropMode(QAbstractItemView::DragDrop);
 365     setDropIndicatorShown(false);
 366     setSelectionMode(ExtendedSelection);
 367
 368     connect(this, SIGNAL(entered(const QModelIndex&)),
 369             controller, SLOT(emitItemEntered(const QModelIndex&)));
 370     connect(this, SIGNAL(viewportEntered()),
 371             controller, SLOT(emitViewportEntered()));
 372     connect(controller, SIGNAL(zoomIn()),
 373             this, SLOT(zoomIn()));
 374     connect(controller, SIGNAL(zoomOut()),
 375             this, SLOT(zoomOut()));
 376     connect(controller, SIGNAL(urlChanged(const KUrl&)),
 377             this, SLOT(showColumn(const KUrl&)));
 378
 379     connect(horizontalScrollBar(), SIGNAL(valueChanged(int)),
 380             this, SLOT(moveContentHorizontally(int)));
 381
 382     ColumnWidget* column = new ColumnWidget(viewport(), this, m_controller->url());
 383     m_columns.append(column);
 384     setActiveColumnIndex(0);
 385
 386     updateDecorationSize();
 387
 388     m_animation = new QTimeLine(500, this);
 389     connect(m_animation, SIGNAL(frameChanged(int)), horizontalScrollBar(), SLOT(setValue(int)));
 390 }
 391
 392 DolphinColumnView::~DolphinColumnView()
 393 {
 394 }
 395
 396 QModelIndex DolphinColumnView::indexAt(const QPoint& point) const
 397 {
 398     foreach (ColumnWidget* column, m_columns) {
 399         const QPoint topLeft = column->frameGeometry().topLeft();
 400         const QPoint adjustedPoint(point.x() - topLeft.x(), point.y() - topLeft.y());
 401         QModelIndex index = column->indexAt(adjustedPoint);
 402         if (index.isValid()) {
 403             return index;
 404         }
 405     }
 406     return activeColumn()->indexAt(point);
 407
 408     return QModelIndex();
 409 }
 410
 411 void DolphinColumnView::scrollTo(const QModelIndex& index, ScrollHint hint)
 412 {
 413     activeColumn()->scrollTo(index, hint);
 414 }
 415
 416 QRect DolphinColumnView::visualRect(const QModelIndex& index) const
 417 {
 418     return activeColumn()->visualRect(index);
 419 }
 420
 421 void DolphinColumnView::setModel(QAbstractItemModel* model)
 422 {
 423     // TODO: remove all columns
 424
 425     activeColumn()->setModel(model);
 426     QAbstractItemView::setModel(model);
 427 }
 428
 429 bool DolphinColumnView::isIndexHidden(const QModelIndex& index) const
 430 {
 431     return false;//activeColumn()->isIndexHidden(index);
 432 }
 433
 434 QModelIndex DolphinColumnView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
 435 {
 436     return QModelIndex(); //activeColumn()->moveCursor(cursorAction, modifiers);
 437 }
 438
 439 void DolphinColumnView::setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags flags)
 440 {
 441     //activeColumn()->setSelection(rect, flags);
 442 }
 443
 444 QRegion DolphinColumnView::visualRegionForSelection(const QItemSelection& selection) const
 445 {
 446     return QRegion(); //activeColumn()->visualRegionForSelection(selection);
 447 }
 448
 449 int DolphinColumnView::horizontalOffset() const
 450 {
 451     return -m_contentX;
 452 }
 453
 454 int DolphinColumnView::verticalOffset() const
 455 {
 456     return 0; // activeColumn()->verticalOffset();
 457 }
 458
 459 void DolphinColumnView::mousePressEvent(QMouseEvent* event)
 460 {
 461     m_controller->triggerActivation();
 462     QAbstractItemView::mousePressEvent(event);
 463 }
 464
 465 void DolphinColumnView::dragEnterEvent(QDragEnterEvent* event)
 466 {
 467     if (event->mimeData()->hasUrls()) {
 468         event->acceptProposedAction();
 469     }
 470 }
 471
 472 void DolphinColumnView::dropEvent(QDropEvent* event)
 473 {
 474     const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData());
 475     if (!urls.isEmpty()) {
 476         m_controller->indicateDroppedUrls(urls,
 477                                           indexAt(event->pos()),
 478                                           event->source());
 479         event->acceptProposedAction();
 480     }
 481     QAbstractItemView::dropEvent(event);
 482 }
 483
 484 void DolphinColumnView::resizeEvent(QResizeEvent* event)
 485 {
 486     QAbstractItemView::resizeEvent(event);
 487     layoutColumns();
 488     updateScrollBar();
 489 }
 490
 491 void DolphinColumnView::zoomIn()
 492 {
 493     if (isZoomInPossible()) {
 494         ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
 495         // TODO: get rid of K3Icon sizes
 496         switch (settings->iconSize()) {
 497         case K3Icon::SizeSmall:  settings->setIconSize(K3Icon::SizeMedium); break;
 498         case K3Icon::SizeMedium: settings->setIconSize(K3Icon::SizeLarge); break;
 499         default: Q_ASSERT(false); break;
 500         }
 501         updateDecorationSize();
 502     }
 503 }
 504
 505 void DolphinColumnView::zoomOut()
 506 {
 507     if (isZoomOutPossible()) {
 508         ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
 509         // TODO: get rid of K3Icon sizes
 510         switch (settings->iconSize()) {
 511         case K3Icon::SizeLarge:  settings->setIconSize(K3Icon::SizeMedium); break;
 512         case K3Icon::SizeMedium: settings->setIconSize(K3Icon::SizeSmall); break;
 513         default: Q_ASSERT(false); break;
 514         }
 515         updateDecorationSize();
 516     }
 517 }
 518
 519 void DolphinColumnView::triggerItem(const QModelIndex& index)
 520 {
 521     m_controller->triggerItem(index);
 522
 523     const Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
 524     if ((modifiers & Qt::ControlModifier) || (modifiers & Qt::ShiftModifier)) {
 525         return;
 526     }
 527
 528     const QAbstractProxyModel* proxyModel = static_cast<const QAbstractProxyModel*>(model());
 529     const KDirModel* dirModel = static_cast<const KDirModel*>(proxyModel->sourceModel());
 530     const KFileItem item = dirModel->itemForIndex(proxyModel->mapToSource(index));
 531     if ((item.url() != activeColumn()->url()) && item.isDir()) {
 532         deleteInactiveChildColumns();
 533
 534         const KUrl& childUrl = m_controller->url();
 535         activeColumn()->setChildUrl(childUrl);
 536
 537         ColumnWidget* column = new ColumnWidget(viewport(), this, childUrl);
 538         column->setModel(model());
 539         column->setRootIndex(index);
 540
 541         m_columns.append(column);
 542
 543         setActiveColumnIndex(m_index + 1);
 544
 545         // Before invoking layoutColumns() the column must be shown. To prevent
 546         // a flickering the initial geometry is set to be invisible.
 547         column->setGeometry(QRect(-1, -1, 1, 1));
 548         column->show();
 549
 550         layoutColumns();
 551         updateScrollBar();
 552         assureVisibleActiveColumn();
 553     }
 554 }
 555
 556 void DolphinColumnView::moveContentHorizontally(int x)
 557 {
 558     m_contentX = -x;
 559     layoutColumns();
 560 }
 561
 562 void DolphinColumnView::showColumn(const KUrl& url)
 563 {
 564     if (!m_columns[0]->url().isParentOf(url)) {
 565         // the URL is no child URL of the column view, hence do nothing
 566         return;
 567     }
 568
 569     int columnIndex = 0;
 570     foreach (ColumnWidget* column, m_columns) {
 571         if (column->url() == url) {
 572             // the column represents already the requested URL, hence activate it
 573             requestActivation(column);
 574             return;
 575         } else if (!column->url().isParentOf(url)) {
 576             // the column is no parent of the requested URL, hence it must
 577             // be deleted and a new column must be loaded
 578             if (columnIndex > 0) {
 579                 setActiveColumnIndex(columnIndex - 1);
 580                 deleteInactiveChildColumns();
 581             }
 582
 583             const QAbstractProxyModel* proxyModel = static_cast<const QAbstractProxyModel*>(model());
 584             const KDirModel* dirModel = static_cast<const KDirModel*>(proxyModel->sourceModel());
 585             const QModelIndex dirIndex = dirModel->indexForUrl(url);
 586             if (dirIndex.isValid()) {
 587                 triggerItem(proxyModel->mapFromSource(dirIndex));
 588             }
 589             return;
 590         }
 591         ++columnIndex;
 592     }
 593 }
 594
 595 void DolphinColumnView::updateDecorationSize()
 596 {
 597     ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
 598     const int iconSize = settings->iconSize();
 599
 600     foreach (QObject* object, viewport()->children()) {
 601         if (object->inherits("QListView")) {
 602             ColumnWidget* widget = static_cast<ColumnWidget*>(object);
 603             widget->setDecorationSize(QSize(iconSize, iconSize));
 604         }
 605     }
 606
 607     m_controller->setZoomInPossible(isZoomInPossible());
 608     m_controller->setZoomOutPossible(isZoomOutPossible());
 609
 610     doItemsLayout();
 611 }
 612
 613 bool DolphinColumnView::isZoomInPossible() const
 614 {
 615     ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
 616     return settings->iconSize() < K3Icon::SizeLarge;
 617 }
 618
 619 bool DolphinColumnView::isZoomOutPossible() const
 620 {
 621     ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();
 622     return settings->iconSize() > K3Icon::SizeSmall;
 623 }
 624
 625 void DolphinColumnView::setActiveColumnIndex(int index)
 626 {
 627     if (m_index == index) {
 628         return;
 629     }
 630
 631     const bool hasActiveColumn = (m_index >= 0);
 632     if (hasActiveColumn) {
 633         m_columns[m_index]->setActive(false);
 634     }
 635
 636     m_index = index;
 637     m_columns[m_index]->setActive(true);
 638 }
 639
 640 void DolphinColumnView::layoutColumns()
 641 {
 642     int x = m_contentX;
 643     const int columnWidth = 250;
 644     foreach (ColumnWidget* column, m_columns) {
 645         column->setGeometry(QRect(x, 0, columnWidth, viewport()->height()));
 646         x += columnWidth;
 647     }
 648 }
 649
 650 void DolphinColumnView::updateScrollBar()
 651 {
 652     int contentWidth = 0;
 653     foreach (ColumnWidget* column, m_columns) {
 654         contentWidth += column->width();
 655     }
 656
 657     horizontalScrollBar()->setPageStep(contentWidth);
 658     horizontalScrollBar()->setRange(0, contentWidth - viewport()->width());
 659 }
 660
 661 void DolphinColumnView::assureVisibleActiveColumn()
 662 {
 663     const int viewportWidth = viewport()->width();
 664     const int x = activeColumn()->x();
 665     const int width = activeColumn()->width();
 666     if (x + width > viewportWidth) {
 667         int newContentX = m_contentX - x - width + viewportWidth;
 668         if (newContentX > 0) {
 669             newContentX = 0;
 670         }
 671         m_animation->setFrameRange(-m_contentX, -newContentX);
 672         m_animation->start();
 673     } else if (x < 0) {
 674         const int newContentX = m_contentX - x;
 675         m_animation->setFrameRange(-m_contentX, -newContentX);
 676         m_animation->start();
 677     }
 678 }
 679
 680 void DolphinColumnView::requestActivation(ColumnWidget* column)
 681 {
 682     if (column->isActive()) {
 683         assureVisibleActiveColumn();
 684     } else {
 685         int index = 0;
 686         foreach (ColumnWidget* currColumn, m_columns) {
 687             if (currColumn == column) {
 688                 setActiveColumnIndex(index);
 689                 assureVisibleActiveColumn();
 690                 return;
 691             }
 692             ++index;
 693         }
 694     }
 695 }
 696
 697 void DolphinColumnView::deleteInactiveChildColumns()
 698 {
 699     QList<ColumnWidget*>::iterator start = m_columns.begin() + m_index + 1;
 700     QList<ColumnWidget*>::iterator end = m_columns.end();
 701     for (QList<ColumnWidget*>::iterator it = start; it != end; ++it) {
 702         (*it)->deleteLater();
 703     }
 704     m_columns.erase(start, end);
 705 }
 706
 707 #include "dolphincolumnview.moc"