diff --git a/libs/ui/kis_image_manager.cc b/libs/ui/kis_image_manager.cc
index 3703ef4bb5..60da5a906b 100644
--- a/libs/ui/kis_image_manager.cc
+++ b/libs/ui/kis_image_manager.cc
@@ -1,217 +1,217 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006
  *
  *  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 "kis_image_manager.h"
 
 #include <QString>
 #include <QStandardPaths>
 
 #include <QAction>
 #include <QUrl>
 #include <QColorDialog>
 
 #include <klocalizedstring.h>
 
 #include <KoColor.h>
 #include <KoFileDialog.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_icon.h>
 #include <KisImportExportManager.h>
 #include "kis_import_catcher.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "dialogs/kis_dlg_image_properties.h"
 #include "commands/kis_image_commands.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_layer_utils.h"
 
 #include "kis_signal_compressor_with_param.h"
 
 
 KisImageManager::KisImageManager(KisViewManager * view)
         : m_view(view)
 {
 }
 
 void KisImageManager::setView(QPointer<KisView>imageView)
 {
     Q_UNUSED(imageView);
 }
 
 void KisImageManager::setup(KisActionManager *actionManager)
 {
 
     KisAction *action  = actionManager->createAction("import_layer_from_file");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerFromFile()));
 
     action  = actionManager->createAction("image_properties");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageProperties()));
 
     action  = actionManager->createAction("import_layer_as_paint_layer");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerFromFile()));
 
     action  = actionManager->createAction("import_layer_as_transparency_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerAsTransparencyMask()));
 
     action  = actionManager->createAction("import_layer_as_filter_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerAsFilterMask()));
 
     action  = actionManager->createAction("import_layer_as_selection_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerAsSelectionMask()));
 
     action = actionManager->createAction("image_color");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageColor()));
 }
 
 void KisImageManager::slotImportLayerFromFile()
 {
     importImage(QUrl(), "KisPaintLayer");
 }
 
 void KisImageManager::slotImportLayerAsTransparencyMask()
 {
     importImage(QUrl(), "KisTransparencyMask");
 }
 
 void KisImageManager::slotImportLayerAsFilterMask()
 {
     importImage(QUrl(), "KisFilterMask");
 }
 
 void KisImageManager::slotImportLayerAsSelectionMask()
 {
     importImage(QUrl(), "KisSelectionMask");
 }
 
 
 qint32 KisImageManager::importImage(const QUrl &urlArg, const QString &layerType)
 {
     KisImageWSP currentImage = m_view->image();
 
     if (!currentImage) {
         return 0;
     }
 
     QList<QUrl> urls;
     qint32 rc = 0;
 
     if (urlArg.isEmpty()) {
         KoFileDialog dialog(m_view->mainWindow(), KoFileDialog::OpenFiles, "OpenDocument");
         dialog.setCaption(i18n("Import Image"));
         dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
         dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
         QStringList fileNames = dialog.filenames();
         Q_FOREACH (const QString &fileName, fileNames) {
             urls << QUrl::fromLocalFile(fileName);
         }
 
     } else {
         urls.push_back(urlArg);
     }
 
     if (urls.empty()) {
         return 0;
     }
 
     Q_FOREACH(const QUrl &url, urls) {
         if (url.toLocalFile().endsWith("svg")) {
             new KisImportCatcher(url, m_view, "KisShapeLayer");
         }
         else {
             new KisImportCatcher(url, m_view, layerType);
         }
     }
 
     m_view->canvas()->update();
 
     return rc;
 }
 
 void KisImageManager::resizeCurrentImage(qint32 w, qint32 h, qint32 xOffset, qint32 yOffset)
 {
     if (!m_view->image()) return;
 
     m_view->image()->resizeImage(QRect(-xOffset, -yOffset, w, h));
 }
 
 void KisImageManager::scaleCurrentImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
 {
     if (!m_view->image()) return;
     m_view->image()->scaleImage(size, xres, yres, filterStrategy);
 }
 
 void KisImageManager::rotateCurrentImage(double radians)
 {
     if (!m_view->image()) return;
     m_view->image()->rotateImage(radians);
 }
 
 void KisImageManager::shearCurrentImage(double angleX, double angleY)
 {
     if (!m_view->image()) return;
     m_view->image()->shear(angleX, angleY);
 }
 
 
 void KisImageManager::slotImageProperties()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     QPointer<KisDlgImageProperties> dlg = new KisDlgImageProperties(image, m_view->mainWindow());
     if (dlg->exec() == QDialog::Accepted) {
         image->convertProjectionColorSpace(dlg->colorSpace());
     }
     delete dlg;
 }
 
 void updateImageBackgroundColor(KisImageSP image, const QColorDialog *dlg)
 {
     QColor newColor = dlg->currentColor();
     KoColor bg = image->defaultProjectionColor();
     bg.fromQColor(newColor);
 
     KisLayerUtils::changeImageDefaultProjectionColor(image, bg);
 }
 
 void KisImageManager::slotImageColor()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     QColorDialog dlg;
     dlg.setOption(QColorDialog::ShowAlphaChannel, true);
