diff --git a/plugins/contextbrowser/browsemanager.cpp b/plugins/contextbrowser/browsemanager.cpp
index fef2c02fef..9501ae5234 100644
--- a/plugins/contextbrowser/browsemanager.cpp
+++ b/plugins/contextbrowser/browsemanager.cpp
@@ -1,333 +1,345 @@
 /*
   * This file is part of KDevelop
  *
  * Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library 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.
  */
 
 #include "browsemanager.h"
 #include <QMouseEvent>
 #include <QToolButton>
 #include <kdebug.h>
 #include <ktexteditor/view.h>
 #include <ktexteditor/document.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include "contextbrowserview.h"
 #include <interfaces/ilanguage.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/interfaces/ilanguagesupport.h>
 #include <language/editor/simplecursor.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 #include <ktexteditor/codecompletioninterface.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/forwarddeclaration.h>
 #include <qtimer.h>
 #include <qapplication.h>
 
 #include "contextbrowser.h"
 
 using namespace KDevelop;
 using namespace KTextEditor;
 
 EditorViewWatcher::EditorViewWatcher(QObject* parent)
     : QObject(parent)
 {
     connect(ICore::self()->documentController(), SIGNAL(textDocumentCreated(KDevelop::IDocument*)), this, SLOT(documentCreated(KDevelop::IDocument*)));
     foreach(KDevelop::IDocument* document, ICore::self()->documentController()->openDocuments())
         documentCreated(document);
 }
 
 void EditorViewWatcher::documentCreated( KDevelop::IDocument* document ) {
     KTextEditor::Document* textDocument = document->textDocument();
     if(textDocument) {
         connect(textDocument, SIGNAL(viewCreated(KTextEditor::Document*,KTextEditor::View*)), this, SLOT(viewCreated(KTextEditor::Document*,KTextEditor::View*)));
         foreach(KTextEditor::View* view, textDocument->views()) {
             Q_ASSERT(view->parentWidget());
             addViewInternal(view);
         }
     }
 }
 
 void EditorViewWatcher::addViewInternal(KTextEditor::View* view) {
     m_views << view;
     viewAdded(view);
     connect(view, SIGNAL(destroyed(QObject*)), this, SLOT(viewDestroyed(QObject*)));
 }
 
 void EditorViewWatcher::viewAdded(KTextEditor::View*) {
 }
 
 void EditorViewWatcher::viewDestroyed(QObject* view) {
     m_views.removeAll(static_cast<KTextEditor::View*>(view));
 }
 
 void EditorViewWatcher::viewCreated(KTextEditor::Document* /*doc*/, KTextEditor::View* view) {
     Q_ASSERT(view->parentWidget());
     addViewInternal(view);
 }
 
 QList<KTextEditor::View*> EditorViewWatcher::allViews() {
     return m_views;
 }
 
 void BrowseManager::eventuallyStartDelayedBrowsing() {
     if(m_browsingByKey && m_browingStartedInView)
         emit startDelayedBrowsing(m_browingStartedInView);
 }
 
 BrowseManager::BrowseManager(ContextBrowserPlugin* controller) : QObject(controller), m_plugin(controller), m_browsing(false), m_browsingByKey(0), m_watcher(this) {
     m_delayedBrowsingTimer = new QTimer(this);
     m_delayedBrowsingTimer->setSingleShot(true);
     
     connect(m_delayedBrowsingTimer, SIGNAL(timeout()), this, SLOT(eventuallyStartDelayedBrowsing()));
     
     foreach(KTextEditor::View* view, m_watcher.allViews())
         viewAdded(view);
 }
 
 KTextEditor::View* viewFromWidget(QWidget* widget) {
     if(!widget)
         return 0;
     KTextEditor::View* view = qobject_cast<KTextEditor::View*>(widget);
     if(view)
         return view;
     else
         return viewFromWidget(widget->parentWidget());
 }
 
 bool BrowseManager::eventFilter(QObject * watched, QEvent * event) {
     QWidget* widget = qobject_cast<QWidget*>(watched);
     Q_ASSERT(widget);
     KTextEditor::View* view = viewFromWidget(widget);
     if(!view)
         return false;
     
     QKeyEvent* keyEvent = dynamic_cast<QKeyEvent*>(event);
 
     const int browseKey = Qt::Key_Control;
     const int magicModifier = Qt::Key_Alt;
     
     //Eventually start key-browsing
     if(keyEvent && (keyEvent->key() == browseKey || keyEvent->key() == magicModifier) && !m_browsingByKey && keyEvent->type() == QEvent::KeyPress) {
         m_browsingByKey = keyEvent->key();
         
         if(keyEvent->key() == magicModifier) {
             if(dynamic_cast<KTextEditor::CodeCompletionInterface*>(view) && dynamic_cast<KTextEditor::CodeCompletionInterface*>(view)->isCompletionActive())
             {
                 //Do nothing, completion is active.
             }else{
                 m_delayedBrowsingTimer->start(300);
                 m_browingStartedInView = view;
             }
             
             if(magicModifier == Qt::Key_Alt) {
                 //ugly hack:
                 //If the magic modifier is ALT, we have to prevent it from being taken by the menu-bar to switch focus to it.
                 //This behavior depends on the style, but if the menu-bar receives any key-press in between, it doesn't do it.
                 //So we send a meaningless key-press here: The shift-key.
                 QEvent* pressEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_Shift, Qt::AltModifier);
                 QEvent* releaseEvent = new QKeyEvent(QEvent::KeyRelease, Qt::Key_Shift, Qt::AltModifier);
                 QApplication::postEvent(masterWidget(widget), pressEvent);
                 QApplication::postEvent(masterWidget(widget), releaseEvent);
             }
         }
         
         if(!m_browsing)
             m_plugin->setAllowBrowsing(true); 
         
     }
     
     QFocusEvent* focusEvent = dynamic_cast<QFocusEvent*>(event);
     
     //Eventually stop key-browsing
     if((keyEvent && m_browsingByKey && keyEvent->key() == m_browsingByKey && keyEvent->type() == QEvent::KeyRelease) || 
        (focusEvent && focusEvent->lostFocus())) {
         if(!m_browsing)
             m_plugin->setAllowBrowsing(false);
         m_browsingByKey = 0;
         emit stopDelayedBrowsing();
     }
