diff --git a/app/configdialog.cpp b/app/configdialog.cpp
index 624a014e..7e325acf 100644
--- a/app/configdialog.cpp
+++ b/app/configdialog.cpp
@@ -1,132 +1,133 @@
 // vim: set tabstop=4 shiftwidth=4 expandtab:
 /*
 Gwenview: an image viewer
 Copyright 2007 Aurélien Gâteau <agateau@kde.org>
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
 */
 // Self
 #include "configdialog.h"
 
 // Qt
 
 // KDE
 #include <KLocalizedString>
 
 // Local
 #include <lib/gwenviewconfig.h>
 #include <QFontDatabase>
 
 namespace Gwenview
 {
 
 template <class Ui>
 QWidget* setupPage(Ui& ui)
 {
     QWidget* widget = new QWidget;
     ui.setupUi(widget);
     widget->layout()->setMargin(0);
     return widget;
 }
 
 ConfigDialog::ConfigDialog(QWidget* parent)
 : KConfigDialog(parent, "Settings", GwenviewConfig::self())
 {
     setFaceType(KPageDialog::List);
 
     QWidget* widget;
     KPageWidgetItem* pageItem;
 
     // General
     widget = setupPage(mGeneralConfigPage);
     
     mThumbnailActionsGroup = new InvisibleButtonGroup(widget);
     mThumbnailActionsGroup->setObjectName(QLatin1String("kcfg_ThumbnailActions"));
     mThumbnailActionsGroup->addButton(mGeneralConfigPage.allButtonsThumbnailActionsRadioButton, int(ThumbnailActions::AllButtons));
     mThumbnailActionsGroup->addButton(mGeneralConfigPage.selectionOnlyThumbnailActionsRadioButton, int(ThumbnailActions::ShowSelectionButtonOnly));
     mThumbnailActionsGroup->addButton(mGeneralConfigPage.noneThumbnailActionsRadioButton, int(ThumbnailActions::None));
 
     pageItem = addPage(widget, i18n("General"));
     pageItem->setIcon(QIcon::fromTheme("gwenview"));
     connect(mGeneralConfigPage.kcfg_ViewBackgroundValue, SIGNAL(valueChanged(int)), SLOT(updateViewBackgroundFrame()));
 
     // Image View
     widget = setupPage(mImageViewConfigPage);
 
     mAlphaBackgroundModeGroup = new InvisibleButtonGroup(widget);
     mAlphaBackgroundModeGroup->setObjectName(QLatin1String("kcfg_AlphaBackgroundMode"));
     mAlphaBackgroundModeGroup->addButton(mImageViewConfigPage.surroundingRadioButton, int(AbstractImageView::AlphaBackgroundNone));
     mAlphaBackgroundModeGroup->addButton(mImageViewConfigPage.checkBoardRadioButton, int(AbstractImageView::AlphaBackgroundCheckBoard));
     mAlphaBackgroundModeGroup->addButton(mImageViewConfigPage.solidColorRadioButton, int(AbstractImageView::AlphaBackgroundSolid));
 
     mWheelBehaviorGroup = new InvisibleButtonGroup(widget);
     mWheelBehaviorGroup->setObjectName(QLatin1String("kcfg_MouseWheelBehavior"));
     mWheelBehaviorGroup->addButton(mImageViewConfigPage.mouseWheelScrollRadioButton, int(MouseWheelBehavior::Scroll));
     mWheelBehaviorGroup->addButton(mImageViewConfigPage.mouseWheelBrowseRadioButton, int(MouseWheelBehavior::Browse));
+    mWheelBehaviorGroup->addButton(mImageViewConfigPage.mouseWheelZoomRadioButton, int(MouseWheelBehavior::Zoom));
 
     mAnimationMethodGroup = new InvisibleButtonGroup(widget);
     mAnimationMethodGroup->setObjectName(QLatin1String("kcfg_AnimationMethod"));
     mAnimationMethodGroup->addButton(mImageViewConfigPage.glAnimationRadioButton, int(DocumentView::GLAnimation));
     mAnimationMethodGroup->addButton(mImageViewConfigPage.softwareAnimationRadioButton, int(DocumentView::SoftwareAnimation));
     mAnimationMethodGroup->addButton(mImageViewConfigPage.noAnimationRadioButton, int(DocumentView::NoAnimation));
 
     mZoomModeGroup = new InvisibleButtonGroup(widget);
     mZoomModeGroup->setObjectName(QLatin1String("kcfg_ZoomMode"));
     mZoomModeGroup->addButton(mImageViewConfigPage.autofitZoomModeRadioButton, int(ZoomMode::Autofit));
     mZoomModeGroup->addButton(mImageViewConfigPage.keepSameZoomModeRadioButton, int(ZoomMode::KeepSame));
     mZoomModeGroup->addButton(mImageViewConfigPage.individualZoomModeRadioButton, int(ZoomMode::Individual));
 
     mThumbnailBarOrientationGroup = new InvisibleButtonGroup(widget);
     mThumbnailBarOrientationGroup->setObjectName(QLatin1String("kcfg_ThumbnailBarOrientation"));
     mThumbnailBarOrientationGroup->addButton(mImageViewConfigPage.horizontalRadioButton, int(Qt::Horizontal));
     mThumbnailBarOrientationGroup->addButton(mImageViewConfigPage.verticalRadioButton, int(Qt::Vertical));
 
     pageItem = addPage(widget, i18n("Image View"));
     pageItem->setIcon(QIcon::fromTheme("view-preview"));
 
     // Advanced
     widget = setupPage(mAdvancedConfigPage);
 
     mRenderingIntentGroup = new InvisibleButtonGroup(widget);
     mRenderingIntentGroup->setObjectName(QLatin1String("kcfg_RenderingIntent"));
     mRenderingIntentGroup->addButton(mAdvancedConfigPage.relativeRenderingIntentRadioButton, int(RenderingIntent::Relative));
     mRenderingIntentGroup->addButton(mAdvancedConfigPage.perceptualRenderingIntentRadioButton, int(RenderingIntent::Perceptual));
 
     pageItem = addPage(widget, i18n("Advanced"));
     pageItem->setIcon(QIcon::fromTheme("preferences-other"));
     mAdvancedConfigPage.cacheHelpLabel->setFont(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont));
     mAdvancedConfigPage.perceptualHelpLabel->setFont(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont));
     mAdvancedConfigPage.relativeHelpLabel->setFont(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont));
 
     updateViewBackgroundFrame();
 }
 
 void ConfigDialog::updateViewBackgroundFrame()
 {
     QColor color = QColor::fromHsv(0, 0, mGeneralConfigPage.kcfg_ViewBackgroundValue->value());
     QString css =
         QString(
             "background-color: %1;"
             "border-radius: 5px;"
             "border: 1px solid %1;")
         .arg(color.name());
     // When using Oxygen, setting the background color via palette causes the
     // pixels outside the frame to be painted with the new background color as
     // well. Using CSS works more like expected.
     mGeneralConfigPage.backgroundValueFrame->setStyleSheet(css);
 }
 
 } // namespace
