diff --git a/debugger/variable/variablecollection.cpp b/debugger/variable/variablecollection.cpp
index cc1f88bde..165507fb4 100644
--- a/debugger/variable/variablecollection.cpp
+++ b/debugger/variable/variablecollection.cpp
@@ -1,547 +1,552 @@
 /*
  * KDevelop Debugger Support
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2008 Vladimir Prus <ghost@cs.msu.su>
  * Copyright 2009 Niko Sams <niko.sams@gmail.com>
  *
  * 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.
  */
 
 #include "variablecollection.h"
 
 #include <QFont>
 #include <QApplication>
 
 #include <KColorScheme>
 #include <KLocalizedString>
 #include <KTextEditor/TextHintInterface>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 #include "../../interfaces/icore.h"
 #include "../../interfaces/idocumentcontroller.h"
 #include "../../interfaces/iuicontroller.h"
 #include "../../sublime/controller.h"
 #include "../../sublime/view.h"
 #include "../../interfaces/idebugcontroller.h"
 #include "../interfaces/idebugsession.h"
 #include "../interfaces/ivariablecontroller.h"
 #include <debug.h>
 #include "util/texteditorhelpers.h"
 #include "variabletooltip.h"
 #include <sublime/area.h>
 
 namespace KDevelop {
 
 IDebugSession* currentSession()
 {
     return ICore::self()->debugController()->currentSession();
 }
 
 IDebugSession::DebuggerState currentSessionState()
 {
     if (!currentSession()) return IDebugSession::NotStartedState;
     return currentSession()->state();
 }
 
 bool hasStartedSession()
 {
     IDebugSession::DebuggerState s = currentSessionState();
     return s != IDebugSession::NotStartedState && s != IDebugSession::EndedState;
 }
 
 Variable::Variable(TreeModel* model, TreeItem* parent,
                    const QString& expression,
                    const QString& display)
   : TreeItem(model, parent)
   , m_expression(expression)
   , m_inScope(true)
   , m_topLevel(true)
   , m_changed(false)
   , m_showError(false)
   , m_format(Natural)
 {
     // FIXME: should not duplicate the data, instead overload 'data'
     // and return expression_ directly.
     if (display.isEmpty())
         setData(QVector<QVariant>() << expression << QString() << QString());
     else
         setData(QVector<QVariant>() << display << QString() << QString());
 }
 
 QString Variable::expression() const
 {
     return m_expression;
 }
 
 bool Variable::inScope() const
 {
     return m_inScope;
 }
 
 void Variable::setValue(const QString& v)
 {
     itemData[VariableCollection::ValueColumn] = v;
     reportChange();
 }
 
 QString Variable::value() const
 {
     return itemData[VariableCollection::ValueColumn].toString();
 }
 
 void Variable::setType(const QString& type)
 {
     itemData[VariableCollection::TypeColumn] = type;
     reportChange();
 }
 
 QString Variable::type() const
 {
     return itemData[VariableCollection::TypeColumn].toString();
 }
 
 void Variable::setTopLevel(bool v)
 {
     m_topLevel = v;
 }
 
 void Variable::setInScope(bool v)
 {
     m_inScope = v;
     for (int i=0; i < childCount(); ++i) {
         if (Variable *var = qobject_cast<Variable*>(child(i))) {
             var->setInScope(v);
         }
     }
     reportChange();
 }
 
 void Variable::setShowError (bool v)
 {
     m_showError = v;
     reportChange();
 }
 
 bool Variable::showError()
 {
     return m_showError;
 }
 
 
 Variable::~Variable()
 {
 }
 
 void Variable::die()
 {
     removeSelf();
     deleteLater();
 }
 
 
 void Variable::setChanged(bool c)
 {
     m_changed=c;
     reportChange();
 }
 
 void Variable::resetChanged()
 {
     setChanged(false);
     for (int i=0; i<childCount(); ++i) {
         TreeItem* childItem = child(i);
         if (qobject_cast<Variable*>(childItem)) {
             static_cast<Variable*>(childItem)->resetChanged();
         }
     }
 }
 
 Variable::format_t Variable::str2format(const QString& str)
 {
     if(str==QLatin1String("Binary") || str==QLatin1String("binary"))          return Binary;
     if(str==QLatin1String("Octal") || str==QLatin1String("octal"))            return Octal;
     if(str==QLatin1String("Decimal") || str==QLatin1String("decimal"))        return Decimal;
     if(str==QLatin1String("Hexadecimal") || str==QLatin1String("hexadecimal"))return Hexadecimal;
 
     return Natural; // maybe most reasonable default
 }
 
 QString Variable::format2str(format_t format)
 {
     switch(format) {
         case Natural:       return QStringLiteral("natural");
         case Binary:        return QStringLiteral("binary");
         case Octal:         return QStringLiteral("octal");
         case Decimal:       return QStringLiteral("decimal");
         case Hexadecimal:   return QStringLiteral("hexadecimal");
         default:            return QString();
     }
 }
 
 
 void Variable::setFormat(Variable::format_t format)
 {
     if (m_format != format) {
         m_format = format;
         formatChanged();
     }
 }
 
 void Variable::formatChanged()
 {
 }
 
 bool Variable::isPotentialProblematicValue() const
 {
     const auto value = data(VariableCollection::ValueColumn, Qt::DisplayRole).toString();
     return value == QLatin1String("0x0");
 }
 
 QVariant Variable::data(int column, int role) const
 {
     if (m_showError) {
         if (role == Qt::FontRole) {
             QVariant ret = TreeItem::data(column, role);
             QFont font = ret.value<QFont>();
             font.setStyle(QFont::StyleItalic);
             return font;
         } else if (column == 1 && role == Qt::DisplayRole) {
             return i18n("Error");
         }
     }
     if (column == 1 && role == Qt::TextColorRole)
     {
         KColorScheme scheme(QPalette::Active);
         if (!m_inScope) {
             return scheme.foreground(KColorScheme::InactiveText).color();
         } else if (isPotentialProblematicValue()) {
             return scheme.foreground(KColorScheme::NegativeText).color();
         } else if (m_changed) {
             return scheme.foreground(KColorScheme::NeutralText).color();
         }
     }
     if (role == Qt::ToolTipRole) {
         return TreeItem::data(column, Qt::DisplayRole);
     }
 
     return TreeItem::data(column, role);
 }
 
 Watches::Watches(TreeModel* model, TreeItem* parent)
 : TreeItem(model, parent), finishResult_(nullptr)
 {
     setData(QVector<QVariant>() << i18n("Auto") << QString());
 }
 
 Variable* Watches::add(const QString& expression)
 {
     if (!hasStartedSession()) return nullptr;
 
     Variable* v = currentSession()->variableController()->createVariable(
         model(), this, expression);
     appendChild(v);
     v->attachMaybe();
     if (childCount() == 1 && !isExpanded()) {
         setExpanded(true);
     }
     return v;
 }
 
 Variable *Watches::addFinishResult(const QString& convenienceVarible)
 {
     if( finishResult_ )
     {
         removeFinishResult();
     }
     finishResult_ = currentSession()->variableController()->createVariable(
         model(), this, convenienceVarible, QStringLiteral("$ret"));
     appendChild(finishResult_);
     finishResult_->attachMaybe();
     if (childCount() == 1 && !isExpanded()) {
         setExpanded(true);
     }
     return finishResult_;
 }
 
 void Watches::removeFinishResult()
 {
     if (finishResult_)
     {
         finishResult_->die();
         finishResult_ = nullptr;
     }
 }
 
 void Watches::resetChanged()
 {
     for (int i=0; i<childCount(); ++i) {
         TreeItem* childItem = child(i);
         if (qobject_cast<Variable*>(childItem)) {
             static_cast<Variable*>(childItem)->resetChanged();
         }
     }
 }
 
 QVariant Watches::data(int column, int role) const
 {
 #if 0
     if (column == 0 && role == Qt::FontRole)
     {
         /* FIXME: is creating font again and agian efficient? */
         QFont f = font();
         f.setBold(true);
         return f;
     }
 #endif
     return TreeItem::data(column, role);
 }
 
 void Watches::reinstall()
 {
     for (int i = 0; i < childItems.size(); ++i)
     {
         Variable* v = static_cast<Variable*>(child(i));
         v->attachMaybe();
     }
 }
 
 Locals::Locals(TreeModel* model, TreeItem* parent, const QString &name)
 : TreeItem(model, parent)
 {
     setData(QVector<QVariant>() << name << QString());
 }
 
 QList<Variable*> Locals::updateLocals(QStringList locals)
 {
     QSet<QString> existing, current;
     for (int i = 0; i < childItems.size(); i++)
     {
         Q_ASSERT(qobject_cast<KDevelop::Variable*>(child(i)));
         Variable* var= static_cast<KDevelop::Variable*>(child(i));
         existing << var->expression();
     }
 
     foreach (const QString& var, locals) {
         current << var;
         // If we currently don't display this local var, add it.
         if( !existing.contains( var ) ) {
             // FIXME: passing variableCollection this way is awkward.
             // In future, variableCollection probably should get a
             // method to create variable.
             Variable* v =
                 currentSession()->variableController()->createVariable(
                     ICore::self()->debugController()->variableCollection(),
                     this, var );
             appendChild( v, false );
         }
     }
 
     for (int i = 0; i < childItems.size(); ++i) {
         KDevelop::Variable* v = static_cast<KDevelop::Variable*>(child(i));
         if (!current.contains(v->expression())) {
             removeChild(i);
             --i;
             // FIXME: check that -var-delete is sent.
             delete v;
         }
     }
 
 
     if (hasMore()) {
         setHasMore(false);
     }
 
     // Variables which changed just value are updated by a call to -var-update.
     // Variables that changed type -- likewise.
 
     QList<Variable*> ret;
     foreach (TreeItem *i, childItems) {
         Q_ASSERT(qobject_cast<Variable*>(i));
         ret << static_cast<Variable*>(i);
     }
     return ret;
 }
 
 void Locals::resetChanged()
 {
     for (int i=0; i<childCount(); ++i) {
         TreeItem* childItem = child(i);
         if (qobject_cast<Variable*>(childItem)) {
             static_cast<Variable*>(childItem)->resetChanged();
         }
     }
 }
 
 VariablesRoot::VariablesRoot(TreeModel* model)
     : TreeItem(model)
     , m_watches(new Watches(model, this))
 {
     appendChild(m_watches, true);
 }
 
 
 Locals* VariablesRoot::locals(const QString& name)
 {
     if (!m_locals.contains(name)) {
         m_locals[name] = new Locals(model(), this, name);
         appendChild(m_locals[name]);
     }
     return m_locals[name];
 }
 
 QHash<QString, Locals*> VariablesRoot::allLocals() const
 {
     return m_locals;
 }
 
 void VariablesRoot::resetChanged()
 {
     m_watches->resetChanged();
     foreach (Locals *l, m_locals) {
         l->resetChanged();
     }
 }
 
 VariableCollection::VariableCollection(IDebugController* controller)
     : TreeModel({i18n("Name"), i18n("Value"), i18n("Type")}, controller)
     , m_widgetVisible(false)
     , m_textHintProvider(this)
 {
     m_universe = new VariablesRoot(this);
     setRootItem(m_universe);
 
     //new ModelTest(this);
 
     connect (ICore::self()->documentController(),
          &IDocumentController::textDocumentCreated,
          this,
          &VariableCollection::textDocumentCreated );
 
     connect(controller, &IDebugController::currentSessionChanged,
              this, &VariableCollection::updateAutoUpdate);
 
     // Qt5 signal slot syntax does not support default arguments
     auto callUpdateAutoUpdate = [&] { updateAutoUpdate(); };
 
     connect(locals(), &Locals::expanded, this, callUpdateAutoUpdate);
     connect(locals(), &Locals::collapsed, this, callUpdateAutoUpdate);
     connect(watches(), &Watches::expanded, this, callUpdateAutoUpdate);
     connect(watches(), &Watches::collapsed, this, callUpdateAutoUpdate);
 }
 
 void VariableCollection::variableWidgetHidden()
 {
     m_widgetVisible = false;
     updateAutoUpdate();
 }
 
 void VariableCollection::variableWidgetShown()
 {
     m_widgetVisible = true;
     updateAutoUpdate();
 }
 
 void VariableCollection::updateAutoUpdate(IDebugSession* session)
 {
     if (!session) session = currentSession();
     qCDebug(DEBUGGER) << session;
     if (!session) return;
 
     if (!m_widgetVisible) {
         session->variableController()->setAutoUpdate(IVariableController::UpdateNone);
     } else {
         QFlags<IVariableController::UpdateType> t = IVariableController::UpdateNone;
         if (locals()->isExpanded()) t |= IVariableController::UpdateLocals;
         if (watches()->isExpanded()) t |= IVariableController::UpdateWatches;
         session->variableController()->setAutoUpdate(t);
     }
 }
 
 VariableCollection::~ VariableCollection()
 {
 }
 
 void VariableCollection::textDocumentCreated(IDocument* doc)
 {
   connect( doc->textDocument(),
        &KTextEditor::Document::viewCreated,
        this, &VariableCollection::viewCreated );
 
   foreach( KTextEditor::View* view, doc->textDocument()->views() )
     viewCreated( doc->textDocument(), view );
 }
 
 void VariableCollection::viewCreated(KTextEditor::Document* doc,
                                      KTextEditor::View* view)
 {
     Q_UNUSED(doc);
     using namespace KTextEditor;
     TextHintInterface *iface = dynamic_cast<TextHintInterface*>(view);
     if( !iface )
         return;
 
     iface->registerTextHintProvider(&m_textHintProvider);
 }
 
+Locals* VariableCollection::locals(const QString &name) const
+{
+    return m_universe->locals(name.isEmpty() ? i18n("Locals") : name);
+}
+
 VariableProvider::VariableProvider(VariableCollection* collection)
     : KTextEditor::TextHintProvider()
     , m_collection(collection)
 {
 }
 
 QString VariableProvider::textHint(KTextEditor::View* view, const KTextEditor::Cursor& cursor)
 {
     if (!hasStartedSession())
         return QString();
 
     if (ICore::self()->uiController()->activeArea()->objectName() != QLatin1String("debug"))
         return QString();
 
     //TODO: These keyboardModifiers should also hide already opened tooltip, and show another one for code area.
     if (QApplication::keyboardModifiers() == Qt::ControlModifier ||
         QApplication::keyboardModifiers() == Qt::AltModifier){
         return QString();
     }
 
     KTextEditor::Document* doc = view->document();
 
     KTextEditor::Range expressionRange = currentSession()->variableController()->expressionRangeUnderCursor(doc, cursor);
 
     if (!expressionRange.isValid())
         return QString();
     QString expression = doc->text(expressionRange).trimmed();
 
     // Don't do anything if there's already an open tooltip with matching range
     if (m_collection->m_activeTooltip && m_collection->m_activeTooltip->variable()->expression() == expression)
         return QString();
     if (expression.isEmpty())
         return QString();
 
     QPoint local = view->cursorToCoordinate(cursor);
     QPoint global = view->mapToGlobal(local);
     QWidget* w = view->childAt(local);
     if (!w)
         w = view;
 
     m_collection->m_activeTooltip = new VariableToolTip(w, global+QPoint(30,30), expression);
     m_collection->m_activeTooltip->setHandleRect(KTextEditorHelpers::getItemBoundingRect(view, expressionRange));
     return QString();
 }
 
 }
 
