diff --git a/debugger/variable/variabletooltip.cpp b/debugger/variable/variabletooltip.cpp
index a8d223f43f..93e9765ab5 100644
--- a/debugger/variable/variabletooltip.cpp
+++ b/debugger/variable/variabletooltip.cpp
@@ -1,210 +1,210 @@
 /*
  * KDevelop Debugger Support
  *
  * 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 "variabletooltip.h"
 
 #include <QWidget>
 #include <QHBoxLayout>
 #include <QTreeView>
 #include <QApplication>
 #include <QEvent>
 #include <QStandardItemModel>
 #include <QMouseEvent>
 #include <QHeaderView>
 #include <QLabel>
 #include <QScrollBar>
 #include <QDesktopWidget>
 #include <KTextEditor/View>
 #include <KLocale>
 #include <QPainter>
 
 #include "variablecollection.h"
 #include "../breakpoint/breakpointmodel.h"
 #include "../interfaces/ivariablecontroller.h"
 #include "../../util/activetooltip.h"
 #include "../../interfaces/icore.h"
 #include "../../interfaces/idebugcontroller.h"
 
 namespace KDevelop {
 
 class SizeGrip : public QWidget
 {
 public:
     SizeGrip(QWidget* parent) : QWidget(parent) {
         m_parent = parent;
     }
 protected:
     virtual void paintEvent(QPaintEvent *)
     {
       QPainter painter(this);
       QStyleOptionSizeGrip opt;
       opt.init(this);
       opt.corner = Qt::BottomRightCorner;
       style()->drawControl(QStyle::CE_SizeGrip, &opt, &painter, this);
     }
 
     virtual void mousePressEvent(QMouseEvent* e)
     {
         if (e->button() == Qt::LeftButton) {
             m_pos = e->globalPos();
             m_startSize = m_parent->size();
             e->ignore();
         }
     }
     virtual void mouseReleaseEvent(QMouseEvent*)
     {
         m_pos = QPoint();
     }
     virtual void mouseMoveEvent(QMouseEvent* e)
     {
         if (!m_pos.isNull()) {
             m_parent->resize(
                 m_startSize.width() + (e->globalPos().x() - m_pos.x()),
                 m_startSize.height() + (e->globalPos().y() - m_pos.y())
             );
         }
     }
 private:
     QWidget *m_parent;
     QSize m_startSize;
     QPoint m_pos;
 };
 
 VariableToolTip::VariableToolTip(QWidget* parent, QPoint position, 
                                  const QString& identifier)
 :  ActiveToolTip(parent, position)
 {
     setPalette( QApplication::palette() );
 
     model_ = new TreeModel(QVector<QString>() << i18n("Name") << i18n("Value"),
                            this);
 
     TooltipRoot* tr = new TooltipRoot(model_);
     model_->setRootItem(tr);
     var_ = ICore::self()->debugController()->currentSession()->
         variableController()->createVariable(
             model_, tr, identifier);
     tr->init(var_);
     var_->attachMaybe(this, "variableCreated");
 
     QVBoxLayout* l = new QVBoxLayout(this);
     l->setContentsMargins(0, 0, 0, 0);
     view_ = new AsyncTreeView(model_, this);
     view_->header()->resizeSection(0, 150);
     view_->header()->resizeSection(1, 90);
     view_->setSelectionBehavior(QAbstractItemView::SelectRows);
     view_->setSelectionMode(QAbstractItemView::SingleSelection);
     view_->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     view_->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Expanding);
     l->addWidget(view_);
 
     itemHeight_ = view_->indexRowSizeHint(model_->indexForItem(var_, 0));
     connect(view_->verticalScrollBar(),
             SIGNAL(rangeChanged(int,int)),
             this,
             SLOT(slotRangeChanged(int,int)));
 
     selection_ = view_->selectionModel();
     selection_->select(model_->indexForItem(var_, 0), 
                        QItemSelectionModel::Rows
                        | QItemSelectionModel::ClearAndSelect);
 
     QHBoxLayout* labelL = new QHBoxLayout();
     labelL->setContentsMargins(11, 0, 11, 6);
     QLabel* label = new QLabel(i18n("<a href=\"add_watch\">Watch this</a>"), this);
     labelL->addWidget(label);
-    QLabel* label2 = new QLabel(i18n("<a href=\"watchpoint\">Stop on change</a>"), 
+    QLabel* label2 = new QLabel(i18n("<a href=\"watchpoint\">Stop on change</a>"),
                                 this);
     labelL->addWidget(label2);
     connect(label, SIGNAL(linkActivated(QString)),
             this, SLOT(slotLinkActivated(QString)));
     connect(label2, SIGNAL(linkActivated(QString)),
             this, SLOT(slotLinkActivated(QString)));    
 
     QHBoxLayout* inner = new QHBoxLayout();
     l->addLayout(inner);
     inner->setContentsMargins(0, 0, 0, 0);
     inner->addLayout(labelL);
     inner->addStretch();
 
     SizeGrip* g = new SizeGrip(this);
     g->setFixedSize(16, 16);
     inner->addWidget(g, 0, (Qt::Alignment)(Qt::AlignRight | Qt::AlignBottom));
 
     move(position);
 }
 
 void VariableToolTip::variableCreated(bool hasValue)
 {
     view_->resizeColumns();
     if (hasValue) {
         ActiveToolTip::showToolTip(this, 0.0);
     } else {
         close();
     }
 }
 
 void VariableToolTip::slotLinkActivated(const QString& link)
 {
     Variable* v = var_;
     QItemSelection s = selection_->selection();
     if (!s.empty())
     {
         QModelIndex index = s.front().topLeft();
         TreeItem *item = model_->itemForIndex(index);
         if (item)
         {
             Variable* v2 = dynamic_cast<Variable*>(item);
             if (v2)
                 v = v2;
         }
     }
 
     IDebugSession *session = ICore::self()->debugController()->currentSession();
     if (session && session->state() != IDebugSession::NotStartedState && session->state() != IDebugSession::EndedState) {
         if (link == "add_watch") {
             session->variableController()->addWatch(v);
         } else if (link == "watchpoint") {
             session->variableController()->addWatchpoint(v);
         }
     }
     close();
 }
 
 void VariableToolTip::slotRangeChanged(int min, int max)
 {
     Q_ASSERT(min == 0);
     Q_UNUSED(min);
     QRect rect = QApplication::desktop()->screenGeometry(this);
     if (pos().y() + height() + max*itemHeight_ < rect.bottom())
         resize(width(), height() + max*itemHeight_);    
     else
     {
         // Oh, well, I'm sorry, but here's the scrollbar you was
         // longing to see
         view_->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);        
     }
 }
 
 }
 
 #include "variabletooltip.moc"
diff --git a/debugger/variable/variablewidget.cpp b/debugger/variable/variablewidget.cpp
index e695fa6d09..5ab23f1ae1 100644
--- a/debugger/variable/variablewidget.cpp
+++ b/debugger/variable/variablewidget.cpp
@@ -1,513 +1,513 @@
 // **************************************************************************
 //    begin                : Sun Aug 8 1999
 //    copyright            : (C) 1999 by John Birch
 //    email                : jbb@kdevelop.org
 // **************************************************************************
 // * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
 // **************************************************************************
 // *                                                                        *
 // *   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.                                  *
 // *                                                                        *
 // **************************************************************************
 
 #include "variablewidget.h"
 
 #include <QLabel>
 #include <QLayout>
 #include <QPainter>
 #include <QPushButton>
 #include <QRegExp>
 #include <QCursor>
 #include <QHBoxLayout>
 #include <QKeyEvent>
 #include <QFocusEvent>
 #include <QVBoxLayout>
 #include <QPoint>
 #include <QClipboard>
 
 #include <kapplication.h>
 #include <kmessagebox.h>
 #include <khistorycombobox.h>
 #include <kdebug.h>
 #include <kmenu.h>
 #include <klineedit.h>
 #include <kdeversion.h>
 #include <kiconloader.h>
 #include <klocale.h>
 
 #include "../../interfaces/icore.h"
 #include <interfaces/idebugcontroller.h>
 #include "../interfaces/ivariablecontroller.h"
 #include "variablecollection.h"
 
 /** The variables widget is passive, and is invoked by the rest of the
     code via two main Q_SLOTS:
     - slotDbgStatus
     - slotCurrentFrame
 
     The first is received the program status changes and the second is
     received after current frame in the debugger can possibly changes.
 
     The widget has a list item for each frame/thread combination, with
     variables as children. However, at each moment only one item is shown.
     When handling the slotCurrentFrame, we check if variables for the
     current frame are available. If yes, we simply show the corresponding item.
     Otherwise, we fetch the new data from debugger.
 
     Fetching the data is done by emitting the produceVariablesInfo signal.
     In response, we get slotParametersReady and slotLocalsReady signal,
     in that order.
 
     The data is parsed and changed variables are highlighted. After that,
     we 'trim' variable items that were not reported by gdb -- that is, gone
     out of scope.
 */
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
 namespace KDevelop
 {
 
 VariableCollection *variableCollection()
 {
     return ICore::self()->debugController()->variableCollection();
 }
 
 
 VariableWidget::VariableWidget(IDebugController* controller, QWidget *parent)
 : QWidget(parent), variablesRoot_(controller->variableCollection()->root())
 {
   //setWindowIcon(KIcon("math_brace"));
     setWindowIcon(KIcon("debugger"));
     setWindowTitle(i18n("Debugger Variables"));
 
     varTree_ = new VariableTree(controller, this);
     setFocusProxy(varTree_);
 
     watchVarEditor_ = new KHistoryComboBox( this );
 
     QVBoxLayout *topLayout = new QVBoxLayout(this);
     topLayout->addWidget(varTree_, 10);
     topLayout->addWidget(watchVarEditor_);
     topLayout->setMargin(0);
 
     connect(watchVarEditor_, SIGNAL(returnPressed(QString)),
             this, SLOT(slotAddWatch(QString)));
 
     //TODO
     //connect(plugin, SIGNAL(raiseVariableViews()), this, SIGNAL(requestRaise()));
 
     // Setup help items.
 
     setWhatsThis( i18n(
         "<b>Variable tree</b>"
         "The variable tree allows you to see the values of local "
         "variables and arbitrary expressions.<br />"
         "Local variables are displayed automatically and are updated "
         "as you step through your program. "
         "For each expression you enter, you can either evaluate it once, "
         "or \"watch\" it (make it auto-updated). Expressions that are not "
         "auto-updated can be updated manually from the context menu. "
         "Expressions can be renamed to more descriptive names by clicking "
         "on the name column.<br />"
         "To change the value of a variable or an expression, "
         "click on the value.<br />"));
 
     watchVarEditor_->setWhatsThis(
                     i18n("<b>Expression entry</b>"
                          "Type in expression to watch."));
 
 }
 
 void VariableWidget::slotAddWatch(const QString &expression)
 {
     if (!expression.isEmpty())
     {
         watchVarEditor_->addToHistory(expression);
         kDebug(9012) << "Trying to add watch\n";
         Variable* v = variablesRoot_->watches()->add(expression);
         if (v) {
             QModelIndex index = variableCollection()->indexForItem(v, 0);
             /* For watches on structures, we really do want them to be shown
             expanded.  Except maybe for structure with custom pretty printing,
             but will handle that later.
             FIXME: it does not actually works now.
             */
             //varTree_->setExpanded(index, true);
         }
         watchVarEditor_->clearEditText();
     }
 }
 
 void VariableWidget::hideEvent(QHideEvent* e)
 {
     QWidget::hideEvent(e);
     variableCollection()->variableWidgetHidden();
 }
 
 void VariableWidget::showEvent(QShowEvent* e)
 {
     QWidget::showEvent(e);
     variableCollection()->variableWidgetShown();
 }
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
 VariableTree::VariableTree(IDebugController *controller,
                            VariableWidget *parent)
 : AsyncTreeView(controller->variableCollection(), parent)
 #if 0
 ,
       activePopup_(0),
       toggleWatch_(0)
 #endif
 {
     setRootIsDecorated(true);
     setAllColumnsShowFocus(true);
 
     QModelIndex index = controller->variableCollection()->indexForItem(
         controller->variableCollection()->watches(), 0);
     setExpanded(index, true);
     
     m_signalMapper = new QSignalMapper(this);
     setupActions();
 }
 
 
 VariableCollection* VariableTree::collection() const
 {
     Q_ASSERT(qobject_cast<VariableCollection*>(model()));
     return static_cast<VariableCollection*>(model());
 }
 
 
 VariableTree::~VariableTree()
 {
 }
 
 void VariableTree::setupActions()
 {
     // TODO decorate this properly to make nice menu title
     m_contextMenuTitle = new QAction(this);
     m_contextMenuTitle->setEnabled(false);
     
     // make Format menu action group
     m_formatMenu = new QMenu(i18n("&Format"), this);
     QActionGroup *ag= new QActionGroup(m_formatMenu);
     
     QAction* act;
     
     act = new QAction(i18n("&Natural"), ag);
     act->setData(Variable::Natural);
     act->setShortcut(Qt::Key_N);
     m_formatMenu->addAction(act);
 
     act = new QAction(i18n("&Binary"), ag);
     act->setData(Variable::Binary);
     act->setShortcut(Qt::Key_B);
     m_formatMenu->addAction(act);
        
     act = new QAction(i18n("&Octal"), ag);
     act->setData(Variable::Octal);
     act->setShortcut(Qt::Key_O);
     m_formatMenu->addAction(act);
     
     act = new QAction(i18n("&Decimal"), ag);
     act->setData(Variable::Decimal);
     act->setShortcut(Qt::Key_D);
     m_formatMenu->addAction(act);
     
     act = new QAction(i18n("&Hexadecimal"), ag);
     act->setData(Variable::Hexadecimal);
     act->setShortcut(Qt::Key_H);
     m_formatMenu->addAction(act);
     
     foreach(QAction* act, m_formatMenu->actions())
     {
         act->setCheckable(true);
         act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
         m_signalMapper->setMapping(act, act->data().toInt());
         connect(act, SIGNAL(triggered()), m_signalMapper, SLOT(map()));
         addAction(act);
     }
     connect(m_signalMapper, SIGNAL(mapped(int)), SLOT(changeVariableFormat(int)));
     
     m_watchDelete = new QAction(
         KIcon("edit-delete"), i18n( "Remove Watch Variable" ), this);
 
     m_watchDelete->setShortcut(Qt::Key_Delete);
     m_watchDelete->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     addAction(m_watchDelete);
     connect(m_watchDelete, SIGNAL(triggered(bool)), SLOT(watchDelete()));
 
     m_copyVariableValue = new QAction(i18n("&Copy Value"), this);
     m_copyVariableValue->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     m_copyVariableValue->setShortcut(QKeySequence::Copy);
     connect(m_copyVariableValue, SIGNAL(triggered(bool)), SLOT(copyVariableValue()));
 
-    m_stopOnChange = new QAction(i18n("&Stop on change"), this);
+    m_stopOnChange = new QAction(i18n("&Stop on Change"), this);
     connect(m_stopOnChange, SIGNAL(triggered(bool)), SLOT(stopOnChange()));
 }
 
 Variable* VariableTree::selectedVariable() const
 {
     if (selectionModel()->selectedRows().isEmpty()) return 0;
     TreeItem* item = collection()->itemForIndex(selectionModel()->selectedRows().first());
     if (!item) return 0;
     return dynamic_cast<Variable*>(item);
 }
 
 void VariableTree::contextMenuEvent(QContextMenuEvent* event)
 {
     if (!selectedVariable()) return;
 
     // set up menu
     QMenu contextMenu(this->parentWidget());
     m_contextMenuTitle->setText(selectedVariable()->expression());
     contextMenu.addAction(m_contextMenuTitle);
     
     if(selectedVariable()->canSetFormat())
         contextMenu.addMenu(m_formatMenu);
 
     foreach(QAction* act, m_formatMenu->actions()) {
         if(act->data().toInt()==selectedVariable()->format())
             act->setChecked(true);
     }
 
     if (dynamic_cast<Watches*>(selectedVariable()->parent())) {
         contextMenu.addAction(m_watchDelete);
     }
 
     contextMenu.addSeparator();
     contextMenu.addAction(m_copyVariableValue);
     contextMenu.addAction(m_stopOnChange);
 
     contextMenu.exec(event->globalPos());
 }
 
 void VariableTree::changeVariableFormat(int format)
 {
     if (!selectedVariable()) return;
     selectedVariable()->setFormat(static_cast<Variable::format_t>(format));
 }
 
 void VariableTree::watchDelete()
 {
     if (!selectedVariable()) return;
     if (!dynamic_cast<Watches*>(selectedVariable()->parent())) return;
     selectedVariable()->die();
 }
 
 void VariableTree::copyVariableValue()
 {
     if (!selectedVariable()) return;
     QApplication::clipboard()->setText(selectedVariable()->value());
 }
 
 void VariableTree::stopOnChange()
 {
     if (!selectedVariable()) return;
     IDebugSession *session = ICore::self()->debugController()->currentSession();
     if (session && session->state() != IDebugSession::NotStartedState && session->state() != IDebugSession::EndedState) {
         session->variableController()->addWatchpoint(selectedVariable());
     }
 }
 
 #if 0
 void VariableTree::contextMenuEvent(QContextMenuEvent* event)
 {
     QModelIndex index = indexAt(event->pos());
     if (!index.isValid())
         return;
 
     AbstractVariableItem* item = collection()->itemForIndex(index);
 
     if (RecentItem* recent = qobject_cast<RecentItem*>(item))
     {
         KMenu popup(this);
         popup.addTitle(i18n("Recent Expressions"));
         QAction* remove = popup.addAction(KIcon("editdelete"), i18n("Remove All"));
         QAction* reevaluate = popup.addAction(KIcon("reload"), i18n("Re-evaluate All"));
 
         if (controller()->stateIsOn(s_dbgNotStarted))
             reevaluate->setEnabled(false);
 
         QAction* res = popup.exec(QCursor::pos());
 
         if (res == remove)
         {
             collection()->deleteItem(recent);
         }
         else if (res == reevaluate)
         {
             foreach (AbstractVariableItem* item, recent->children())
             {
                 if (VariableItem* variable = qobject_cast<VariableItem*>(item))
                     variable->updateValue();
             }
         }
     }
     else
     {
         activePopup_ = new KMenu(this);
         KMenu format(this);
 
         QAction* remember = 0;
         QAction* remove = 0;
         QAction* reevaluate = 0;
         QAction* watch = 0;
 
         QAction* natural = 0;
         QAction* hex = 0;
         QAction* decimal = 0;
         QAction* character = 0;
         QAction* binary = 0;
 
 #define MAYBE_DISABLE(action) if (!var->isAlive()) action->setEnabled(false)
 
         VariableItem* var = qobject_cast<VariableItem*>(item);
 
         AbstractVariableItem* root = item->abstractRoot();
 
         RecentItem* recentRoot = qobject_cast<RecentItem*>(root);
 
         if (!recentRoot)
         {
             remember = activePopup_->addAction(KIcon("draw-freehand"), i18n("Remember Value"));
             MAYBE_DISABLE(remember);
         }
 
         if (!recentRoot) {
             watch = activePopup_->addAction(i18n("Watch Variable"));
             MAYBE_DISABLE(watch);
         }
 
         if (recentRoot) {
             reevaluate = activePopup_->addAction(KIcon("reload"), i18n("Reevaluate Expression"));
             MAYBE_DISABLE(reevaluate);
             remove = activePopup_->addAction(KIcon("editdelete"), i18n("Remove Expression"));
             remove->setShortcut(Qt::Key_Delete);
         }
 
         if (var)
         {
             toggleWatch_ = activePopup_->addAction( i18n("Data write breakpoint") );
             toggleWatch_->setCheckable(true);
             toggleWatch_->setEnabled(false);
         }
 
         /* This code can be executed when debugger is stopped,
            and we invoke popup menu on a var under "recent expressions"
            just to delete it. */
         if (var && var->isAlive() && !controller()->stateIsOn(s_dbgNotStarted)) {
             GDBCommand* cmd =  new GDBCommand(DataEvaluateExpression,
                                                 QString("&%1")
                                                 .arg(var->gdbExpression()));
             cmd->setHandler(this, &VariableTree::handleAddressComputed, true /*handles error*/);
             cmd->setThread(var->thread());
             cmd->setFrame(var->frame());
             controller_->addCommand(cmd);
         }
 
 
         QAction* res = activePopup_->exec(event->globalPos());
         delete activePopup_;
         activePopup_ = 0;
 
         if (res == remember)
         {
             if (var)
             {
                 ((VariableWidget*)parent())->
                     slotEvaluateExpression(var->gdbExpression());
             }
         }
         else if (res == watch)
         {
             if (var)
             {
                 ((VariableWidget*)parent())->
                     slotAddWatchVariable(var->gdbExpression());
             }
         }
         else if (res == remove)
         {
             delete item;
         }
         else if (res == toggleWatch_)
         {
             if (var)
                 emit toggleWatchpoint(var->gdbExpression());
         }
         else if (res == reevaluate)
         {
             if (var)
             {
                 var->updateValue();
             }
         }
 
         event->accept();
     }
 }
 
 
 void VariableTree::updateCurrentFrame()
 {
 }
 
 // **************************************************************************
 
 void VariableTree::handleAddressComputed(const GDBMI::ResultRecord& r)
 {
     if (r.reason == "error")
     {
         // Not lvalue, leave item disabled.
         return;
     }
 
     if (activePopup_)
     {
         toggleWatch_->setEnabled(true);
 
         //quint64 address = r["value"].literal().toULongLong(0, 16);
         /*if (breakpointWidget_->hasWatchpointForAddress(address))
         {
             toggleWatch_->setChecked(true);
         }*/
     }
 }
 
 VariableCollection * VariableTree::collection() const
 {
     return controller_->variables();
 }
 
 GDBController * VariableTree::controller() const
 {
     return controller_;
 }
 
 void VariableTree::showEvent(QShowEvent * event)
 {
     Q_UNUSED(event)
 
     for (int i = 0; i < model()->columnCount(); ++i)
         resizeColumnToContents(i);
 }
 #endif
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
 }
 
 #include "variablewidget.moc"