diff --git a/app/imageviewconfigpage.ui b/app/imageviewconfigpage.ui
index 6ee7c89d..8819b122 100644
--- a/app/imageviewconfigpage.ui
+++ b/app/imageviewconfigpage.ui
@@ -1,661 +1,686 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>ImageViewConfigPage</class>
  <widget class="QWidget" name="ImageViewConfigPage">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>500</width>
     <height>650</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QLabel" name="label_1">
      <property name="text">
       <string>Show transparency with:</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
      </property>
      <property name="buddy">
       <cstring>surroundingRadioButton</cstring>
      </property>
     </widget>
    </item>
    <item row="0" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_0">
      <property name="spacing">
       <number>6</number>
      </property>
      <property name="margin">
       <number>0</number>
      </property>
      <item>
       <widget class="QRadioButton" name="surroundingRadioButton">
        <property name="text">
         <string>Surrounding background</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_0">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item row="1" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_1">
      <property name="spacing">
       <number>6</number>
      </property>
      <property name="margin">
       <number>0</number>
      </property>
      <item>
       <widget class="QRadioButton" name="checkBoardRadioButton">
        <property name="text">
         <string>&amp;Checkerboard background</string>
        </property>
        <property name="checked">
         <bool>false</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_1">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item row="2" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_2">
      <property name="spacing">
       <number>6</number>
      </property>
      <property name="margin">
       <number>0</number>
      </property>
      <item>
       <widget class="QRadioButton" name="solidColorRadioButton">
        <property name="text">
         <string>&amp;Solid color background:</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KColorButton" name="kcfg_AlphaBackgroundColor">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="text">
         <string/>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_2">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item row="3" column="1">
     <spacer name="verticalSpacer_1">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>207</width>
        <height>17</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="4" column="0">
     <widget class="QLabel" name="label_2">
      <property name="text">
       <string>Mouse wheel behavior:</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
      </property>
      <property name="buddy">
       <cstring>mouseWheelScrollRadioButton</cstring>
      </property>
     </widget>
    </item>
    <item row="4" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_3">
      <item>
       <widget class="QRadioButton" name="mouseWheelScrollRadioButton">
        <property name="text">
         <string comment="@option:radio action on mouse wheel">Scroll</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_3">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item row="5" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_4">
      <item>
       <widget class="QRadioButton" name="mouseWheelBrowseRadioButton">
        <property name="text">
         <string comment="@option:radio action on mouse wheel">Browse</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_4">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item row="6" column="1">
+    <layout class="QHBoxLayout" name="horizontalLayout_16">
+     <item>
+      <widget class="QRadioButton" name="mouseWheelZoomRadioButton">
+       <property name="text">
+        <string comment="@option:radio action on mouse wheel">Zoom</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer_16">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+   <item row="7" column="1">
     <spacer name="verticalSpacer_2">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>207</width>
        <height>17</height>
       </size>
      </property>
     </spacer>
    </item>
-   <item row="7" column="0">
+   <item row="8" column="0">
     <widget class="QLabel" name="label_3">
      <property name="text">
       <string>Zoom mode:</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
      </property>
      <property name="buddy">
       <cstring>autofitZoomModeRadioButton</cstring>
      </property>
     </widget>
    </item>
-   <item row="7" column="1">
+   <item row="8" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_5">
      <item>
       <widget class="QRadioButton" name="autofitZoomModeRadioButton">
        <property name="text">
         <string>Autofit each image</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_5">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="8" column="1">
+   <item row="9" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_6">
      <item>
       <widget class="QRadioButton" name="keepSameZoomModeRadioButton">
        <property name="text">
         <string>Keep same zoom and position</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_6">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="9" column="1">
+   <item row="10" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_7">
      <item>
       <widget class="QRadioButton" name="individualZoomModeRadioButton">
        <property name="text">
         <string>Per image zoom and position</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_7">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="10" column="1">
+   <item row="11" column="1">
     <spacer name="verticalSpacer_3">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>207</width>
        <height>17</height>
       </size>
      </property>
     </spacer>
    </item>
-   <item row="11" column="1">
+   <item row="12" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_8">
      <item>
       <widget class="QCheckBox" name="kcfg_EnlargeSmallerImages">
        <property name="text">
         <string>Enlarge smaller images</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_8">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="12" column="1">
+   <item row="13" column="1">
     <spacer name="verticalSpacer_4">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>204</width>
        <height>17</height>
       </size>
      </property>
     </spacer>
    </item>
-   <item row="13" column="0">
+   <item row="14" column="0">
     <widget class="QLabel" name="label_4">
      <property name="text">
       <string>Animations:</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
      </property>
      <property name="buddy">
       <cstring>glAnimationRadioButton</cstring>
      </property>
     </widget>
    </item>
-   <item row="13" column="1">
+   <item row="14" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_9">
      <item>
       <widget class="QRadioButton" name="glAnimationRadioButton">
        <property name="text">
         <string>OpenGL</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_9">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="14" column="1">
+   <item row="15" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_10">
      <item>
       <widget class="QRadioButton" name="softwareAnimationRadioButton">
        <property name="text">
         <string>Software</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_10">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="15" column="1">
+   <item row="16" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_11">
      <item>
       <widget class="QRadioButton" name="noAnimationRadioButton">
        <property name="text">
         <string>None</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_11">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="16" column="1">
+   <item row="17" column="1">
     <spacer name="verticalSpacer_5">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>204</width>
        <height>17</height>
       </size>
      </property>
     </spacer>
    </item>
-   <item row="17" column="0">
+   <item row="18" column="0">
     <widget class="QLabel" name="label_5">
      <property name="text">
       <string>&lt;b&gt;Thumbnail Bar&lt;/b&gt;</string>
      </property>
     </widget>
    </item>
-   <item row="18" column="1">
+   <item row="19" column="1">
     <spacer name="verticalSpacer_6">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>204</width>
        <height>12</height>
       </size>
      </property>
     </spacer>
    </item>
-   <item row="19" column="0">
+   <item row="20" column="0">
     <widget class="QLabel" name="label_6">
      <property name="text">
       <string>Orientation:</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
      </property>
      <property name="buddy">
       <cstring>horizontalRadioButton</cstring>
      </property>
     </widget>
    </item>
-   <item row="19" column="1">
+   <item row="20" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_12">
      <item>
       <widget class="QRadioButton" name="horizontalRadioButton">
        <property name="text">
         <string>Horizontal</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_12">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="20" column="1">
+   <item row="21" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_13">
      <item>
       <widget class="QRadioButton" name="verticalRadioButton">
        <property name="text">
         <string>Vertical</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_13">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="21" column="0">
+   <item row="22" column="0">
     <widget class="QLabel" name="label_7">
      <property name="text">
       <string>Row count:</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
      </property>
      <property name="buddy">
       <cstring>kcfg_ThumbnailBarRowCount</cstring>
      </property>
     </widget>
    </item>
-   <item row="21" column="1">
+   <item row="22" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout_14">
      <item>
       <widget class="QSpinBox" name="kcfg_ThumbnailBarRowCount">
        <property name="minimum">
         <number>1</number>
        </property>
        <property name="maximum">
         <number>10</number>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_14">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
-   <item row="22" column="1">
+   <item row="23" column="1">
     <spacer name="verticalSpacer_7">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>60</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KColorButton</class>
    <extends>QPushButton</extends>
    <header>kcolorbutton.h</header>
   </customwidget>
   <customwidget>
    <class>QSpinBox</class>
    <extends>QSpinBox</extends>
    <header>knuminput.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>checkBoardRadioButton</tabstop>
   <tabstop>solidColorRadioButton</tabstop>
   <tabstop>kcfg_AlphaBackgroundColor</tabstop>
   <tabstop>mouseWheelScrollRadioButton</tabstop>
   <tabstop>mouseWheelBrowseRadioButton</tabstop>
+  <tabstop>mouseWheelZoomRadioButton</tabstop>
   <tabstop>kcfg_EnlargeSmallerImages</tabstop>
   <tabstop>glAnimationRadioButton</tabstop>
   <tabstop>softwareAnimationRadioButton</tabstop>
   <tabstop>noAnimationRadioButton</tabstop>
   <tabstop>horizontalRadioButton</tabstop>
   <tabstop>verticalRadioButton</tabstop>
   <tabstop>kcfg_ThumbnailBarRowCount</tabstop>
  </tabstops>
  <resources/>
  <connections>
   <connection>
    <sender>solidColorRadioButton</sender>
    <signal>toggled(bool)</signal>
    <receiver>kcfg_AlphaBackgroundColor</receiver>
    <slot>setEnabled(bool)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>195</x>
      <y>49</y>
     </hint>
     <hint type="destinationlabel">
      <x>292</x>
      <y>56</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>