-
+    dlg.setWindowTitle(i18n("Select a Color"));
     KoColor bg = image->defaultProjectionColor();
     dlg.setCurrentColor(bg.toQColor());
 
     KisSignalCompressor compressor(200, KisSignalCompressor::FIRST_INACTIVE);
 
     std::function<void ()> updateCall(std::bind(updateImageBackgroundColor, image, &dlg));
     SignalToFunctionProxy proxy(updateCall);
 
     connect(&dlg, SIGNAL(currentColorChanged(QColor)), &compressor, SLOT(start()));
     connect(&compressor, SIGNAL(timeout()), &proxy, SLOT(start()));
 
     dlg.exec();
 }
 
 
diff --git a/libs/ui/widgets/KoDualColorButton.cpp b/libs/ui/widgets/KoDualColorButton.cpp
index dde55e9377..7bba0de001 100644
--- a/libs/ui/widgets/KoDualColorButton.cpp
+++ b/libs/ui/widgets/KoDualColorButton.cpp
@@ -1,406 +1,406 @@
 /* This file is part of the KDE libraries
    Copyright (C) 1999 Daniel M. Duley <mosfet@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 version 2 as published by the Free Software Foundation.
 
    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 "KoDualColorButton.h"
 #include "KoColor.h"
 #include "KoColorDisplayRendererInterface.h"
 #include <kcolormimedata.h>
 
 #include "dcolorarrow.xbm"
 #include "dcolorreset.xpm"
 
 #include <QColorDialog>
 #include "KisDlgInternalColorSelector.h"
 
 #include "kis_signals_blocker.h"
 
 #include <QBrush>
 #include <QDrag>
 #include <QDragEnterEvent>
 #include <QPainter>
 #include <qdrawutil.h>
 #include <QApplication>
 
 class Q_DECL_HIDDEN KoDualColorButton::Private
 {
   public:
     Private(const KoColor &fgColor, const KoColor &bgColor,
             QWidget *_dialogParent,
             const KoColorDisplayRendererInterface *_displayRenderer)
         : dialogParent(_dialogParent)
         , dragFlag( false )
         , miniCtlFlag( false )
         , foregroundColor(fgColor)
         , backgroundColor(bgColor)
 
         , displayRenderer(_displayRenderer)
     {
         updateArrows();
         resetPixmap = QPixmap( (const char **)dcolorreset_xpm );
 
         popDialog = true;
     }
 
     void updateArrows() {
         arrowBitmap = QPixmap(12,12);
         arrowBitmap.fill(Qt::transparent);
 
         QPainter p(&arrowBitmap);
         p.setPen(dialogParent->palette().foreground().color());
 
         // arrow pointing left
         p.drawLine(0, 3, 7, 3);
         p.drawLine(1, 2, 1, 4);
         p.drawLine(2, 1, 2, 5);
         p.drawLine(3, 0, 3, 6);
 
         // arrow pointing down
         p.drawLine(8, 4, 8, 11);
         p.drawLine(5, 8, 11, 8);
         p.drawLine(6, 9, 10, 9);
         p.drawLine(7, 10, 9, 10);
     }
 
     QWidget* dialogParent;
 
     QPixmap arrowBitmap;
     QPixmap resetPixmap;
     bool dragFlag, miniCtlFlag;
     KoColor foregroundColor;
     KoColor backgroundColor;
     KisDlgInternalColorSelector *colorSelectorDialog;
     QPoint dragPosition;
     Selection tmpSelection;
     bool popDialog;
     const KoColorDisplayRendererInterface *displayRenderer;
 
     void init(KoDualColorButton *q);
 };
 
 void KoDualColorButton::Private::init(KoDualColorButton *q)
 {
     if ( q->sizeHint().isValid() )
         q->setMinimumSize( q->sizeHint() );
 
     q->setAcceptDrops( true );
-    QString caption = i18n("Select a color");
+    QString caption = i18n("Select a Color");
     KisDlgInternalColorSelector::Config config = KisDlgInternalColorSelector::Config();
     config.modal = false;
     colorSelectorDialog = new KisDlgInternalColorSelector(q, foregroundColor, config, caption, displayRenderer);
     connect(colorSelectorDialog, SIGNAL(signalForegroundColorChosen(KoColor)), q, SLOT(slotSetForeGroundColorFromDialog(KoColor)));
     connect(q, SIGNAL(foregroundColorChanged(KoColor)), colorSelectorDialog, SLOT(slotColorUpdated(KoColor)));
 }
 
 KoDualColorButton::KoDualColorButton(const KoColor &foregroundColor, const KoColor &backgroundColor, QWidget *parent, QWidget* dialogParent )
     : QWidget( parent ),
       d( new Private(foregroundColor, backgroundColor,
                      dialogParent,
                      KoDumbColorDisplayRenderer::instance()) )
 {
     d->init(this);
 }
 
 KoDualColorButton::KoDualColorButton(const KoColor &foregroundColor, const KoColor &backgroundColor,
                                      const KoColorDisplayRendererInterface *displayRenderer,
                                      QWidget *parent, QWidget* dialogParent)
     : QWidget( parent ),
       d( new Private(foregroundColor, backgroundColor,
                      dialogParent,
                      displayRenderer) )
 {
     d->init(this);
 }
 
 KoDualColorButton::~KoDualColorButton()
 {
   delete d;
 }
 
 KoColor KoDualColorButton::foregroundColor() const
 {
   return d->foregroundColor;
 }
 
 KoColor KoDualColorButton::backgroundColor() const
 {
   return d->backgroundColor;
 }
 
 bool KoDualColorButton::popDialog() const
 {
   return d->popDialog;
 }
 
 QSize KoDualColorButton::sizeHint() const
 {
   return QSize( 34, 34 );
 }
 
 void KoDualColorButton::setForegroundColor( const KoColor &color )
 {
   d->foregroundColor = color;
   {
       /**
        * The internal color selector might emit the color of a different profile, so
        * we should break this cycling dependency somehow.
        */
       KisSignalsBlocker b(d->colorSelectorDialog);
       d->colorSelectorDialog->slotColorUpdated(color);
   }
   repaint();
 }
 
 void KoDualColorButton::setBackgroundColor( const KoColor &color )
 {
   d->backgroundColor = color;
   repaint();
 }
 
 void KoDualColorButton::setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer)
 {
     if (displayRenderer) {
         d->displayRenderer = displayRenderer;
         d->colorSelectorDialog->setDisplayRenderer(displayRenderer);
         connect(d->displayRenderer, SIGNAL(destroyed()), this, SLOT(setDisplayRenderer()), Qt::UniqueConnection);
     } else {
         d->displayRenderer = KoDumbColorDisplayRenderer::instance();
     }
 }
 
 void KoDualColorButton::setColorSpace(const KoColorSpace *cs)
 {
     d->colorSelectorDialog->lockUsedColorSpace(cs);
 }
 
 QColor KoDualColorButton::getColorFromDisplayRenderer(KoColor c)
 {
     QColor col;
     if (d->displayRenderer) {
         c.convertTo(d->displayRenderer->getPaintingColorSpace());
         col = d->displayRenderer->toQColor(c);
     } else {
         col = c.toQColor();
     }
     return col;
 }
 
 void KoDualColorButton::setPopDialog( bool popDialog )
 {
   d->popDialog = popDialog;
 }
 
 void KoDualColorButton::metrics( QRect &foregroundRect, QRect &backgroundRect )
 {
   foregroundRect = QRect( 0, 0, width() - 14, height() - 14 );
   backgroundRect = QRect( 14, 14, width() - 14, height() - 14 );
 }
 
 void KoDualColorButton::paintEvent(QPaintEvent *)
 {
   QRect foregroundRect;
   QRect backgroundRect;
 
   QPainter painter( this );
 
   metrics( foregroundRect, backgroundRect );
 
   QBrush defBrush = palette().brush( QPalette::Button );
   QBrush foregroundBrush( getColorFromDisplayRenderer(d->foregroundColor), Qt::SolidPattern );
   QBrush backgroundBrush( getColorFromDisplayRenderer(d->backgroundColor), Qt::SolidPattern );
 
   qDrawShadeRect( &painter, backgroundRect, palette(), false, 1, 0,
                   isEnabled() ? &backgroundBrush : &defBrush );
 
   qDrawShadeRect( &painter, foregroundRect, palette(), false, 1, 0,
                   isEnabled() ? &foregroundBrush : &defBrush );
 
   painter.setPen( palette().color( QPalette::Shadow ) );
 
   painter.drawPixmap( foregroundRect.right() + 2, 1, d->arrowBitmap );
   painter.drawPixmap( 1, foregroundRect.bottom() + 2, d->resetPixmap );
 }
 
 void KoDualColorButton::dragEnterEvent( QDragEnterEvent *event )
 {
   event->setAccepted( isEnabled() && KColorMimeData::canDecode( event->mimeData() ) );
 }
 
 void KoDualColorButton::dropEvent( QDropEvent *event )
 {
     Q_UNUSED(event);
 /*  QColor color = KColorMimeData::fromMimeData( event->mimeData() );
 
   if ( color.isValid() ) {
     if ( d->selection == Foreground ) {
       d->foregroundColor = color;
       emit foregroundColorChanged( color );
     } else {
       d->backgroundColor = color;
       emit backgroundColorChanged( color );
     }
 
     repaint();
   }
 */
 }
 
 void KoDualColorButton::slotSetForeGroundColorFromDialog(const KoColor color)
 {
     d->foregroundColor = color;
     repaint();
     emit foregroundColorChanged(d->foregroundColor);
 }
 
 void KoDualColorButton::mousePressEvent( QMouseEvent *event )
 {
   QRect foregroundRect;
   QRect backgroundRect;
 
   metrics( foregroundRect, backgroundRect );
 
   d->dragPosition = event->pos();
 
   d->dragFlag = false;
 
   if ( foregroundRect.contains( d->dragPosition ) ) {
     d->tmpSelection = Foreground;
     d->miniCtlFlag = false;
   }
   else if( backgroundRect.contains( d->dragPosition ) ) {
     d->tmpSelection = Background;
     d->miniCtlFlag = false;
   }
   else if ( event->pos().x() > foregroundRect.width() ) {
     // We handle the swap and reset controls as soon as the mouse is
     // is pressed and ignore further events on this click (mosfet).
 
     KoColor tmp = d->foregroundColor;
     d->foregroundColor = d->backgroundColor;
     d->backgroundColor = tmp;
 
     emit backgroundColorChanged( d->backgroundColor );
     emit foregroundColorChanged( d->foregroundColor );
 
     d->miniCtlFlag = true;
   }
   else if ( event->pos().x() < backgroundRect.x() ) {
     d->foregroundColor = d->displayRenderer->approximateFromRenderedQColor(Qt::black);
     d->backgroundColor = d->displayRenderer->approximateFromRenderedQColor(Qt::white);
 
     emit backgroundColorChanged( d->backgroundColor );
     emit foregroundColorChanged( d->foregroundColor );
 
     d->miniCtlFlag = true;
   }
   repaint();
 }
 
 
 void KoDualColorButton::mouseMoveEvent( QMouseEvent *event )
 {
   if ( !d->miniCtlFlag ) {
     int delay = QApplication::startDragDistance();
 
     if ( event->x() >= d->dragPosition.x() + delay || event->x() <= d->dragPosition.x() - delay ||
          event->y() >= d->dragPosition.y() + delay || event->y() <= d->dragPosition.y() - delay ) {
       KColorMimeData::createDrag( d->tmpSelection == Foreground ?
                                   getColorFromDisplayRenderer(d->foregroundColor) :
                                   getColorFromDisplayRenderer(d->backgroundColor),
                                   this )->start();
       d->dragFlag = true;
     }
   }
 }
 
 void KoDualColorButton::mouseReleaseEvent( QMouseEvent *event )
 {
     d->dragFlag = false;
 
     if ( d->miniCtlFlag )
         return;
 
     d->miniCtlFlag = false;
 
     QRect foregroundRect;
     QRect backgroundRect;
     metrics( foregroundRect, backgroundRect );
 
     if (foregroundRect.contains( event->pos())) {
         if (d->tmpSelection == Foreground) {
             if (d->popDialog) {
 #ifndef Q_OS_OSX
                 d->colorSelectorDialog->setPreviousColor(d->foregroundColor);
                 //this should toggle, but I don't know how to implement that...
                 d->colorSelectorDialog->show();
 #else
                 QColor c = d->displayRenderer->toQColor(d->foregroundColor);
                 c = QColorDialog::getColor(c, this);
                 if (c.isValid()) {
                     d->foregroundColor = d->displayRenderer->approximateFromRenderedQColor(c);
                     emit foregroundColorChanged(d->foregroundColor);
                 }
 #endif
             }
             else {
                 emit pleasePopDialog(d->foregroundColor);
             }
         }
         else {
             d->foregroundColor = d->backgroundColor;
             emit foregroundColorChanged( d->foregroundColor );
         }
     } else if ( backgroundRect.contains( event->pos() )) {
         if(d->tmpSelection == Background ) {
             if( d->popDialog) {
 #ifndef Q_OS_OSX
                 KoColor c = d->backgroundColor;
                 c = KisDlgInternalColorSelector::getModalColorDialog(c, this);
                 d->backgroundColor = c;
                 emit backgroundColorChanged(d->backgroundColor);
 #else
                 QColor c = d->displayRenderer->toQColor(d->backgroundColor);
                 c = QColorDialog::getColor(c, this);
                 if (c.isValid()) {
                     d->backgroundColor = d->displayRenderer->approximateFromRenderedQColor(c);
                     emit backgroundColorChanged(d->backgroundColor);
                 }
 #endif
             }
             else
                 emit pleasePopDialog( d->backgroundColor);
         } else {
             d->backgroundColor = d->foregroundColor;
             emit backgroundColorChanged( d->backgroundColor );
         }
     }
 
     repaint();
 }
 
 void KoDualColorButton::changeEvent(QEvent *event)
 {
     QWidget::changeEvent(event);
 
     switch (event->type()) {
     case QEvent::StyleChange:
     case QEvent::PaletteChange:
         d->updateArrows();
     default:
         break;
     }
 }