diff --git a/debugger/variable/variablecollection.h b/debugger/variable/variablecollection.h
index 8fb4424c4..e7e75993a 100644
--- a/debugger/variable/variablecollection.h
+++ b/debugger/variable/variablecollection.h
@@ -1,253 +1,253 @@
 /*
  * KDevelop Debugger Support
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2008 Vladimir Prus <ghost@cs.msu.su>
  * Copyright 2009 Niko Sams <niko.sams@gmail.com>
  *
  * 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.
  */
 
 #ifndef KDEVPLATFORM_VARIABLECOLLECTION_H
 #define KDEVPLATFORM_VARIABLECOLLECTION_H
 
 #include <QPointer>
 
 #include <KLocalizedString>
 #include <KTextEditor/TextHintInterface>
 
 #include <debugger/debuggerexport.h>
 #include "../util/treemodel.h"
 #include "../util/treeitem.h"
 #include "../../interfaces/idocument.h"
 #include "../../interfaces/idebugcontroller.h"
 
 namespace KDevMI { namespace GDB {
     class GdbTest;
 }
 }
 
 namespace KDevelop
 {
 class VariableToolTip;
 class IDebugSession;
 
 class KDEVPLATFORMDEBUGGER_EXPORT Variable : public TreeItem
 {
     Q_OBJECT
     friend class KDevMI::GDB::GdbTest;
 public:
 protected:
     Variable(TreeModel* model, TreeItem* parent,
              const QString& expression,
              const QString& display = {});
 
 public:
     enum format_t { Natural, Binary, Octal, Decimal, Hexadecimal };
     static format_t str2format(const QString& str);
     static QString format2str(format_t format);
 
     QString expression() const;
     bool inScope() const;
     void setInScope(bool v);
     void setValue(const QString &v);
     QString value() const;
     void setType(const QString& type);
     QString type() const;
     void setTopLevel(bool v);
     void setShowError(bool v);
     bool showError();
 
     using TreeItem::setHasMore;
     using TreeItem::setHasMoreInitial;
     using TreeItem::appendChild;
     using TreeItem::deleteChildren;
     using TreeItem::isExpanded;
     using TreeItem::parent;
 
     using TreeItem::model;
 
     ~Variable() override;
 
     /* Connects this variable to debugger, fetching the current value and
        otherwise preparing this variable to be displayed everywhere.  
        The attempt may fail, for example if the expression is invalid.
        Calls slot 'callbackMethod' in 'callback' to notify of the result.
        The slot should be taking 'bool ok' parameter.  */
     virtual void attachMaybe(QObject *callback = nullptr, const char *callbackMethod = nullptr) = 0;
 
     virtual bool canSetFormat() const { return false; }
 
     void setFormat(format_t format);
     format_t format() const { return m_format; }
     virtual void formatChanged();
 
     // get/set 'changed' state, if the variable changed it will be highlighted
     bool isChanged() const { return m_changed; }
     void setChanged(bool c);
     void resetChanged();
 
 public Q_SLOTS:
     void die();
 
 protected:
     bool topLevel() const { return m_topLevel; }
 
 private: // TreeItem overrides
     QVariant data(int column, int role) const override;
 
 private:
     bool isPotentialProblematicValue() const;
 
     QString m_expression;
     bool m_inScope;
     bool m_topLevel;
     bool m_changed;
     bool m_showError;
 
     format_t m_format;
 };
 
 class KDEVPLATFORMDEBUGGER_EXPORT TooltipRoot : public TreeItem
 {
     Q_OBJECT
 public:
     explicit TooltipRoot(TreeModel* model)
     : TreeItem(model)
     {}
 
     void init(Variable *var)
     {
         appendChild(var);
     }
 
     void fetchMoreChildren() override {}
 };
 
 class KDEVPLATFORMDEBUGGER_EXPORT Watches : public TreeItem
 {
     Q_OBJECT
     friend class KDevMI::GDB::GdbTest;
 public:
     Watches(TreeModel* model, TreeItem* parent);
     Variable* add(const QString& expression);
 
     void reinstall();
 
     Variable *addFinishResult(const QString& convenienceVarible);
     void removeFinishResult();
     void resetChanged();
 
     using TreeItem::childCount;
     friend class VariableCollection;
     friend class IVariableController;
 private:
 
     QVariant data(int column, int role) const override;
 
     void fetchMoreChildren() override {}
 
     Variable* finishResult_;
 };
 
 class KDEVPLATFORMDEBUGGER_EXPORT Locals : public TreeItem
 {
     Q_OBJECT
 public:
     Locals(TreeModel* model, TreeItem* parent, const QString &name);
     QList<Variable*> updateLocals(QStringList locals);
     void resetChanged();
 
     using TreeItem::deleteChildren;
     using TreeItem::setHasMore;
 
     friend class VariableCollection;
     friend class IVariableController;
     
 private:
     void fetchMoreChildren() override {}
 };
 
 class KDEVPLATFORMDEBUGGER_EXPORT VariablesRoot : public TreeItem
 {
     Q_OBJECT
 public:
     explicit VariablesRoot(TreeModel* model);
 
     Watches *watches() const { return m_watches; }
     Locals *locals(const QString &name = QStringLiteral("Locals"));
     QHash<QString, Locals*> allLocals() const;
 
     void fetchMoreChildren() override {}
 
     void resetChanged();
 
 private:
     Watches *m_watches;
     QHash<QString, Locals*> m_locals;
 };
 
 class VariableProvider : public KTextEditor::TextHintProvider
 {
 public:
     explicit VariableProvider(VariableCollection* collection);
     QString textHint(KTextEditor::View* view, const KTextEditor::Cursor& position) override;
 
 private:
     VariableCollection* m_collection;
 };
 
 class KDEVPLATFORMDEBUGGER_EXPORT VariableCollection : public TreeModel
 {
     Q_OBJECT
 
 public:
     enum Column {
         NameColumn,
         ValueColumn,
         TypeColumn
     };
 
     explicit VariableCollection(IDebugController* parent);
     ~VariableCollection() override;
 
     VariablesRoot* root() const { return m_universe; }
     Watches* watches() const { return m_universe->watches(); }
-    Locals* locals(const QString &name = i18n("Locals")) const { return m_universe->locals(name); }
+    Locals* locals(const QString &name = QString()) const;
     QHash<QString, Locals*> allLocals() const { return m_universe->allLocals(); }
 
 public Q_SLOTS:
     void variableWidgetShown();
     void variableWidgetHidden();
 
 private Q_SLOTS:
     void updateAutoUpdate(KDevelop::IDebugSession* session = nullptr);
 
     void textDocumentCreated( KDevelop::IDocument*);
     void viewCreated(KTextEditor::Document*, KTextEditor::View*);
 
 private:
     VariablesRoot* m_universe;
     QPointer<VariableToolTip> m_activeTooltip;
     bool m_widgetVisible;
 
     friend class VariableProvider;
     VariableProvider m_textHintProvider;
 };
 
 }
 
 #endif