diff --git a/lib/documentview/documentview.cpp b/lib/documentview/documentview.cpp
index 9b822e07..2035df28 100644
--- a/lib/documentview/documentview.cpp
+++ b/lib/documentview/documentview.cpp
@@ -1,1018 +1,1022 @@
 // vim: set tabstop=4 shiftwidth=4 expandtab:
 /*
 Gwenview: an image viewer
 Copyright 2008 Aurélien Gâteau <agateau@kde.org>
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Cambridge, MA 02110-1301, USA.
 
 */
 // Self
 #include "documentview.h"
 
 // C++ Standard library
 #include <cmath>
 
 // Qt
 #include <QApplication>
 #include <QGraphicsLinearLayout>
 #include <QGraphicsProxyWidget>
 #include <QGraphicsScene>
 #include <QGraphicsSceneMouseEvent>
 #include <QGraphicsSceneWheelEvent>
 #include <QGraphicsOpacityEffect>
 #include <QGraphicsView>
 #include <QPainter>
 #include <QPropertyAnimation>
 #include <QPointer>
 #include <QDebug>
 #include <QIcon>
 #include <QUrl>
 #include <QDrag>
 #include <QMimeData>
 #include <QStyleHints>
 
 // KDE
 #include <KLocalizedString>
 #include <KFileItem>
 #include <KUrlMimeData>
 
 // Local
 #include <lib/document/document.h>
 #include <lib/document/documentfactory.h>
 #include <lib/documentview/abstractrasterimageviewtool.h>
 #include <lib/documentview/birdeyeview.h>
 #include <lib/documentview/loadingindicator.h>
 #include <lib/documentview/messageviewadapter.h>
 #include <lib/documentview/rasterimageview.h>
 #include <lib/documentview/rasterimageviewadapter.h>
 #include <lib/documentview/svgviewadapter.h>
 #include <lib/documentview/videoviewadapter.h>
 #include <lib/hud/hudbutton.h>
 #include <lib/hud/hudwidget.h>
 #include <lib/graphicswidgetfloater.h>
 #include <lib/gvdebug.h>
 #include <lib/gwenviewconfig.h>
 #include <lib/mimetypeutils.h>
 #include <lib/urlutils.h>
 #include <lib/thumbnailview/dragpixmapgenerator.h>
 #include <lib/thumbnailprovider/thumbnailprovider.h>
 
 namespace Gwenview
 {
 
 #undef ENABLE_LOG
 #undef LOG
 //#define ENABLE_LOG
 #ifdef ENABLE_LOG
 #define LOG(x) //qDebug() << x
 #else
 #define LOG(x) ;
 #endif
 
 static const qreal REAL_DELTA = 0.001;
 static const qreal MAXIMUM_ZOOM_VALUE = qreal(DocumentView::MaximumZoom);
 static const auto MINSTEP = sqrt(0.5);
 static const auto MAXSTEP = sqrt(2.0);
 
 static const int COMPARE_MARGIN = 4;
 
 const int DocumentView::MaximumZoom = 16;
 const int DocumentView::AnimDuration = 250;
 
 struct DocumentViewPrivate
 {
     DocumentView* q;
     int mSortKey; // Used to sort views when displayed in compare mode
     HudWidget* mHud;
     BirdEyeView* mBirdEyeView;
     QPointer<QPropertyAnimation> mMoveAnimation;
     QPointer<QPropertyAnimation> mFadeAnimation;
     QGraphicsOpacityEffect* mOpacityEffect;
 
     LoadingIndicator* mLoadingIndicator;
 
     QScopedPointer<AbstractDocumentViewAdapter> mAdapter;
     QList<qreal> mZoomSnapValues;
     Document::Ptr mDocument;
     DocumentView::Setup mSetup;
     bool mCurrent;
     bool mCompareMode;
     int controlWheelAccumulatedDelta;
 
     QPointF mDragStartPosition;
     QPointer<ThumbnailProvider> mDragThumbnailProvider;
     QPointer<QDrag> mDrag;
 
     void setCurrentAdapter(AbstractDocumentViewAdapter* adapter)
     {
         Q_ASSERT(adapter);
         mAdapter.reset(adapter);
 
         adapter->widget()->setParentItem(q);
         resizeAdapterWidget();
 
         if (adapter->canZoom()) {
             QObject::connect(adapter, SIGNAL(zoomChanged(qreal)),
                              q, SLOT(slotZoomChanged(qreal)));
             QObject::connect(adapter, SIGNAL(zoomInRequested(QPointF)),
                              q, SLOT(zoomIn(QPointF)));
             QObject::connect(adapter, SIGNAL(zoomOutRequested(QPointF)),
                              q, SLOT(zoomOut(QPointF)));
             QObject::connect(adapter, SIGNAL(zoomToFitChanged(bool)),
                              q, SIGNAL(zoomToFitChanged(bool)));
             QObject::connect(adapter, SIGNAL(zoomToFillChanged(bool)),
                              q, SIGNAL(zoomToFillChanged(bool)));
         }
         QObject::connect(adapter, SIGNAL(scrollPosChanged()),
                          q, SIGNAL(positionChanged()));
         QObject::connect(adapter, SIGNAL(previousImageRequested()),
                          q, SIGNAL(previousImageRequested()));
         QObject::connect(adapter, SIGNAL(nextImageRequested()),
                          q, SIGNAL(nextImageRequested()));
         QObject::connect(adapter, SIGNAL(toggleFullScreenRequested()),
                          q, SIGNAL(toggleFullScreenRequested()));
         QObject::connect(adapter, SIGNAL(completed()),
                          q, SLOT(slotCompleted()));
 
         adapter->loadConfig();
 
         adapter->widget()->installSceneEventFilter(q);
         if (mCurrent) {
             adapter->widget()->setFocus();
         }
 
         if (mSetup.valid && adapter->canZoom()) {
             adapter->setZoomToFit(mSetup.zoomToFit);
             adapter->setZoomToFill(mSetup.zoomToFill);
             if (!mSetup.zoomToFit && !mSetup.zoomToFill) {
                 adapter->setZoom(mSetup.zoom);
                 adapter->setScrollPos(mSetup.position);
             }
         }
         emit q->adapterChanged();
         emit q->positionChanged();
         if (adapter->canZoom()) {
             if (adapter->zoomToFit()) {
                 emit q->zoomToFitChanged(true);
             } else if (adapter->zoomToFill()) {
                 emit q->zoomToFillChanged(true);
             } else {
                 emit q->zoomChanged(adapter->zoom());
             }
         }
         if (adapter->rasterImageView()) {
             QObject::connect(adapter->rasterImageView(), SIGNAL(currentToolChanged(AbstractRasterImageViewTool*)),
                              q, SIGNAL(currentToolChanged(AbstractRasterImageViewTool*)));
         }
     }
 
     void setupLoadingIndicator()
     {
         mLoadingIndicator = new LoadingIndicator(q);
         GraphicsWidgetFloater* floater = new GraphicsWidgetFloater(q);
         floater->setChildWidget(mLoadingIndicator);
     }
 
     HudButton* createHudButton(const QString& text, const QString &iconName, bool showText)
     {
         HudButton* button = new HudButton;
         if (showText) {
             button->setText(text);
         } else {
             button->setToolTip(text);
         }
         button->setIcon(QIcon::fromTheme(iconName));
         return button;
     }
 
     void setupHud()
     {
         HudButton* trashButton = createHudButton(i18nc("@info:tooltip", "Trash"), QStringLiteral("user-trash"), false);
         HudButton* deselectButton = createHudButton(i18nc("@action:button", "Deselect"), QStringLiteral("list-remove"), true);
 
         QGraphicsWidget* content = new QGraphicsWidget;
         QGraphicsLinearLayout* layout = new QGraphicsLinearLayout(content);
         layout->addItem(trashButton);
         layout->addItem(deselectButton);
 
         mHud = new HudWidget(q);
         mHud->init(content, HudWidget::OptionNone);
         GraphicsWidgetFloater* floater = new GraphicsWidgetFloater(q);
         floater->setChildWidget(mHud);
         floater->setAlignment(Qt::AlignBottom | Qt::AlignHCenter);
 
         QObject::connect(trashButton, SIGNAL(clicked()), q, SLOT(emitHudTrashClicked()));
         QObject::connect(deselectButton, SIGNAL(clicked()), q, SLOT(emitHudDeselectClicked()));
 
         mHud->hide();
     }
 
     void setupBirdEyeView()
     {
         if (mBirdEyeView) {
             delete mBirdEyeView;
         }
         mBirdEyeView = new BirdEyeView(q);
         mBirdEyeView->setZValue(1);
     }
 
     void updateCaption()
     {
         if (!mCurrent) {
             return;
         }
         QString caption;
 
         Document::Ptr doc = mAdapter->document();
         if (!doc) {
             emit q->captionUpdateRequested(caption);
             return;
         }
 
         caption = doc->url().fileName();
         QSize size = doc->size();
         if (size.isValid()) {
             caption +=
                 QStringLiteral(" - %1x%2")
                 .arg(size.width())
                 .arg(size.height());
             if (mAdapter->canZoom()) {
                 int intZoom = qRound(mAdapter->zoom() * 100);
                 caption += QStringLiteral(" - %1%")
                            .arg(intZoom);
             }
         }
         emit q->captionUpdateRequested(caption);
     }
 
     void uncheckZoomToFit()
     {
         if (mAdapter->zoomToFit()) {
             mAdapter->setZoomToFit(false);
         }
     }
 
     void uncheckZoomToFill()
     {
         if (mAdapter->zoomToFill()) {
             mAdapter->setZoomToFill(false);
         }
     }
 
     void setZoom(qreal zoom, const QPointF& center = QPointF(-1, -1))
     {
         uncheckZoomToFit();
         uncheckZoomToFill();
         zoom = qBound(q->minimumZoom(), zoom, MAXIMUM_ZOOM_VALUE);
         mAdapter->setZoom(zoom, center);
     }
 
     void updateZoomSnapValues()
     {
         qreal min = q->minimumZoom();
 
         mZoomSnapValues.clear();
         for (qreal zoom = MINSTEP; zoom > min; zoom *= MINSTEP) {
             mZoomSnapValues << zoom;
         }
         mZoomSnapValues << min;
 
         std::reverse(mZoomSnapValues.begin(), mZoomSnapValues.end());
 
         for (qreal zoom = 1; zoom < MAXIMUM_ZOOM_VALUE; zoom *= MAXSTEP) {
             mZoomSnapValues << zoom;
         }
         mZoomSnapValues << MAXIMUM_ZOOM_VALUE;
 
         emit q->minimumZoomChanged(min);
     }
 
     void showLoadingIndicator()
     {
         if (!mLoadingIndicator) {
             setupLoadingIndicator();
         }
         mLoadingIndicator->show();
         mLoadingIndicator->setZValue(1);
     }
 
     void hideLoadingIndicator()
     {
         if (!mLoadingIndicator) {
             return;
         }
         mLoadingIndicator->hide();
     }
 
     void resizeAdapterWidget()
     {
         QRectF rect = QRectF(QPointF(0, 0), q->boundingRect().size());
         if (mCompareMode) {
             rect.adjust(COMPARE_MARGIN, COMPARE_MARGIN, -COMPARE_MARGIN, -COMPARE_MARGIN);
         }
         mAdapter->widget()->setGeometry(rect);
     }
 
     void fadeTo(qreal value)
     {
         if (mFadeAnimation.data()) {
             qreal endValue = mFadeAnimation.data()->endValue().toReal();
             if (qFuzzyCompare(value, endValue)) {
                 // Same end value, don't change the actual animation
                 return;
             }
         }
         // Create a new fade animation
         QPropertyAnimation* anim = new QPropertyAnimation(mOpacityEffect, "opacity");
         anim->setStartValue(mOpacityEffect->opacity());
         anim->setEndValue(value);
         if (qFuzzyCompare(value, 1)) {
             QObject::connect(anim, SIGNAL(finished()),
                             q, SLOT(slotFadeInFinished()));
         }
         QObject::connect(anim, SIGNAL(finished()), q, SIGNAL(isAnimatedChanged()));
         anim->setDuration(DocumentView::AnimDuration);
         mFadeAnimation = anim;
         emit q->isAnimatedChanged();
         anim->start(QAbstractAnimation::DeleteWhenStopped);
     }
 
     bool canPan() const
     {
         if (!q->canZoom()) {
             return false;
         }
 
         const QSize zoomedImageSize = mDocument->size() * q->zoom();
         const QSize viewPortSize = q->boundingRect().size().toSize();
         const bool imageWiderThanViewport = zoomedImageSize.width() > viewPortSize.width();
         const bool imageTallerThanViewport = zoomedImageSize.height() > viewPortSize.height();
         return (imageWiderThanViewport || imageTallerThanViewport);
     }
 
     void setDragPixmap(const QPixmap& pix)
     {
         if (mDrag) {
             DragPixmapGenerator::DragPixmap dragPixmap = DragPixmapGenerator::generate({pix}, 1);
             mDrag->setPixmap(dragPixmap.pix);
             mDrag->setHotSpot(dragPixmap.hotSpot);
         }
     }
 
     void executeDrag()
     {
         if (mDrag) {
             if (mAdapter->imageView()) {
                 mAdapter->imageView()->resetDragCursor();
             }
             mDrag->exec(Qt::MoveAction | Qt::CopyAction | Qt::LinkAction, Qt::CopyAction);
         }
     }
 
     void initDragThumbnailProvider() {
         mDragThumbnailProvider = new ThumbnailProvider();
         QObject::connect(mDragThumbnailProvider, &ThumbnailProvider::thumbnailLoaded,
                          q, &DocumentView::dragThumbnailLoaded);
         QObject::connect(mDragThumbnailProvider, &ThumbnailProvider::thumbnailLoadingFailed,
                          q, &DocumentView::dragThumbnailLoadingFailed);
     }
 
     void startDragIfSensible()
     {
         if (q->document()->loadingState() == Document::LoadingFailed) {
             return;
         }
 
         if (q->currentTool()) {
             return;
         }
 
         if (mDrag) {
             mDrag->deleteLater();
         }
         mDrag = new QDrag(q);
         const auto itemList = KFileItemList({q->document()->url()});
         mDrag->setMimeData(MimeTypeUtils::selectionMimeData(itemList, MimeTypeUtils::DropTarget));
 
         if (q->document()->isModified()) {
             setDragPixmap(QPixmap::fromImage(q->document()->image()));
             executeDrag();
         } else {
             // Drag is triggered on success or failure of thumbnail generation
             if (mDragThumbnailProvider.isNull()) {
                 initDragThumbnailProvider();
             }
             mDragThumbnailProvider->appendItems(itemList);
         }
     }
 
     QPointF cursorPosition() {
         const QGraphicsScene* sc = q->scene();
         if (sc) {
             const auto views = sc->views();
             for (const QGraphicsView* view : views) {
                 if (view->underMouse()) {
                     return q->mapFromScene(view->mapFromGlobal(QCursor::pos()));
                 }
             }
         }
         return QPointF(-1, -1);
     }
 };
 
 DocumentView::DocumentView(QGraphicsScene* scene)
 : d(new DocumentViewPrivate)
 {
     setFlag(ItemIsFocusable);
     setFlag(ItemIsSelectable);
     setFlag(ItemClipsChildrenToShape);
 
     d->q = this;
     d->mLoadingIndicator = nullptr;
     d->mBirdEyeView = nullptr;
     d->mCurrent = false;
     d->mCompareMode = false;
     d->controlWheelAccumulatedDelta = 0;
     d->mDragStartPosition = QPointF(0, 0);
     d->mDrag = nullptr;
 
     // We use an opacity effect instead of using the opacity property directly, because the latter operates at
     // the painter level, which means if you draw multiple layers in paint(), all layers get the specified
     // opacity, resulting in all layers being visible when 0 < opacity < 1.
     // QGraphicsEffects on the other hand, operate after all painting is done, therefore 'flattening' all layers.
     // This is important for fade effects, where we don't want any background layers visible during the fade.
     d->mOpacityEffect = new QGraphicsOpacityEffect(this);
     d->mOpacityEffect->setOpacity(0);
     setGraphicsEffect(d->mOpacityEffect);
 
     scene->addItem(this);
 
     d->setupHud();
     d->setCurrentAdapter(new EmptyAdapter);
 
     setAcceptDrops(true);
 
     connect(DocumentFactory::instance(), &DocumentFactory::documentChanged, this, [this]() {
         d->updateCaption();
     });
 }
 
 DocumentView::~DocumentView()
 {
     delete d->mDragThumbnailProvider;
     delete d->mDrag;
     delete d;
 }
 
 void DocumentView::createAdapterForDocument()
 {
     const MimeTypeUtils::Kind documentKind = d->mDocument->kind();
     if (d->mAdapter && documentKind == d->mAdapter->kind() && documentKind != MimeTypeUtils::KIND_UNKNOWN) {
         // Do not reuse for KIND_UNKNOWN: we may need to change the message
         LOG("Reusing current adapter");
         return;
     }
     AbstractDocumentViewAdapter* adapter = nullptr;
     switch (documentKind) {
     case MimeTypeUtils::KIND_RASTER_IMAGE:
         adapter = new RasterImageViewAdapter;
         break;
     case MimeTypeUtils::KIND_SVG_IMAGE:
         adapter = new SvgViewAdapter;
         break;
     case MimeTypeUtils::KIND_VIDEO:
         adapter = new VideoViewAdapter;
         connect(adapter, SIGNAL(videoFinished()),
                 SIGNAL(videoFinished()));
         break;
     case MimeTypeUtils::KIND_UNKNOWN:
         adapter = new MessageViewAdapter;
         static_cast<MessageViewAdapter*>(adapter)->setErrorMessage(i18n("Gwenview does not know how to display this kind of document"));
         break;
     default:
         qWarning() << "should not be called for documentKind=" << documentKind;
         adapter = new MessageViewAdapter;
         break;
     }
 
     d->setCurrentAdapter(adapter);
 }
 
 void DocumentView::openUrl(const QUrl &url, const DocumentView::Setup& setup)
 {
     if (d->mDocument) {
         if (url == d->mDocument->url()) {
             return;
         }
         disconnect(d->mDocument.data(), nullptr, this, nullptr);
     }
     d->mSetup = setup;
     d->mDocument = DocumentFactory::instance()->load(url);
     connect(d->mDocument.data(), SIGNAL(busyChanged(QUrl,bool)), SLOT(slotBusyChanged(QUrl,bool)));
     connect(d->mDocument.data(), &Document::modified, this, [this]() {
         d->updateZoomSnapValues();
     });
 
     if (d->mDocument->loadingState() < Document::KindDetermined) {
         MessageViewAdapter* messageViewAdapter = qobject_cast<MessageViewAdapter*>(d->mAdapter.data());
         if (messageViewAdapter) {
             messageViewAdapter->setInfoMessage(QString());
         }
         d->showLoadingIndicator();
         connect(d->mDocument.data(), SIGNAL(kindDetermined(QUrl)),
                 SLOT(finishOpenUrl()));
     } else {
         QMetaObject::invokeMethod(this, "finishOpenUrl", Qt::QueuedConnection);
     }
     d->setupBirdEyeView();
 }
 
 void DocumentView::finishOpenUrl()
 {
     disconnect(d->mDocument.data(), SIGNAL(kindDetermined(QUrl)),
                this, SLOT(finishOpenUrl()));
     GV_RETURN_IF_FAIL(d->mDocument->loadingState() >= Document::KindDetermined);
 
     if (d->mDocument->loadingState() == Document::LoadingFailed) {
         slotLoadingFailed();
         return;
     }
     createAdapterForDocument();
 
     connect(d->mDocument.data(), SIGNAL(loadingFailed(QUrl)),
             SLOT(slotLoadingFailed()));
     d->mAdapter->setDocument(d->mDocument);
     d->updateCaption();
 }
 
 void DocumentView::loadAdapterConfig()
 {
     d->mAdapter->loadConfig();
 }
 
 RasterImageView* DocumentView::imageView() const
 {
     return d->mAdapter->rasterImageView();
 }
 
 void DocumentView::slotCompleted()
 {
     d->hideLoadingIndicator();
     d->updateCaption();
     d->updateZoomSnapValues();
     if (!d->mAdapter->zoomToFit() || !d->mAdapter->zoomToFill()) {
         qreal min = minimumZoom();
         if (d->mAdapter->zoom() < min) {
             d->mAdapter->setZoom(min);
         }
     }
     emit completed();
 }
 
 DocumentView::Setup DocumentView::setup() const
 {
     Setup setup;
     if (d->mAdapter->canZoom()) {
         setup.valid = true;
         setup.zoomToFit = zoomToFit();
         setup.zoomToFill = zoomToFill();
         if (!setup.zoomToFit && !setup.zoomToFill) {
             setup.zoom = zoom();
             setup.position = position();
         }
     }
     return setup;
 }
 
 void DocumentView::slotLoadingFailed()
 {
     d->hideLoadingIndicator();
     MessageViewAdapter* adapter = new MessageViewAdapter;
     adapter->setDocument(d->mDocument);
     QString message = xi18n("Loading <filename>%1</filename> failed", d->mDocument->url().fileName());
     adapter->setErrorMessage(message, d->mDocument->errorString());
     d->setCurrentAdapter(adapter);
     emit completed();
 }
 
 bool DocumentView::canZoom() const
 {
     return d->mAdapter->canZoom();
 }
 
 void DocumentView::setZoomToFit(bool on)
 {
     if (on == d->mAdapter->zoomToFit()) {
         return;
     }
     d->mAdapter->setZoomToFit(on);
 }
 
 void DocumentView::toggleZoomToFit() {
     const bool zoomToFitOn = d->mAdapter->zoomToFit();
     d->mAdapter->setZoomToFit(!zoomToFitOn);
     if (zoomToFitOn) {
         d->setZoom(1., d->cursorPosition());
     }
 }
 
 void DocumentView::setZoomToFill(bool on)
 {
     if (on == d->mAdapter->zoomToFill()) {
         return;
     }
     d->mAdapter->setZoomToFill(on, d->cursorPosition());
 }
 
 void DocumentView::toggleZoomToFill() {
     const bool zoomToFillOn = d->mAdapter->zoomToFill();
     d->mAdapter->setZoomToFill(!zoomToFillOn, d->cursorPosition());
     if (zoomToFillOn) {
         d->setZoom(1., d->cursorPosition());
     }
 }
 
 bool DocumentView::zoomToFit() const
 {
     return d->mAdapter->zoomToFit();
 }
 
 bool DocumentView::zoomToFill() const
 {
     return d->mAdapter->zoomToFill();
 }
 
 void DocumentView::zoomActualSize()
 {
     d->uncheckZoomToFit();
     d->uncheckZoomToFill();
     d->mAdapter->setZoom(1., d->cursorPosition());
 }
 
 void DocumentView::zoomIn(QPointF center)
 {
     if (center == QPointF(-1, -1)) {
         center = d->cursorPosition();
     }
     qreal currentZoom = d->mAdapter->zoom();
 
     Q_FOREACH(qreal zoom, d->mZoomSnapValues) {
         if (zoom > currentZoom + REAL_DELTA) {
             d->setZoom(zoom, center);
             return;
         }
     }
 }
 
 void DocumentView::zoomOut(QPointF center)
 {
     if (center == QPointF(-1, -1)) {
         center = d->cursorPosition();
     }
     qreal currentZoom = d->mAdapter->zoom();
 
     QListIterator<qreal> it(d->mZoomSnapValues);
     it.toBack();
     while (it.hasPrevious()) {
         qreal zoom = it.previous();
         if (zoom < currentZoom - REAL_DELTA) {
             d->setZoom(zoom, center);
             return;
         }
     }
 }
 
 void DocumentView::slotZoomChanged(qreal zoom)
 {
     d->updateCaption();
     emit zoomChanged(zoom);
 }
 
 void DocumentView::setZoom(qreal zoom)
 {
     d->setZoom(zoom);
 }
 
 qreal DocumentView::zoom() const
 {
     return d->mAdapter->zoom();
 }
 
 void DocumentView::resizeEvent(QGraphicsSceneResizeEvent *event)
 {
     d->resizeAdapterWidget();
     d->updateZoomSnapValues();
     QGraphicsWidget::resizeEvent(event);
 }
 
 void DocumentView::mousePressEvent(QGraphicsSceneMouseEvent* event)
 {
     QGraphicsWidget::mousePressEvent(event);
 
     if (d->mAdapter->canZoom() && event->button() == Qt::MiddleButton) {
         if (event->modifiers() == Qt::NoModifier) {
             toggleZoomToFit();
         } else if (event->modifiers() == Qt::SHIFT) {
             toggleZoomToFill();
         }
     }
 }
 
 void DocumentView::wheelEvent(QGraphicsSceneWheelEvent* event)
 {
-    if (d->mAdapter->canZoom() && event->modifiers() & Qt::ControlModifier) {
-        d->controlWheelAccumulatedDelta += event->delta();
-        // Ctrl + wheel => zoom in or out
-        if (d->controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep) {
-            zoomIn(event->pos());
-            d->controlWheelAccumulatedDelta = 0;
-        } else if (d->controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep) {
-            zoomOut(event->pos());
-            d->controlWheelAccumulatedDelta = 0;
+    if (d->mAdapter->canZoom()) {
+        if ((event->modifiers() & Qt::ControlModifier) ||
+            (GwenviewConfig::mouseWheelBehavior() == MouseWheelBehavior::Zoom
+            && event->modifiers() == Qt::NoModifier)) {
+            d->controlWheelAccumulatedDelta += event->delta();
+            // Ctrl + wheel => zoom in or out
+            if (d->controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep) {
+                zoomIn(event->pos());
+                d->controlWheelAccumulatedDelta = 0;
+            } else if (d->controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep) {
+                zoomOut(event->pos());
+                d->controlWheelAccumulatedDelta = 0;
+            }
+            return;
         }
-        return;
     }
     if (GwenviewConfig::mouseWheelBehavior() == MouseWheelBehavior::Browse
         && event->modifiers() == Qt::NoModifier) {
         d->controlWheelAccumulatedDelta += event->delta();
         // Browse with mouse wheel
         if (d->controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep) {
             emit previousImageRequested();
             d->controlWheelAccumulatedDelta = 0;
         } else if (d->controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep) {
             emit nextImageRequested();
             d->controlWheelAccumulatedDelta = 0;
         }
         return;
     }
     // Scroll
     qreal dx = 0;
     // 16 = pixels for one line
     // 120: see QWheelEvent::delta() doc
     qreal dy = -qApp->wheelScrollLines() * 16 * event->delta() / 120;
     if (event->orientation() == Qt::Horizontal) {
         qSwap(dx, dy);
     }
     d->mAdapter->setScrollPos(d->mAdapter->scrollPos() + QPointF(dx, dy));
 }
 
 void DocumentView::contextMenuEvent(QGraphicsSceneContextMenuEvent* event)
 {
     // Filter out context menu if Ctrl is down to avoid showing it when
     // zooming out with Ctrl + Right button
     if (event->modifiers() != Qt::ControlModifier) {
         emit contextMenuRequested();
     }
 }
 
 void DocumentView::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
 {
     // Fill background manually, because setAutoFillBackground(true) fill with QPalette::Window,
     // but our palettes use QPalette::Base for the background color/texture
     painter->fillRect(rect(), palette().base());
 
     // Selection indicator/highlight
     if (d->mCompareMode && d->mCurrent) {
         painter->save();
         painter->setBrush(Qt::NoBrush);
         painter->setPen(QPen(palette().highlight().color(), 2));
         painter->setRenderHint(QPainter::Antialiasing);
         const QRectF visibleRectF = mapRectFromItem(d->mAdapter->widget(), d->mAdapter->visibleDocumentRect());
         // Round the point and size independently. This is different than calling toRect(),
         // and is necessary to keep consistent rects, otherwise the selection rect can be
         // drawn 1 pixel too big or small.
         const QRect visibleRect = QRect(visibleRectF.topLeft().toPoint(), visibleRectF.size().toSize());
         const QRect selectionRect = visibleRect.adjusted(-1, -1, 1, 1);
         painter->drawRoundedRect(selectionRect, 3, 3);
         painter->restore();
     }
 }
 
 void DocumentView::slotBusyChanged(const QUrl&, bool busy)
 {
     if (busy) {
         d->showLoadingIndicator();
     } else {
         d->hideLoadingIndicator();
     }
 }
 
 qreal DocumentView::minimumZoom() const
 {
     // There is no point zooming out less than zoomToFit, but make sure it does
     // not get too small either
     return qBound(qreal(0.001), d->mAdapter->computeZoomToFit(), qreal(1.));
 }
 
 void DocumentView::setCompareMode(bool compare)
 {
     d->mCompareMode = compare;
     if (compare) {
         d->mHud->show();
         d->mHud->setZValue(1);
     } else {
         d->mHud->hide();
     }
 }
 
 void DocumentView::setCurrent(bool value)
 {
     d->mCurrent = value;
     if (value) {
         d->mAdapter->widget()->setFocus();
         d->updateCaption();
     }
     update();
 }
 
 bool DocumentView::isCurrent() const
 {
     return d->mCurrent;
 }
 
 QPoint DocumentView::position() const
 {
     return d->mAdapter->scrollPos().toPoint();
 }
 
 void DocumentView::setPosition(const QPoint& pos)
 {
     d->mAdapter->setScrollPos(pos);
 }
 
 Document::Ptr DocumentView::document() const
 {
     return d->mDocument;
 }
 
 QUrl DocumentView::url() const
 {
     Document::Ptr doc = d->mDocument;
     return doc ? doc->url() : QUrl();
 }
 
 void DocumentView::emitHudDeselectClicked()
 {
     emit hudDeselectClicked(this);
 }
 
 void DocumentView::emitHudTrashClicked()
 {
     emit hudTrashClicked(this);
 }
 
 void DocumentView::emitFocused()
 {
     emit focused(this);
 }
 
 void DocumentView::setGeometry(const QRectF& rect)
 {
     QGraphicsWidget::setGeometry(rect);
     if (d->mBirdEyeView) {
         d->mBirdEyeView->slotZoomOrSizeChanged();
     }
 }
 
 void DocumentView::moveTo(const QRect& rect)
 {
     if (d->mMoveAnimation) {
         d->mMoveAnimation.data()->setEndValue(rect);
     } else {
         setGeometry(rect);
     }
 }
 
 void DocumentView::moveToAnimated(const QRect& rect)
 {
     QPropertyAnimation* anim = new QPropertyAnimation(this, "geometry");
     anim->setStartValue(geometry());
     anim->setEndValue(rect);
     anim->setDuration(DocumentView::AnimDuration);
     connect(anim, SIGNAL(finished()), SIGNAL(isAnimatedChanged()));
     d->mMoveAnimation = anim;
     emit isAnimatedChanged();
     anim->start(QAbstractAnimation::DeleteWhenStopped);
 }
 
 QPropertyAnimation* DocumentView::fadeIn()
 {
     d->fadeTo(1);
     return d->mFadeAnimation.data();
 }
 
 void DocumentView::fadeOut()
 {
     d->fadeTo(0);
 }
 
 void DocumentView::slotFadeInFinished()
 {
     emit fadeInFinished(this);
 }
 
 bool DocumentView::isAnimated() const
 {
     return d->mMoveAnimation || d->mFadeAnimation;
 }
 
 bool DocumentView::sceneEventFilter(QGraphicsItem*, QEvent* event)
 {
     if (event->type() == QEvent::GraphicsSceneMousePress) {
         const QGraphicsSceneMouseEvent* mouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event);
         if (mouseEvent->button() == Qt::LeftButton) {
             d->mDragStartPosition = mouseEvent->pos();
         }
         QMetaObject::invokeMethod(this, "emitFocused", Qt::QueuedConnection);
     } else if (event->type() == QEvent::GraphicsSceneHoverMove) {
         if (d->mBirdEyeView) {
             d->mBirdEyeView->onMouseMoved();
         }
     } else if (event->type() == QEvent::GraphicsSceneMouseMove) {
         const QGraphicsSceneMouseEvent* mouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event);
         const qreal dragDistance = (mouseEvent->pos() - d->mDragStartPosition).manhattanLength();
         const qreal minDistanceToStartDrag = QGuiApplication::styleHints()->startDragDistance();
         if (!d->canPan() && dragDistance >= minDistanceToStartDrag) {
             d->startDragIfSensible();
         }
     }
     return false;
 }
 
 AbstractRasterImageViewTool* DocumentView::currentTool() const
 {
     return imageView() ? imageView()->currentTool() : nullptr;
 }
 
 int DocumentView::sortKey() const
 {
     return d->mSortKey;
 }
 
 void DocumentView::setSortKey(int sortKey)
 {
     d->mSortKey = sortKey;
 }
 
 void DocumentView::hideAndDeleteLater()
 {
     hide();
     deleteLater();
 }
 
 void DocumentView::setGraphicsEffectOpacity(qreal opacity)
 {
     d->mOpacityEffect->setOpacity(opacity);
 }
 
 void DocumentView::dragEnterEvent(QGraphicsSceneDragDropEvent* event)
 {
     QGraphicsWidget::dragEnterEvent(event);
 
     const auto urls = KUrlMimeData::urlsFromMimeData(event->mimeData());
     bool acceptDrag = !urls.isEmpty();
     if (urls.size() == 1 && urls.first() == url()) {
         // Do not allow dragging a single image onto itself
         acceptDrag = false;
     }
     event->setAccepted(acceptDrag);
 }
 
 void DocumentView::dropEvent(QGraphicsSceneDragDropEvent* event)
 {
     QGraphicsWidget::dropEvent(event);
     // Since we're capturing drops in View mode, we only support one url
     const QUrl url = event->mimeData()->urls().first();
     if (UrlUtils::urlIsDirectory(url)) {
         emit openDirUrlRequested(url);
     } else {
         emit openUrlRequested(url);
     }
 }
 
 void DocumentView::dragThumbnailLoaded(const KFileItem& item, const QPixmap& pix)
 {
     d->setDragPixmap(pix);
     d->executeDrag();
     d->mDragThumbnailProvider->removeItems(KFileItemList({item}));
 }
 
 void DocumentView::dragThumbnailLoadingFailed(const KFileItem& item)
 {
     d->executeDrag();
     d->mDragThumbnailProvider->removeItems(KFileItemList({item}));
 }
 
 } // namespace