-    
+
+    QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);
+
+    if(mouseEvent) {
+        if (mouseEvent->type() == QEvent::MouseButtonPress && mouseEvent->button() == Qt::XButton1) {
+            m_plugin->historyPrevious();
+            return true;
+        }
+        if (mouseEvent->type() == QEvent::MouseButtonPress && mouseEvent->button() == Qt::XButton2) {
+            m_plugin->historyNext();
+            return true;
+        }
+    }
+
     if(!m_browsing && !m_browsingByKey) {
         resetChangedCursor();
         return false;
     }
-    
-    QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);
+
     if(mouseEvent) {
         KTextEditor::CoordinatesToCursorInterface* iface = dynamic_cast<KTextEditor::CoordinatesToCursorInterface*>(view);
         if(!iface) {
             kDebug() << "Update kdelibs for the browsing-mode to work";
             return false;
         }
         
         QPoint coordinatesInView = widget->mapTo(view, mouseEvent->pos());
         
         KTextEditor::Cursor textCursor = iface->coordinatesToCursor(coordinatesInView);
         if(textCursor.isValid()) {
             ///@todo find out why this is needed, fix the code in kate
             if(textCursor.column() > 0)
                 textCursor.setColumn(textCursor.column()-1);
 
             KUrl viewUrl = view->document()->url();
             QList<ILanguage*> languages = ICore::self()->languageController()->languagesForUrl(viewUrl);
 
             QPair<KUrl, KDevelop::SimpleCursor> jumpTo;
 
             //Step 1: Look for a special language object(Macro, included header, etc.)
             foreach( ILanguage* language, languages) {
                 jumpTo = language->languageSupport()->specialLanguageObjectJumpCursor(viewUrl, SimpleCursor(textCursor));
                 if(jumpTo.first.isValid() && jumpTo.second.isValid())
                     break; //Found a special object to jump to
             }
 
             //Step 2: Look for a declaration/use
             if(!jumpTo.first.isValid() || !jumpTo.second.isValid()) {
                 Declaration* foundDeclaration = 0;
                 KDevelop::DUChainReadLocker lock( DUChain::lock() );
                 foundDeclaration = DUChainUtils::declarationForDefinition( DUChainUtils::itemUnderCursor(view->document()->url(), SimpleCursor(textCursor)) );
                 
                 if(foundDeclaration && foundDeclaration->url().toUrl().equals(view->document()->url()) && foundDeclaration->range().contains( foundDeclaration->transformToLocalRevision(SimpleCursor(textCursor)))) {
                     ///A declaration was clicked directly. Jumping to it is useless, so jump to the definition or something useful
 
                     bool foundBetter = false;
 
                     Declaration* definition = FunctionDefinition::definition(foundDeclaration);
                     if(definition) {
                         foundDeclaration = definition;
                         foundBetter = true;
                     }
                     ForwardDeclaration* forward = dynamic_cast<ForwardDeclaration*>(foundDeclaration);
                     if(forward) {
                         TopDUContext* standardContext = DUChainUtils::standardContextForUrl(view->document()->url());
                         if(standardContext) {
                             Declaration* resolved = forward->resolve(standardContext);
                             if(resolved) {
                                 foundDeclaration = resolved; //This probably won't work
                                 foundBetter = true;
                             }
                         }
                     }
                     //This will do a search without visibility-restriction, and that search will prefer non forward declarations
                     if(!foundBetter) {
                         Declaration* betterDecl = foundDeclaration->id().getDeclaration(0);
                         if(betterDecl) {
                             foundDeclaration = betterDecl;
                             foundBetter = true;
                         }
                     }
                 }
                 
                 if( foundDeclaration ) {
                     jumpTo.first = foundDeclaration->url().toUrl();
                     jumpTo.second = foundDeclaration->rangeInCurrentRevision().start;
                 }
             }
             if(jumpTo.first.isValid() && jumpTo.second.isValid()) {
                 if(mouseEvent->button() == Qt::LeftButton) {
                     if(mouseEvent->type() == QEvent::MouseButtonPress) {
                         m_buttonPressPosition = textCursor;
 //                         view->setCursorPosition(textCursor);
 //                         return false;
                     }else if(mouseEvent->type() == QEvent::MouseButtonRelease && textCursor == m_buttonPressPosition) {
                         ICore::self()->documentController()->openDocument(jumpTo.first, jumpTo.second.textCursor());
 //                         event->accept();
 //                         return true;
                     }
                 }else if(mouseEvent->type() == QEvent::MouseMove) {
                     //Make the cursor a "hand"
                     setHandCursor(widget);
                     return false;
                 }
             }
         }
         resetChangedCursor();
     }
     return false;
 }
 
 void BrowseManager::resetChangedCursor() {
     QMap<QPointer<QWidget>, QCursor> cursors = m_oldCursors;
     m_oldCursors.clear();
     
     for(QMap<QPointer<QWidget>, QCursor>::iterator it = cursors.begin(); it != cursors.end(); ++it)
         if(it.key())
             it.key()->setCursor(QCursor(Qt::IBeamCursor));
 }
 
 void BrowseManager::setHandCursor(QWidget* widget) {
     if(m_oldCursors.contains(widget))
         return; //Nothing to do
     m_oldCursors[widget] = widget->cursor();
     widget->setCursor(QCursor(Qt::PointingHandCursor));
 }
 
 void BrowseManager::applyEventFilter(QWidget* object, bool install) {
     if(install)
         object->installEventFilter(this);
     else
         object->removeEventFilter(this);
     
     foreach(QObject* child, object->children())
         if(qobject_cast<QWidget*>(child))
             applyEventFilter(qobject_cast<QWidget*>(child), install);
 }
 
 void BrowseManager::viewAdded(KTextEditor::View* view) {
     applyEventFilter(view, true);
     //We need to listen for cursorPositionChanged, to clear the shift-detector. The problem: Kate listens for the arrow-keys using shortcuts,
     //so those keys are not passed to the event-filter
 
     connect(view, SIGNAL(navigateLeft()), m_plugin, SLOT(navigateLeft()));
     connect(view, SIGNAL(navigateRight()), m_plugin, SLOT(navigateRight()));
     connect(view, SIGNAL(navigateUp()), m_plugin, SLOT(navigateUp()));
     connect(view, SIGNAL(navigateDown()), m_plugin, SLOT(navigateDown()));
     connect(view, SIGNAL(navigateAccept()), m_plugin, SLOT(navigateAccept()));
     connect(view, SIGNAL(navigateBack()), m_plugin, SLOT(navigateBack()));
 }
 
 void BrowseManager::Watcher::viewAdded(KTextEditor::View* view) {
     m_manager->viewAdded(view);
 }
 
 void BrowseManager::setBrowsing(bool enabled) {
     if(m_browsingByKey)
         return;
     if(enabled == m_browsing)
         return;
     m_browsing = enabled;
     
     //This collects all the views
     if(enabled) {
         kDebug() << "Enabled browsing-mode";
     }else{
         kDebug() << "Disabled browsing-mode";
         resetChangedCursor();
     }
 }
 
 BrowseManager::Watcher::Watcher(BrowseManager* manager)
     : EditorViewWatcher(manager), m_manager(manager) {
     foreach(KTextEditor::View* view, allViews())
         m_manager->applyEventFilter(view, true);
 }
 
 