diff --git a/plugins/welcomepage/welcomepageplugin.cpp b/plugins/welcomepage/welcomepageplugin.cpp
index 1f5ba73d2..9a8b76c70 100644
--- a/plugins/welcomepage/welcomepageplugin.cpp
+++ b/plugins/welcomepage/welcomepageplugin.cpp
@@ -1,59 +1,61 @@
 /* This file is part of KDevelop
   Copyright 2010 Aleix Pol Gonzalez <aleixpol@kde.org>
 
   This library 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 library 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #include "welcomepageplugin.h"
 #include "welcomepageview.h"
 
 #include <KPluginFactory>
 
 #include <interfaces/icore.h>
 #include <interfaces/iuicontroller.h>
 #include <sublime/mainwindow.h>
 
 #include <QDebug>
 
+#include <stdint.h>
+
 K_PLUGIN_FACTORY_WITH_JSON(KDevWelcomePagePluginFactory, "kdevwelcomepage.json", registerPlugin<KDevWelcomePagePlugin>();)
 
 using namespace KDevelop;
 
 namespace {
 WelcomePageWidget* createWelcomePageWidget(QWidget* parent)
 {
     // don't attempt to load any QML if CPU doesn't have SSE2 support (cf. bug 381999)
-#if defined(Q_OS_LINUX) && (defined(Q_CC_GNU) || (defined(Q_CC_CLANG) && __clang_major__ >= 3 && __clang_minor__ >= 7))
+#if defined(Q_OS_LINUX) && INTPTR_MAX == INT32_MAX && (defined(Q_CC_GNU) || (defined(Q_CC_CLANG) && __clang_major__ >= 3 && __clang_minor__ >= 7))
     if (!__builtin_cpu_supports("sse2")) {
         qWarning() << "Welcome Page won't load any QML -- lacking SSE2 support on this processor";
         return nullptr;
     }
 #endif
 
     return new WelcomePageWidget({}, parent);
 }
 }
 
 KDevWelcomePagePlugin::KDevWelcomePagePlugin( QObject* parent, const QVariantList& )
     : IPlugin(QStringLiteral("kdevwelcomepage"), parent )
 {
     auto mainWindow = qobject_cast<Sublime::MainWindow*>(ICore::self()->uiController()->activeMainWindow());
     if (auto welcomePageWidget = createWelcomePageWidget(mainWindow)) {
         mainWindow->setBackgroundCentralWidget(welcomePageWidget);
     }
 }
 
 #include "welcomepageplugin.moc"
diff --git a/sublime/container.cpp b/sublime/container.cpp
index f736db01b..5c4390ecd 100644
--- a/sublime/container.cpp
+++ b/sublime/container.cpp
@@ -1,726 +1,737 @@
 /***************************************************************************
  *   Copyright 2006-2009 Alexander Dymo  <adymo@kdevelop.org>              *
  *                                                                         *
  *   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 Library 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 "container.h"
 
 #include <QApplication>
 #include <QBoxLayout>
 #include <QClipboard>
 #include <QEvent>
 #include <QLabel>
 #include <QMenu>
 #include <QMouseEvent>
 #include <QPointer>
 #include <QStackedWidget>
 #include <QStyleFactory>
 #include <QStyleOptionTabBarBase>
 #include <QStylePainter>
 #include <QTabBar>
 #include <QToolButton>
+#include <QWindow>
 
 #include <KAcceleratorManager>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include "view.h"
 #include "urldocument.h"
 #include <ksqueezedtextlabel.h>
 
 namespace Sublime {
 
 // struct ContainerPrivate
 
 class ContainerTabBar : public QTabBar
 {
     Q_OBJECT
 
 public:
     explicit ContainerTabBar(Container* container)
         : QTabBar(container), m_container(container)
     {
         if (QApplication::style()->objectName() == QLatin1String("macintosh")) {
             static QPointer<QStyle> qTabBarStyle = QStyleFactory::create(QStringLiteral("fusion"));
             if (qTabBarStyle) {
                 setStyle(qTabBarStyle);
             }
         }
         // configure the QTabBar style so it behaves as appropriately as possible,
         // even if we end up using the native Macintosh style because the user's
         // Qt doesn't have the Fusion style installed.
         setDocumentMode(true);
         setUsesScrollButtons(true);
         setElideMode(Qt::ElideNone);
 
         installEventFilter(this);
     }
 
     bool event(QEvent* ev) override {
         if(ev->type() == QEvent::ToolTip)
         {
             ev->accept();
 
             QHelpEvent* helpEvent = static_cast<QHelpEvent*>(ev);
             int tab = tabAt(helpEvent->pos());
 
             if(tab != -1)
             {
                 m_container->showTooltipForTab(tab);
             }
 
             return true;
         }
 
         return QTabBar::event(ev);
     }
     void mousePressEvent(QMouseEvent* event) override {
         if (event->button() == Qt::MidButton) {
             // just close on midbutton, drag can still be done with left mouse button
 
             int tab = tabAt(event->pos());
             if (tab != -1) {
                 emit tabCloseRequested(tab);
             }
             return;
         }
         QTabBar::mousePressEvent(event);
     }
 
     bool eventFilter(QObject* obj, QEvent* event) override
     {
         if (obj != this) {
             return QObject::eventFilter(obj, event);
         }
 
         // TODO Qt6: Move to mouseDoubleClickEvent when fixme in qttabbar.cpp is resolved
         // see "fixme Qt 6: move to mouseDoubleClickEvent(), here for BC reasons." in qtabbar.cpp
         if (event->type() == QEvent::MouseButtonDblClick) {
             // block tabBarDoubleClicked signals with RMB, see https://bugs.kde.org/show_bug.cgi?id=356016
             auto mouseEvent = static_cast<const QMouseEvent*>(event);
             if (mouseEvent->button() == Qt::MidButton) {
                 return true;
             }
         }
 
         return QObject::eventFilter(obj, event);
     }
 
 Q_SIGNALS:
     void newTabRequested();
 
 private:
     Container* m_container;
 };
 
 bool sortViews(const View* const lhs, const View* const rhs)
 {
         return lhs->document()->title().compare(rhs->document()->title(), Qt::CaseInsensitive) < 0;
 }
 
 #ifdef Q_OS_MACOS
 // only one of these per process:
 static QMenu* currentDockMenu = nullptr;
 #endif
 
 struct ContainerPrivate {
     QBoxLayout* layout;
     QHash<QWidget*, View*> viewForWidget;
 
     ContainerTabBar *tabBar;
     QStackedWidget *stack;
     KSqueezedTextLabel *fileNameCorner;
     QLabel *fileStatus;
     KSqueezedTextLabel *statusCorner;
     QPointer<QWidget> leftCornerWidget;
     QToolButton* documentListButton;
     QMenu* documentListMenu;
     QHash<View*, QAction*> documentListActionForView;
 
     /**
      * Updates the context menu which is shown when
      * the document list button in the tab bar is clicked.
      *
      * It shall build a popup menu which contains all currently
      * enabled views using the title their document provides.
      */
     void updateDocumentListPopupMenu()
     {
         qDeleteAll(documentListActionForView);
         documentListActionForView.clear();
         documentListMenu->clear();
 
         // create a lexicographically sorted list
         QVector<View*> views;
         views.reserve(viewForWidget.size());
 
         foreach(View* view, viewForWidget){
             views << view;
         }
 
         std::sort(views.begin(), views.end(), sortViews);
 
         for (int i = 0; i < views.size(); ++i) {
             View *view = views.at(i);
             QString visibleEntryTitle;
             // if filename is not unique, prepend containing directory
             if ((i < views.size() - 1 && view->document()->title() == views.at(i + 1)->document()->title())
                 || (i > 0 && view->document()->title() == views.at(i - 1)->document()->title())
             ) {
                 auto urlDoc = qobject_cast<Sublime::UrlDocument*>(view->document());
                 if (!urlDoc) {
                     visibleEntryTitle = view->document()->title();
                 }
                 else {
                     auto url = urlDoc->url().toString();
                     int secondOffset = url.lastIndexOf('/');
                     secondOffset = url.lastIndexOf('/', secondOffset - 1);
                     visibleEntryTitle = url.right(url.length() - url.lastIndexOf('/', secondOffset) - 1);
                 }
             } else {
                 visibleEntryTitle = view->document()->title();
             }
             QAction* action = documentListMenu->addAction(visibleEntryTitle);
             action->setData(QVariant::fromValue(view));
             documentListActionForView[view] = action;
             action->setIcon(view->document()->icon());
             ///FIXME: push this code somehow into shell, such that we can access the project model for
             ///       icons and also get a neat, short path like the document switcher.
         }
 
         setAsDockMenu();
     }
 
     void setAsDockMenu()
     {
 #ifdef Q_OS_MACOS
         if (documentListMenu != currentDockMenu) {
             documentListMenu->setAsDockMenu();
             currentDockMenu = documentListMenu;
         }
 #endif
     }
 
     ~ContainerPrivate()
     {
 #ifdef Q_OS_MACOS
         if (documentListMenu == currentDockMenu) {
             QMenu().setAsDockMenu();
             currentDockMenu = nullptr;
         }
 #endif
     }
 };
 
 class UnderlinedLabel: public KSqueezedTextLabel {
 Q_OBJECT
 public:
     explicit UnderlinedLabel(QTabBar *tabBar, QWidget* parent = nullptr)
         :KSqueezedTextLabel(parent), m_tabBar(tabBar)
     {
     }
 
 protected:
     void paintEvent(QPaintEvent *ev) override
     {
 #ifndef Q_OS_OSX
         // getting the underlining right on OS X is tricky; omitting
         // the underlining attracts the eye less than not getting it
         // exactly right.
         if (m_tabBar->isVisible() && m_tabBar->count() > 0)
         {
             QStylePainter p(this);
             QStyleOptionTabBarBase optTabBase;
             optTabBase.init(m_tabBar);
             optTabBase.shape = m_tabBar->shape();
             optTabBase.tabBarRect = m_tabBar->rect();
             optTabBase.tabBarRect.moveRight(0);
 
             QStyleOptionTab tabOverlap;
             tabOverlap.shape = m_tabBar->shape();
             int overlap = style()->pixelMetric(QStyle::PM_TabBarBaseOverlap, &tabOverlap, m_tabBar);
             if( overlap > 0 )
             {
                 QRect rect;
                 rect.setRect(0, height()-overlap, width(), overlap);
                 optTabBase.rect = rect;
             }
             if( m_tabBar->drawBase() )
             {
                 p.drawPrimitive(QStyle::PE_FrameTabBarBase, optTabBase);
             }
         }
 #endif
 
         KSqueezedTextLabel::paintEvent(ev);
     }
 
     QTabBar *m_tabBar;
 };
 
 
 class StatusLabel: public UnderlinedLabel {
 Q_OBJECT
 public:
     explicit StatusLabel(QTabBar *tabBar, QWidget* parent = nullptr):
         UnderlinedLabel(tabBar, parent)
     {
         setAlignment(Qt::AlignRight | Qt::AlignVCenter);
         setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
     }
 
     QSize minimumSizeHint() const override
     {
         QRect rect = style()->itemTextRect(fontMetrics(), QRect(), Qt::AlignRight, true, i18n("Line: 00000 Col: 000"));
         rect.setHeight(m_tabBar->height());
         return rect.size();
     }
 };
 
 // class Container
 
 Container::Container(QWidget *parent)
     :QWidget(parent), d(new ContainerPrivate())
 {
     KAcceleratorManager::setNoAccel(this);
 
     QBoxLayout *l = new QBoxLayout(QBoxLayout::TopToBottom, this);
     l->setMargin(0);
     l->setSpacing(0);
 
     d->layout = new QBoxLayout(QBoxLayout::LeftToRight);
     d->layout->setMargin(0);
     d->layout->setSpacing(0);
 
     d->documentListMenu = new QMenu(this);
     d->documentListButton = new QToolButton(this);
     d->documentListButton->setIcon(QIcon::fromTheme(QStringLiteral("format-list-unordered")));
     d->documentListButton->setMenu(d->documentListMenu);
 #ifdef Q_OS_MACOS
     // for maintaining the Dock menu:
     setFocusPolicy(Qt::StrongFocus);
 #endif
     d->documentListButton->setPopupMode(QToolButton::InstantPopup);
     d->documentListButton->setAutoRaise(true);
     d->documentListButton->setToolTip(i18n("Show sorted list of opened documents"));
     d->documentListButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
     d->layout->addWidget(d->documentListButton);
     d->tabBar = new ContainerTabBar(this);
     d->tabBar->setContextMenuPolicy(Qt::CustomContextMenu);
     d->layout->addWidget(d->tabBar);
     d->fileStatus = new QLabel( this );
     d->fileStatus->setFixedSize( QSize( 16, 16 ) );
     d->layout->addWidget(d->fileStatus);
     d->fileNameCorner = new UnderlinedLabel(d->tabBar, this);
     d->layout->addWidget(d->fileNameCorner);
     d->statusCorner = new StatusLabel(d->tabBar, this);
     d->layout->addWidget(d->statusCorner);
     l->addLayout(d->layout);
 
     d->stack = new QStackedWidget(this);
     l->addWidget(d->stack);
 
     connect(d->tabBar, &ContainerTabBar::currentChanged, this, &Container::widgetActivated);
     connect(d->tabBar, &ContainerTabBar::tabCloseRequested, this, static_cast<void(Container::*)(int)>(&Container::requestClose));
     connect(d->tabBar, &ContainerTabBar::newTabRequested, this, &Container::newTabRequested);
     connect(d->tabBar, &ContainerTabBar::tabMoved, this, &Container::tabMoved);
     connect(d->tabBar, &ContainerTabBar::customContextMenuRequested, this, &Container::contextMenu);
     connect(d->tabBar, &ContainerTabBar::tabBarDoubleClicked, this, &Container::doubleClickTriggered);
     connect(d->documentListMenu, &QMenu::triggered, this, &Container::documentListActionTriggered);
 
 
     setTabBarHidden(!configTabBarVisible());
     d->tabBar->setTabsClosable(true);
     d->tabBar->setMovable(true);
     d->tabBar->setExpanding(false);
     d->tabBar->setSelectionBehaviorOnRemove(QTabBar::SelectPreviousTab);
 }
 
 bool Container::configTabBarVisible()
 {
     KConfigGroup group = KSharedConfig::openConfig()->group("UiSettings");
     return group.readEntry("TabBarVisibility", 1);
 }
 
 void Container::setLeftCornerWidget(QWidget* widget)
 {
     if(d->leftCornerWidget.data() == widget) {
         if(d->leftCornerWidget)
             d->leftCornerWidget.data()->setParent(nullptr);
     }else{
         delete d->leftCornerWidget.data();
         d->leftCornerWidget.clear();
     }
     d->leftCornerWidget = widget;
     if(!widget)
         return;
     widget->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred);
     d->layout->insertWidget(0, widget);
     widget->show();
 }
 
 Container::~Container()
 {
     delete d;
 }
 
 QList<View*> Container::views() const
 {
     return d->viewForWidget.values();
 }
 
 void Container::requestClose(int idx)
 {
     emit requestClose(widget(idx));
 }
 
 void Container::widgetActivated(int idx)
 {
     if (idx < 0)
         return;
     if (QWidget* w = d->stack->widget(idx)) {
         Sublime::View* view = d->viewForWidget.value(w);
         if(view)
             emit activateView(view);
     }
 }
 
 void Container::addWidget(View *view, int position)
 {
     QWidget *w = view->widget(this);
     int idx = 0;
     if (position != -1)
     {
         idx = d->stack->insertWidget(position, w);
     }
     else
         idx = d->stack->addWidget(w);
     d->tabBar->insertTab(idx, view->document()->statusIcon(), view->document()->title());
     Q_ASSERT(view);
     d->viewForWidget[w] = view;
 
     // Update document list context menu. This has to be called before
     // setCurrentWidget, because we call the status icon and title update slots
     // already, which in turn need the document list menu to be setup.
     d->updateDocumentListPopupMenu();
 
     setCurrentWidget(d->stack->currentWidget());
 
     // This fixes a strange layouting bug, that could be reproduced like this: Open a few files in KDevelop, activate the rightmost tab.
     // Then temporarily switch to another area, and then switch back. After that, the tab-bar was gone.
     // The problem could only be fixed by closing/opening another view.
     d->tabBar->setMinimumHeight(d->tabBar->sizeHint().height());
 
     connect(view, &View::statusChanged, this, &Container::statusChanged);
     connect(view->document(), &Document::statusIconChanged, this, &Container::statusIconChanged);
     connect(view->document(), &Document::titleChanged, this, &Container::documentTitleChanged);
 }
 
 void Container::statusChanged(Sublime::View* view)
 {
     d->statusCorner->setText(view->viewStatus());
 }
 
 
 void Container::statusIconChanged(Document* doc)
 {
     QHashIterator<QWidget*, View*> it = d->viewForWidget;
     while (it.hasNext()) {
         if (it.next().value()->document() == doc) {
             d->fileStatus->setPixmap( doc->statusIcon().pixmap( QSize( 16,16 ) ) );
             int tabIndex = d->stack->indexOf(it.key());
             if (tabIndex != -1) {
                 d->tabBar->setTabIcon(tabIndex, doc->statusIcon());
             }
 
             // Update the document title's menu associated action
             // using the View* index map
             Q_ASSERT(d->documentListActionForView.contains(it.value()));
             d->documentListActionForView[it.value()]->setIcon(doc->icon());
             break;
         }
     }
 }
 
 void Container::documentTitleChanged(Sublime::Document* doc)
 {
     QHashIterator<QWidget*, View*> it = d->viewForWidget;
     while (it.hasNext()) {
         Sublime::View* view = it.next().value();
         if (view->document() == doc) {
             if (currentView() == view) {
                 d->fileNameCorner->setText( doc->title(Document::Extended) + i18n(" <i><small>(Press Ctrl+Tab to switch)</small></i>") );
             }
             int tabIndex = d->stack->indexOf(it.key());
             if (tabIndex != -1) {
                 d->tabBar->setTabText(tabIndex, doc->title());
             }
             break;
         }
     }
     // Update document list popup title
     d->updateDocumentListPopupMenu();
 }
 
 int Container::count() const
 {
     return d->stack->count();
 }
 
 QWidget* Container::currentWidget() const
 {
     return d->stack->currentWidget();
 }
 
 void Container::setCurrentWidget(QWidget* w)
 {
     d->stack->setCurrentWidget(w);
     //prevent from emitting activateView() signal on tabbar active tab change
     //this function is called from MainWindow::activateView()
     //which does the activation without any additional signals
     {
         QSignalBlocker blocker(d->tabBar);
         d->tabBar->setCurrentIndex(d->stack->indexOf(w));
     }
     if (View* view = viewForWidget(w))
     {
         statusChanged(view);
         if (!d->tabBar->isVisible())
         {
             // repaint icon and document title only in tabbar-less mode
             // tabbar will do repainting for us
             statusIconChanged( view->document() );
             documentTitleChanged( view->document() );
         }
     }
 }
 
 QWidget* Container::widget(int i) const
 {
     return d->stack->widget(i);
 }
 
 int Container::indexOf(QWidget* w) const
 {
     return d->stack->indexOf(w);
 }
 
 void Container::removeWidget(QWidget *w)
 {
     if (w) {
         int widgetIdx = d->stack->indexOf(w);
         d->stack->removeWidget(w);
         d->tabBar->removeTab(widgetIdx);
         if (d->tabBar->currentIndex() != -1 && !d->tabBar->isVisible()) {
             // repaint icon and document title only in tabbar-less mode
             // tabbar will do repainting for us
             View* view = currentView();
             if( view ) {
                 statusIconChanged( view->document() );
                 documentTitleChanged( view->document() );
             }
         }
         View* view = d->viewForWidget.take(w);
         if (view)
         {
             disconnect(view->document(), &Document::titleChanged, this, &Container::documentTitleChanged);
             disconnect(view->document(), &Document::statusIconChanged, this, &Container::statusIconChanged);
             disconnect(view, &View::statusChanged, this, &Container::statusChanged);
 
             // Update document list context menu
             Q_ASSERT(d->documentListActionForView.contains(view));
             delete d->documentListActionForView.take(view);
         }
     }
 }
 
 bool Container::hasWidget(QWidget *w)
 {
     return d->stack->indexOf(w) != -1;
 }
 
 View *Container::viewForWidget(QWidget *w) const
 {
     return d->viewForWidget.value(w);
 }
 
 void Container::setTabBarHidden(bool hide)
 {
     if (hide)
     {
         d->tabBar->hide();
         d->fileNameCorner->show();
         d->fileStatus->show();
     }
     else
     {
         d->fileNameCorner->hide();
         d->fileStatus->hide();
         d->tabBar->show();
     }
     View* v = currentView();
     if (v) {
         documentTitleChanged(v->document());
     }
 }
 
 void Container::resetTabColors(const QColor& color)
 {
     for (int i = 0; i < count(); i++){
         d->tabBar->setTabTextColor(i, color);
     }
 }
 
 void Container::setTabColor(const View* view, const QColor& color)
 {
     for (int i = 0; i < count(); i++){
         if (view == viewForWidget(widget(i))) {
             d->tabBar->setTabTextColor(i, color);
         }
     }
 }
 
 void Container::setTabColors(const QHash<const View*, QColor>& colors)
 {
     for (int i = 0; i < count(); i++) {
         auto view = viewForWidget(widget(i));
         auto color = colors[view];
         if (color.isValid()) {
             d->tabBar->setTabTextColor(i, color);
         }
     }
 }
 
 void Container::tabMoved(int from, int to)
 {
     QWidget *w = d->stack->widget(from);
     d->stack->removeWidget(w);
     d->stack->insertWidget(to, w);
     d->viewForWidget[w]->notifyPositionChanged(to);
 }
 
 void Container::contextMenu( const QPoint& pos )
 {
     QWidget* senderWidget = qobject_cast<QWidget*>(sender());
     Q_ASSERT(senderWidget);
 
     int currentTab = d->tabBar->tabAt(pos);
 
-    QPointer<QMenu> menu = new QMenu(senderWidget);
+    QMenu menu;
+    // At least for positioning on Wayland the window the menu belongs to
+    // needs to be set. We cannot set senderWidget as parent because some actions (e.g. split view)
+    // result in sync destruction of the senderWidget, which then would also prematurely
+    // destruct the menu object
+    // Workaround (best known currently, check again API of Qt >5.9):
+    menu.winId(); // trigger being a native widget already, to ensure windowHandle created
+    auto parentWindowHandle = senderWidget->windowHandle();
+    if (!parentWindowHandle) {
+        parentWindowHandle = senderWidget->nativeParentWidget()->windowHandle();
+    }
+    menu.windowHandle()->setTransientParent(parentWindowHandle);
 
     Sublime::View* view = viewForWidget(widget(currentTab));
-    emit tabContextMenuRequested(view, menu);
+    emit tabContextMenuRequested(view, &menu);
 
-    menu->addSeparator();
+    menu.addSeparator();
     QAction* copyPathAction = nullptr;
     QAction* closeTabAction = nullptr;
     QAction* closeOtherTabsAction = nullptr;
     if (view) {
-        copyPathAction = menu->addAction(QIcon::fromTheme(QStringLiteral("edit-copy")),
+        copyPathAction = menu.addAction(QIcon::fromTheme(QStringLiteral("edit-copy")),
                                         i18n("Copy Filename"));
-        menu->addSeparator();
-        closeTabAction = menu->addAction(QIcon::fromTheme(QStringLiteral("document-close")),
+        menu.addSeparator();
+        closeTabAction = menu.addAction(QIcon::fromTheme(QStringLiteral("document-close")),
                                         i18n("Close File"));
-        closeOtherTabsAction = menu->addAction(QIcon::fromTheme(QStringLiteral("document-close")),
+        closeOtherTabsAction = menu.addAction(QIcon::fromTheme(QStringLiteral("document-close")),
                                               i18n("Close Other Files"));
     }
-    QAction* closeAllTabsAction = menu->addAction( QIcon::fromTheme(QStringLiteral("document-close")), i18n( "Close All Files" ) );
+    QAction* closeAllTabsAction = menu.addAction(QIcon::fromTheme(QStringLiteral("document-close")), i18n("Close All Files"));
 
-    QAction* triggered = menu->exec(senderWidget->mapToGlobal(pos));
-    delete menu.data();
+    QAction* triggered = menu.exec(senderWidget->mapToGlobal(pos));
 
     if (triggered) {
         if ( triggered == closeTabAction ) {
             requestClose(currentTab);
         } else if ( triggered == closeOtherTabsAction ) {
             // activate the remaining tab
             widgetActivated(currentTab);
             // first get the widgets to be closed since otherwise the indices will be wrong
             QList<QWidget*> otherTabs;
             for ( int i = 0; i < count(); ++i ) {
                 if ( i != currentTab ) {
                     otherTabs << widget(i);
                 }
             }
             // finally close other tabs
             foreach( QWidget* tab, otherTabs ) {
                 requestClose(tab);
             }
         } else if ( triggered == closeAllTabsAction ) {
             // activate last tab
             widgetActivated(count() - 1);
 
             // close all
             for ( int i = 0; i < count(); ++i ) {
                 requestClose(widget(i));
             }
         } else if( triggered == copyPathAction ) {
             auto view = viewForWidget( widget( currentTab ) );
             auto urlDocument = qobject_cast<UrlDocument*>( view->document() );
             if( urlDocument ) {
                 QApplication::clipboard()->setText(urlDocument->url().toDisplayString(QUrl::PreferLocalFile));
             }
         } // else the action was handled by someone else
     }
 }
 
 void Container::showTooltipForTab(int tab)
 {
     emit tabToolTipRequested(viewForWidget(widget(tab)), this, tab);
 }
 
 bool Container::isCurrentTab(int tab) const
 {
     return d->tabBar->currentIndex() == tab;
 }
 
 QRect Container::tabRect(int tab) const
 {
     return d->tabBar->tabRect(tab).translated(d->tabBar->mapToGlobal(QPoint(0, 0)));
 }
 
 void Container::doubleClickTriggered(int tab)
 {
     if (tab == -1) {
         emit newTabRequested();
     } else {
         emit tabDoubleClicked(viewForWidget(widget(tab)));
     }
 }
 
 void Container::documentListActionTriggered(QAction* action)
 {
     Sublime::View* view = action->data().value< Sublime::View* >();
     Q_ASSERT(view);
     QWidget* widget = d->viewForWidget.key(view);
     Q_ASSERT(widget);
     setCurrentWidget(widget);
 }
 Sublime::View* Container::currentView() const
 {
     return d->viewForWidget.value(widget( d->tabBar->currentIndex() ));
 }
 
 void Container::focusInEvent(QFocusEvent* event)
 {
     d->setAsDockMenu();
     QWidget::focusInEvent(event);
 }
 
 }
 
 #include "container.moc"