diff --git a/lib/gwenviewconfig.kcfg b/lib/gwenviewconfig.kcfg
index fbdddd85..89d23c76 100644
--- a/lib/gwenviewconfig.kcfg
+++ b/lib/gwenviewconfig.kcfg
@@ -1,341 +1,342 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE kcfg SYSTEM "http://www.kde.org/standards/kcfg/1.0/kcfg.dtd">
 <kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
                         http://www.kde.org/standards/kcfg/1.0/kcfg.xsd">
     <kcfgfile name="gwenviewrc"/>
     <include>lib/sorting.h</include>
     <include>lib/zoommode.h</include>
     <include>lib/thumbnailactions.h</include>
     <include>lib/mousewheelbehavior.h</include>
     <include>lib/documentview/documentview.h</include>
     <include>lib/documentview/rasterimageview.h</include>
     <include>lib/print/printoptionspage.h</include>
     <include>lib/renderingintent.h</include>
     <group name="SideBar">
         <entry name="PreferredMetaInfoKeyList" type="StringList">
         <default>General.Name,General.ImageSize,Exif.Photo.ExposureTime,Exif.Photo.Flash</default>
         </entry>
 
         <entry name="SideBarVisibleBrowseMode" key="IsVisible BrowseMode" type="Bool">
             <default>true</default>
         </entry>
         <entry name="SideBarVisibleViewMode" key="IsVisible ViewMode" type="Bool">
             <default>true</default>
         </entry>
         <entry name="SideBarVisibleViewModeFullScreen" key="IsVisible ViewMode FullScreen" type="Bool">
             <default>false</default>
         </entry>
 
         <entry name="SideBarSplitterSizes" type="IntList">
         </entry>
     </group>
 
     <group name="General">
         <entry name="ViewBackgroundValue" type="Int">
             <default>100</default>
         </entry>
 
         <entry name="HistoryEnabled" type="Bool">
             <default>true</default>
         </entry>
 
         <entry name="PercentageOfMemoryUsageWarning" type="Double">
             <default>0.5</default>
             <whatsthis>The percentage of memory used by Gwenview before it
             warns the user and suggest saving changes.</whatsthis>
         </entry>
 
         <entry name="BlackListedExtensions" type="StringList">
             <default>new</default>
             <whatsthis>A list of filename extensions Gwenview should not try to
             load. We exclude *.new as well because this is the extension
             used for temporary files by KSaveFile.</whatsthis>
         </entry>
         <entry name="ThumbnailBarIsVisible" type="Bool">
             <default>false</default>
         </entry>
 
         <entry name="LastTargetDir" type="Path">
         </entry>
 
         <entry name="ThumbnailBarOrientation" type="Enum">
             <choices name="Qt::Orientation">
                 <!-- Enum entries do not support enums with arbitrary values.
                 Since Qt::Horizontal is 1 and Qt::Vertical is 2, we need to
                 introduce a Dummy value here.
                 -->
                 <choice name="Dummy"/>
                 <choice name="Horizontal"/>
                 <choice name="Vertical"/>
             </choices>
             <default>Horizontal</default>
         </entry>
 
         <entry name="ThumbnailBarRowCount" type="Int">
             <default>1</default>
         </entry>
 
         <entry name="UrlNavigatorIsEditable" type="Bool">
             <default>false</default>
         </entry>
         <entry name="UrlNavigatorShowFullPath" type="Bool">
             <default>false</default>
         </entry>
 
         <entry name="DefaultExportPluginText" type="String">
         </entry>
 
         <entry name="SideBarPage" type="String">
             <default>information</default>
         </entry>
         
         <entry name="ThumbnailActions" type="Enum">
             <choices name="Gwenview::ThumbnailActions::Enum">
                 <choice name="ThumbnailActions::AllButtons"/>
                 <choice name="ThumbnailActions::ShowSelectionButtonOnly"/>
                 <choice name="ThumbnailActions::None"/>
             </choices>
             <default>ThumbnailActions::AllButtons</default>
         </entry>
     </group>
 
     <group name="FullScreen">
         <entry name="FullScreenPreferredMetaInfoKeyList" type="StringList">
             <default>General.Name,Exif.Image.DateTime</default>
         </entry>
         <entry name="FullScreenColorScheme" type="String">
             <default></default>
         </entry>
         <entry name="FullScreenBarHeight" type="Int">
             <default></default>
         </entry>
         <entry name="ShowFullScreenThumbnails" type="Bool">
             <default>true</default>
         </entry>
         <entry name="FullScreenModeActive" type="Bool">
             <default>false</default>
         </entry>
     </group>
 
     <group name="ImageView">
         <entry name="AlphaBackgroundMode" type="Enum">
             <choices name="Gwenview::AbstractImageView::AlphaBackgroundMode">
                 <choice name="AbstractImageView::AlphaBackgroundNone"/>
                 <choice name="AbstractImageView::AlphaBackgroundCheckBoard"/>
                 <choice name="AbstractImageView::AlphaBackgroundSolid"/>
             </choices>
             <default>AbstractImageView::AlphaBackgroundNone</default>
         </entry>
         <entry name="AlphaBackgroundColor" type="Color">
             <default>#ffffff</default>
         </entry>
 
         <entry name="MouseWheelBehavior" type="Enum">
             <choices name="Gwenview::MouseWheelBehavior::Enum">
                 <choice name="MouseWheelBehavior::Scroll"/>
                 <choice name="MouseWheelBehavior::Browse"/>