diff --git a/plugins/contextbrowser/contextbrowser.h b/plugins/contextbrowser/contextbrowser.h
index 0c065a3b54..7a719ce0b8 100644
--- a/plugins/contextbrowser/contextbrowser.h
+++ b/plugins/contextbrowser/contextbrowser.h
@@ -1,261 +1,262 @@
 
 /*
  * This file is part of KDevelop
  *
  * Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library 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.
  */
 
 #ifndef KDEVPLATFORM_PLUGIN_CONTEXTBROWSERPLUGIN_H
 #define KDEVPLATFORM_PLUGIN_CONTEXTBROWSERPLUGIN_H
 
 #include <QVariant>
 #include <QSet>
 #include <QMap>
 #include <QList>
 
 #include <KUrl>
 
 #include <interfaces/iplugin.h>
 #include <language/duchain/duchainpointer.h>
 #include <language/editor/simplecursor.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/indexedducontext.h>
 #include <language/editor/persistentmovingrange.h>
 #include <language/interfaces/iquickopen.h>
 #include <language/editor/documentcursor.h>
 
 #include <language/interfaces/icontextbrowser.h>
 
 class QHBoxLayout;
 class QMenu;
 class QToolButton;
 
 namespace Sublime {
   class MainWindow;
 }
 
 namespace KDevelop {
   class IDocument;
   class ILanguage;
   class ParseJob;
   class DUContext;
   class TopDUContext;
   class DUChainBase;
   class AbstractNavigationWidget;
 }
 
 namespace KTextEditor {
   class Document;
   class View;
 }
 
 class ContextBrowserViewFactory;
 class ContextBrowserView;
 class BrowseManager;
 
 QWidget* masterWidget(QWidget* w);
 
 struct ViewHighlights
 {
   ViewHighlights() : keep(false) {
   }
   // Whether the same highlighting should be kept highlighted (usually during typing)
   bool keep;
   // The declaration that is highlighted for this view
   KDevelop::IndexedDeclaration declaration;
   // Highlighted ranges. Those may also be contained by different views.
   QList<KDevelop::PersistentMovingRange::Ptr> highlights;
 };
 
 class ContextBrowserPlugin : public KDevelop::IPlugin, public KDevelop::IContextBrowser
 {
     Q_OBJECT
     Q_INTERFACES( KDevelop::IContextBrowser )
   public:
     ContextBrowserPlugin(QObject *parent, const QVariantList & = QVariantList() );
     virtual ~ContextBrowserPlugin();
 
     virtual void unload();
 
     void registerToolView(ContextBrowserView* view);
     void unRegisterToolView(ContextBrowserView* view);
     
     virtual KDevelop::ContextMenuExtension contextMenuExtension(KDevelop::Context*);
 
     virtual KXMLGUIClient* createGUIForMainWindow( Sublime::MainWindow* window );
 
     ///duchain must be locked
     ///@param force When this is true, the history-entry is added, no matter whether the context is "interesting" or not
     void updateHistory(KDevelop::DUContext* context, const KDevelop::SimpleCursor& cursorPosition,
                        bool force = false);
 
     void updateDeclarationListBox(KDevelop::DUContext* context);
     void setAllowBrowsing(bool allow);
 
     virtual void showUses(const KDevelop::DeclarationPointer& declaration);
 
   public Q_SLOTS:
     void showUsesDelayed(const KDevelop::DeclarationPointer& declaration);
     void previousContextShortcut();
     void nextContextShortcut();
     
     void startDelayedBrowsing(KTextEditor::View* view);
     void stopDelayedBrowsing();
     
     void previousUseShortcut();
     void nextUseShortcut();
 
     void declarationSelectedInUI(const KDevelop::DeclarationPointer& decl);
 
     void parseJobFinished(KDevelop::ParseJob* job);
     void textDocumentCreated( KDevelop::IDocument* document );
     void documentActivated( KDevelop::IDocument* );
     void viewDestroyed( QObject* obj );
     void cursorPositionChanged( KTextEditor::View* view, const KTextEditor::Cursor& newPosition );
     void viewCreated( KTextEditor::Document* , KTextEditor::View* );
     void updateViews();
 
     void textHintRequested(const KTextEditor::Cursor&, QString&);
 
     void hideToolTip();
     void findUses();
     
     void textInserted(KTextEditor::Document*, KTextEditor::Range);
     void selectionChanged(KTextEditor::View*);
 
+    void historyNext();
+    void historyPrevious();
+
   private slots:
     // history browsing
     void documentJumpPerformed( KDevelop::IDocument* newDocument,
                                 const KTextEditor::Cursor& newCursor,
                                 KDevelop::IDocument* previousDocument,
                                 const KTextEditor::Cursor& previousCursor);
 
-    void historyNext();
-    void historyPrevious();
     void nextMenuAboutToShow();
     void previousMenuAboutToShow();
     void actionTriggered();
 
     void navigateLeft();
     void navigateRight();
     void navigateUp();
     void navigateDown();
     void navigateAccept();
     void navigateBack();
 
   private:
     QWidget* toolbarWidgetForMainWindow(Sublime::MainWindow* window);
     virtual void createActionsForMainWindow(Sublime::MainWindow* window, QString& xmlFile,
                                             KActionCollection& actions);
     void switchUse(bool forward);
     void clearMouseHover();
 
     void addHighlight( KTextEditor::View* view, KDevelop::Declaration* decl );
 
     /** helper for updateBrowserView().
      *  Tries to find a 'specialLanguageObject' (eg macro) in @p view under cursor @c.
      *  If found returns true and sets @p pickedLanguage to the language this object belongs to */
     KDevelop::Declaration* findDeclaration(KTextEditor::View* view, const KDevelop::SimpleCursor&, bool mouseHighlight);
     void updateForView(KTextEditor::View* view);
 
     // history browsing
     bool isPreviousEntry(KDevelop::DUContext*, const KDevelop::SimpleCursor& cursor) const;
     QString actionTextFor(int historyIndex) const;
     void updateButtonState();
     void openDocument(int historyIndex);
     void fillHistoryPopup(QMenu* menu, const QList<int>& historyIndices);
 
     enum NavigationActionType {
       Accept,
       Back,
       Down,
       Up,
       Left,
       Right
     };
     void doNavigate(NavigationActionType action);
 
   private:
     
     // Returns the currently active and visible context browser view that belongs
     // to the same context (mainwindow and area) as the given widget
     ContextBrowserView* browserViewForWidget(QWidget* widget);
     
     void showToolTip(KTextEditor::View* view, KTextEditor::Cursor position);
     QTimer* m_updateTimer;
     
     //Contains the range, the old attribute, and the attribute it was replaced with
     QSet<KTextEditor::View*> m_updateViews;
     QMap<KTextEditor::View*, ViewHighlights > m_highlightedRanges;
 
     //Holds a list of all active context browser tool views
     QList<ContextBrowserView*> m_views;
 
     //Used to override the next declaration that will be highlighted
     KDevelop::IndexedDeclaration m_useDeclaration;
     KDevelop::IndexedDeclaration m_lastHighlightedDeclaration;
 
     KUrl m_mouseHoverDocument;
     KDevelop::SimpleCursor m_mouseHoverCursor;
     ContextBrowserViewFactory* m_viewFactory;
     QPointer<QWidget> m_currentToolTip;
     QPointer<QWidget> m_currentNavigationWidget;
     KDevelop::IndexedDeclaration m_currentToolTipDeclaration;
     QAction* m_findUses;
     
     QPointer<KTextEditor::Document> m_lastInsertionDocument;
     KTextEditor::Cursor m_lastInsertionPos;
 
     // outline toolbar
     QPointer<KDevelop::IQuickOpenLine> m_outlineLine;
     QPointer<QHBoxLayout> m_toolbarWidgetLayout;
     QPointer<QWidget> m_toolbarWidget;
 
     // history browsing
     struct HistoryEntry {
         //Duchain must be locked
         HistoryEntry(KDevelop::IndexedDUContext ctx = KDevelop::IndexedDUContext(), const KDevelop::SimpleCursor& cursorPosition = KDevelop::SimpleCursor());
         HistoryEntry(KDevelop::DocumentCursor pos);
         //Duchain must be locked
         void setCursorPosition(const KDevelop::SimpleCursor& cursorPosition);
 
         //Duchain does not need to be locked
         KDevelop::DocumentCursor computePosition() const;
 
         KDevelop::IndexedDUContext context;
         KDevelop::DocumentCursor absoluteCursorPosition;
         KDevelop::SimpleCursor relativeCursorPosition; //Cursor position relative to the start line of the context
         QString alternativeString;
     };
 
     QVector<HistoryEntry> m_history;
     QPointer<QToolButton> m_previousButton;
     QPointer<QToolButton> m_nextButton;
     QPointer<QMenu> m_previousMenu, m_nextMenu;
     QPointer<QToolButton> m_browseButton;
     QList<KDevelop::IndexedDeclaration> m_listDeclarations;
     KDevelop::IndexedString m_listUrl;
     BrowseManager* m_browseManager;
     //Used to not record jumps triggered by the context-browser as history entries
     QPointer<QWidget> m_focusBackWidget;
     int m_nextHistoryIndex;
 };
 
 #endif // KDEVPLATFORM_PLUGIN_CONTEXTBROWSERPLUGIN_H
 
 // kate: space-indent on; indent-width 2; tab-width 4; replace-tabs on; auto-insert-doxygen on