diff --git a/language/codegen/basicrefactoring.cpp b/language/codegen/basicrefactoring.cpp
index b3d89bb41c..930eb0d681 100644
--- a/language/codegen/basicrefactoring.cpp
+++ b/language/codegen/basicrefactoring.cpp
@@ -1,298 +1,298 @@
 /* This file is part of KDevelop
  *
  * Copyright 2014 Miquel Sabaté <mikisabate@gmail.com>
  *
  * 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.
  */
 
 
 // Qt
 #include <QAction>
 
 // KDE / KDevelop
 #include <KParts/MainWindow>
 #include <KTextEditor/Document>
 #include <kmessagebox.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocument.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/contextmenuextension.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/navigation/abstractnavigationwidget.h>
 #include <language/codegen/basicrefactoring.h>
 #include <language/interfaces/codecontext.h>
 #include <duchain/use.h>
 
 #include "progressdialogs/refactoringdialog.h"
 
 #include "ui_basicrefactoring.h"
 
 namespace KDevelop
 {
 
 //BEGIN: BasicRefactoringCollector
 
 BasicRefactoringCollector::BasicRefactoringCollector(const IndexedDeclaration &decl)
     : UsesWidgetCollector(decl)
 {
     setCollectConstructors(true);
     setCollectDefinitions(true);
     setCollectOverloads(true);
 }
 
 QVector<IndexedTopDUContext> BasicRefactoringCollector::allUsingContexts() const
 {
     return m_allUsingContexts;
 }
 
 void BasicRefactoringCollector::processUses(KDevelop::ReferencedTopDUContext topContext)
 {
     m_allUsingContexts << IndexedTopDUContext(topContext.data());
     UsesWidgetCollector::processUses(topContext);
 }
 
 //END: BasicRefactoringCollector
 
 //BEGIN: BasicRefactoring
 
 BasicRefactoring::BasicRefactoring(QObject *parent)
     : QObject(parent)
 {
     /* There's nothing to do here. */
 }
 
 void BasicRefactoring::fillContextMenu(ContextMenuExtension &extension, Context *context)
 {
     DeclarationContext *declContext = dynamic_cast<DeclarationContext *>(context);
     if (!declContext)
         return;
 
     DUChainReadLocker lock;
     Declaration *declaration = declContext->declaration().data();
     if (declaration && acceptForContextMenu(declaration)) {
         QFileInfo finfo(declaration->topContext()->url().str());
         if (finfo.isWritable()) {
             QAction *action = new QAction(i18n("Rename \"%1\"...", declaration->qualifiedIdentifier().toString()), 0);
             action->setData(QVariant::fromValue(IndexedDeclaration(declaration)));
             action->setIcon(KIcon("edit-rename"));
             connect(action, SIGNAL(triggered(bool)), this, SLOT(executeRenameAction()));
             extension.addAction(ContextMenuExtension::RefactorGroup, action);
         }
     }
 }
 
 DocumentChangeSet::ChangeResult BasicRefactoring::applyChanges(const QString &oldName, const QString &newName,
                                                                DocumentChangeSet &changes, DUContext *context,
                                                                int usedDeclarationIndex)
 {
     if (usedDeclarationIndex == std::numeric_limits<int>::max())
         return DocumentChangeSet::ChangeResult(true);
 
     for (int a = 0; a < context->usesCount(); ++a) {
         const Use &use(context->uses()[a]);
         if (use.m_declarationIndex != usedDeclarationIndex)
             continue;
         if (use.m_range.isEmpty()) {
             kDebug() << "found empty use";
             continue;
         }
         DocumentChangeSet::ChangeResult result = changes.addChange(DocumentChange(context->url(), context->transformFromLocalRevision(use.m_range), oldName, newName));
         if (!result)
             return result;
     }
 
     foreach (DUContext *child, context->childContexts()) {
         DocumentChangeSet::ChangeResult result = applyChanges(oldName, newName, changes, child, usedDeclarationIndex);
         if (!result)
             return result;
     }
     return DocumentChangeSet::ChangeResult(true);
 }
 
 DocumentChangeSet::ChangeResult BasicRefactoring::applyChangesToDeclarations(const QString &oldName,
                                                                              const QString &newName,
                                                                              DocumentChangeSet &changes,
                                                                              const QList<IndexedDeclaration> &declarations)
 {
     foreach (const IndexedDeclaration &decl, declarations) {
         Declaration *declaration = decl.data();
         if (!declaration)
             continue;
         if (declaration->range().isEmpty())
             kDebug() << "found empty declaration";
 
         TopDUContext *top = declaration->topContext();
         DocumentChangeSet::ChangeResult result = changes.addChange(DocumentChange(top->url(), declaration->rangeInCurrentRevision(), oldName, newName));
         if (!result)
             return result;
     }
     return DocumentChangeSet::ChangeResult(true);
 }
 
 KDevelop::IndexedDeclaration BasicRefactoring::declarationUnderCursor(bool allowUse)
 {
     KDevelop::IDocument *doc = ICore::self()->documentController()->activeDocument();
     if (doc && doc->textDocument() && doc->textDocument()->activeView()) {
         DUChainReadLocker lock;
         if (allowUse)
             return DUChainUtils::itemUnderCursor(doc->url(), SimpleCursor(doc->textDocument()->activeView()->cursorPosition()));
         else
             return DUChainUtils::declarationInLine(SimpleCursor(doc->textDocument()->activeView()->cursorPosition()), DUChainUtils::standardContextForUrl(doc->url()));
     }
 
     return KDevelop::IndexedDeclaration();
 }
 
 void BasicRefactoring::startInteractiveRename(const KDevelop::IndexedDeclaration &decl)
 {
     DUChainReadLocker lock(DUChain::lock());
 
     Declaration *declaration = decl.data();
     if (!declaration) {
         KMessageBox::error(ICore::self()->uiController()->activeMainWindow(), i18n("No declaration under cursor"));
         return;
     }
     QFileInfo info(declaration->topContext()->url().str());
     if (!info.isWritable()) {
         KMessageBox::error(ICore::self()->uiController()->activeMainWindow(),
                            i18n("Declaration is located in non-writeable file %1.", declaration->topContext()->url().str()));
         return;
     }
 
     QString originalName = declaration->identifier().identifier().str();
     lock.unlock();
 
     NameAndCollector nc = newNameForDeclaration(DeclarationPointer(declaration));
 
     if (nc.newName == originalName || nc.newName.isEmpty())
         return;
 
     renameCollectedDeclarations(nc.collector.data(), nc.newName, originalName);
 }
 
 bool BasicRefactoring::acceptForContextMenu(const Declaration *decl)
 {
     // Default implementation. Some language plugins might override it to
     // handle some cases.
     Q_UNUSED(decl);
     return true;
 }
 
 void BasicRefactoring::executeRenameAction()
 {
     QAction *action = qobject_cast<QAction *>(sender());
     if (action) {
         IndexedDeclaration decl = action->data().value<IndexedDeclaration>();
         if(!decl.isValid())
             decl = declarationUnderCursor();
         startInteractiveRename(decl);
     }
 }
 
 BasicRefactoring::NameAndCollector BasicRefactoring::newNameForDeclaration(const KDevelop::DeclarationPointer& declaration)
 {
     DUChainReadLocker lock;
     if (!declaration) {
         return {};
     }
 
     QSharedPointer<BasicRefactoringCollector> collector(new BasicRefactoringCollector(declaration.data()));
 
     Ui::RenameDialog renameDialog;
     QDialog dialog;
     renameDialog.setupUi(&dialog);
 
     UsesWidget uses(declaration.data(), collector);
 
     //So the context-links work
     QWidget *navigationWidget = declaration->context()->createNavigationWidget(declaration.data());
     AbstractNavigationWidget* abstractNavigationWidget = dynamic_cast<AbstractNavigationWidget*>(navigationWidget);
     if (abstractNavigationWidget)
         connect(&uses, SIGNAL(navigateDeclaration(KDevelop::IndexedDeclaration)), abstractNavigationWidget, SLOT(navigateDeclaration(KDevelop::IndexedDeclaration)));
 
-    dialog.setWindowTitle(i18n("Rename %1", declaration->toString()));
+    dialog.setWindowTitle(i18nc("Renaming some declaration", "Rename \"%1\"", declaration->toString()));
     renameDialog.edit->setText(declaration->identifier().identifier().str());
     renameDialog.edit->selectAll();
 
     renameDialog.tabWidget->addTab(&uses, i18n("Uses"));
     if (navigationWidget)
         renameDialog.tabWidget->addTab(navigationWidget, i18n("Declaration Info"));
     lock.unlock();
 
     if (dialog.exec() != QDialog::Accepted)
         return {};
 
     RefactoringProgressDialog refactoringProgress(i18n("Renaming \"%1\" to \"%2\"", declaration->toString(), renameDialog.edit->text()), collector.data());
     if (!collector->isReady()) {
         refactoringProgress.exec();
         if (refactoringProgress.result() != QDialog::Accepted) {
             return {};
         }
     }
 
     //TODO: input validation
     return {renameDialog.edit->text(),collector};
 }
 
 DocumentChangeSet BasicRefactoring::renameCollectedDeclarations(KDevelop::BasicRefactoringCollector* collector, const QString& replacementName, const QString& originalName, bool apply)
 {
     DocumentChangeSet changes;
     DUChainReadLocker lock;
 
     foreach (const KDevelop::IndexedTopDUContext& collected, collector->allUsingContexts()) {
         QSet<int> hadIndices;
         foreach (const IndexedDeclaration& decl, collector->declarations()) {
             uint usedDeclarationIndex = collected.data()->indexForUsedDeclaration(decl.data(), false);
             if (hadIndices.contains(usedDeclarationIndex))
                 continue;
             hadIndices.insert(usedDeclarationIndex);
             DocumentChangeSet::ChangeResult result = applyChanges(originalName, replacementName, changes, collected.data(), usedDeclarationIndex);
             if (!result) {
                 KMessageBox::error(0, i18n("Applying changes failed: %1", result.m_failureReason));
                 return {};
             }
         }
     }
 
     DocumentChangeSet::ChangeResult result = applyChangesToDeclarations(originalName, replacementName, changes, collector->declarations());
     if (!result) {
         KMessageBox::error(0, i18n("Applying changes failed: %1", result.m_failureReason));
         return {};
     }
 
     ///We have to ignore failed changes for now, since uses of a constructor or of operator() may be created on "(" parens
     changes.setReplacementPolicy(DocumentChangeSet::IgnoreFailedChange);
 
     if (!apply) {
         return changes;
     }
 
     result = changes.applyAllChanges();
     if (!result) {
         KMessageBox::error(0, i18n("Applying changes failed: %1", result.m_failureReason));
     }
 
     return {};
 }
 
 //END: BasicRefactoring
 
 } // End of namespace KDevelop
 
 #include "basicrefactoring.moc"