+                <choice name="MouseWheelBehavior::Zoom"/>
             </choices>
             <default>MouseWheelBehavior::Scroll</default>
         </entry>
 
         <entry name="EnlargeSmallerImages" type="Bool">
             <default>false</default>
         </entry>
 
         <entry name="ApplyExifOrientation" type="Bool">
             <default>true</default>
         </entry>
 
         <entry name="ThumbnailSplitterSizes" type="IntList">
             <default>350, 100</default>
         </entry>
 
         <entry name="AnimationMethod" type="Enum">
             <choices name="Gwenview::DocumentView::AnimationMethod">
                 <choice name="DocumentView::NoAnimation"/>
                 <choice name="DocumentView::SoftwareAnimation"/>
                 <choice name="DocumentView::GLAnimation"/>
             </choices>
             <default>DocumentView::SoftwareAnimation</default>
         </entry>
 
         <entry name="ZoomMode" type="Enum">
                 <choices name="Gwenview::ZoomMode::Enum">
                 <choice name="ZoomMode::Autofit"/>
                 <choice name="ZoomMode::KeepSame"/>
                 <choice name="ZoomMode::Individual"/>
             </choices>
             <default>ZoomMode::Autofit</default>
             <whatsthis>Defines what happens when going to image B after
             having zoomed in on an area of image A.  If set to Autofit,
             image B is zoomed out to fit the screen.  If set to KeepSame,
             all images share the same zoom and position: image B is set
             to the same zoom parameters as image A (and if these are
             changed, image A will then be displayed with the updated zoom
             and position).  If set to Individual, all images remember
             their own zoom and position: image B is initially set to the
             same zoom parameters as image A, but will then remember its
             own zoom and position (if these are changed, image A will NOT
             be displayed with the updated zoom and position).</whatsthis>
         </entry>
 
         <entry name="RenderingIntent" type="Enum">
                 <choices name="Gwenview::RenderingIntent::Enum">
                 <choice name="RenderingIntent::Perceptual"/>
                 <choice name="RenderingIntent::Relative"/>
             </choices>
             <default>RenderingIntent::Perceptual</default>
             <whatsthis>Defines how colors are rendered when your display
             uses an ICC color profile and an image has colors that do not
             fit within the profile's color gamut. "Perceptual" will scale
             the colors of the entire image so that they all fit within the
             display's capabilities. "Relative" will squash only the colors
             that cannot be displayed, and leave the other colors alone.</whatsthis>
         </entry>
     </group>
 
     <group name="ThumbnailView">
         <entry name="ThumbnailSize" type="Int">
             <default>128</default>
         </entry>
 
         <entry name="ThumbnailAspectRatio" type="Double">
         <default>3./2.</default>
         </entry>
 
         <entry name="DeleteThumbnailCacheOnExit" type="Bool">
             <default>false</default>
         </entry>
 
         <entry name="Sorting" type="Enum">
             <choices name="Gwenview::Sorting::Enum">
                 <choice name="Sorting::Name"/>
                 <choice name="Sorting::Size"/>
                 <choice name="Sorting::Date"/>
                 <choice name="Sorting::Rating"/>
             </choices>
             <default>Sorting::Name</default>
         </entry>
         
         <entry name="SortDescending" type="Bool">
             <default>false</default>
         </entry>
 
         <entry name="ThumbnailDetails" type="Int">
             <default>1</default>
             <!-- 1 == PreviewItemDelegate::FileNameDetail -->
         </entry>
 
         <entry name="ListVideos" type="Bool">
             <default>true</default>
         </entry>
     </group>
 
     <group name="Print">
         <entry name="PrintPosition" type="Int">
             <default code="true">
                 Qt::AlignHCenter | Qt::AlignVCenter
             </default>
         </entry>
 
         <entry name="PrintScaleMode" type="Enum">
             <choices name="Gwenview::PrintOptionsPage::ScaleMode">
                 <choice name="PrintOptionsPage::NoScale"/>
                 <choice name="PrintOptionsPage::ScaleToPage"/>
                 <choice name="PrintOptionsPage::ScaleToCustomSize"/>
             </choices>
             <default>PrintOptionsPage::ScaleToPage</default>
         </entry>
 
         <entry name="PrintEnlargeSmallerImages" type="Bool">
             <default>false</default>
         </entry>
 
         <entry name="PrintWidth" type="Double">
             <default>15.0</default>
         </entry>
 
         <entry name="PrintHeight" type="Double">
             <default>10.0</default>
             <!-- Default is in fact computed from PrintWidth because PrintKeepRatio is true -->
         </entry>
 
         <entry name="PrintUnit" type="Enum">
             <choices name="Gwenview::PrintOptionsPage::Unit">
                 <choice name="PrintOptionsPage::Millimeters"/>
                 <choice name="PrintOptionsPage::Centimeters"/>
                 <choice name="PrintOptionsPage::Inches"/>
             </choices>
             <default>PrintOptionsPage::Centimeters</default>
         </entry>
 
         <entry name="PrintKeepRatio" type="Bool">
             <default>true</default>
         </entry>
     </group>
 
     <group name="slide show">
         <entry name="random" type="Bool">
             <label>Display slide show images in random order</label>
             <default>false</default>
         </entry>
         <entry name="fullscreen" type="Bool">
             <label>Show slideshow in fullscreen mode</label>
             <default>true</default>
         </entry>
         <entry name="loop" type="Bool">
             <label>Loop on images</label>
             <default>false</default>
         </entry>
         <entry name="stopAtEnd" key="stop at end" type="Bool">
             <label>Stop at last image of folder</label>
             <default>false</default>
         </entry>
         <entry name="interval" type="Double">
             <label>Interval between images (in seconds)</label>
             <default>5.0</default>
         </entry>
     </group>
 
     <group name="RedEyeReduction">
         <entry name="RedEyeReductionDiameter" type="Int">
             <default>24</default>
         </entry>
     </group>
 
     <group name="Crop">
         <entry name="CropAdvancedSettingsEnabled" type="Bool">
             <default>false</default>
         </entry>
         <entry name="CropPreserveAspectRatio" type="Bool">
             <label>Restrict crop to image ratio when Advanced Settings disabled</label>
             <default>false</default>
         </entry>
         <entry name="CropRatioIndex" type="Int">
             <label>Index representing selected ratio in the Advanced settings combobox</label>
             <default>-1</default>
         </entry>
         <entry name="CropRatioWidth" type="Double">
             <label>Last used crop ratio width when Advanced Settings enabled</label>
             <default>0</default>
         </entry>
         <entry name="CropRatioHeight" type="Double">
             <label>Last used crop ratio height when Advanced Settings enabled</label>
             <default>0</default>
         </entry>
     </group>
 
     <group name="StatusBar">
         <entry name="StatusBarVisibleBrowseMode" key="IsVisible BrowseMode" type="Bool">
             <default>true</default>
         </entry>
         <entry name="StatusBarVisibleViewMode" key="IsVisible ViewMode" type="Bool">
             <default>true</default>
         </entry>
         <entry name="StatusBarVisibleViewModeFullScreen" key="IsVisible ViewMode FullScreen" type="Bool">
             <default>false</default>
         </entry>
     </group>
 </kcfg>
diff --git a/lib/mousewheelbehavior.h b/lib/mousewheelbehavior.h
index c91029a9..a359da48 100644
--- a/lib/mousewheelbehavior.h
+++ b/lib/mousewheelbehavior.h
@@ -1,44 +1,45 @@
 // vim: set tabstop=4 shiftwidth=4 expandtab:
 /*
 Gwenview: an image viewer
 Copyright 2010 Aurélien Gâteau <agateau@kde.org>
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Cambridge, MA 02110-1301, USA.
 
 */
 #ifndef MOUSEWHEELBEHAVIOR_H
 #define MOUSEWHEELBEHAVIOR_H
 
 // Qt
 
 // KDE
 
 // Local
 
 namespace Gwenview
 {
 
 namespace MouseWheelBehavior
 {
 enum Enum {
     Scroll,
-    Browse
+    Browse,
+    Zoom
 };
 
 } // namespace MouseWheelBehavior
 
 } // namespace Gwenview
 
 #endif /* MOUSEWHEELBEHAVIOR_H */