diff --git a/src/History.cpp b/src/History.cpp
index 64b589ec..c2660ee5 100644
--- a/src/History.cpp
+++ b/src/History.cpp
@@ -1,669 +1,676 @@
 /*
     This file is part of Konsole, an X terminal.
     Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
 
     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.
 */
 
 // Own
 #include "History.h"
 
 #include "konsoledebug.h"
+#include "KonsoleSettings.h"
 
 // System
 #include <stdlib.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <errno.h>
 
 // KDE
 #include <QDir>
 #include <qplatformdefs.h>
 #include <QStandardPaths>
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 // Reasonable line size
 static const int LINE_SIZE = 1024;
 
 using namespace Konsole;
 
 Q_GLOBAL_STATIC(QString, historyFileLocation)
 
 /*
    An arbitrary long scroll.
 
    One can modify the scroll only by adding either cells
    or newlines, but access it randomly.
 
    The model is that of an arbitrary wide typewriter scroll
    in that the scroll is a series of lines and each line is
    a series of cells with no overwriting permitted.
 
    The implementation provides arbitrary length and numbers
    of cells and line/column indexed read access to the scroll
    at constant costs.
 */
 
 // History File ///////////////////////////////////////////
 HistoryFile::HistoryFile()
     : _fd(-1),
       _length(0),
       _fileMap(0),
       _readWriteBalance(0)
 {
     // Determine the temp directory once
     // This class is called 3 times for each "unlimited" scrollback.
     // This has the down-side that users must restart to
-    // load changes (currently only 2 choices).
+    // load changes.
     if (!historyFileLocation.exists()) {
         KConfigGroup configGroup(KSharedConfig::openConfig(), "FileLocation");
         if (configGroup.readEntry("scrollbackUseCacheLocation", false)) {
             *historyFileLocation() = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
+        } else if (configGroup.readEntry("scrollbackUseSpecifiedLocation", false)) {
+            const QUrl specifiedUrl = KonsoleSettings::scrollbackUseSpecifiedLocationDirectory();
+            *historyFileLocation() = specifiedUrl.path();
         } else {
             *historyFileLocation() = QDir::tempPath();
         }
-        QDir().mkpath(*historyFileLocation());
+        if (!QDir().mkpath(*historyFileLocation())) {
+            qCWarning(KonsoleDebug)<<"Unable to create scrollback folder "<<*historyFileLocation()<<" using "<<QDir::homePath();
+            *historyFileLocation() = QDir::homePath();
+        }
     }
     const QString tmpDir = *historyFileLocation();
     const QString tmpFormat = tmpDir + QLatin1Char('/') + QLatin1String("konsole-XXXXXX.history");
     _tmpFile.setFileTemplate(tmpFormat);
     if (_tmpFile.open()) {
         _tmpFile.setAutoRemove(true);
         _fd = _tmpFile.handle();
     }
 }
 
 HistoryFile::~HistoryFile()
 {
     if (_fileMap != nullptr)
         unmap();
 }
 
 //TODO:  Mapping the entire file in will cause problems if the history file becomes exceedingly large,
 //(ie. larger than available memory).  HistoryFile::map() should only map in sections of the file at a time,
 //to avoid this.
 void HistoryFile::map()
 {
     Q_ASSERT(_fileMap == 0);
 
     _fileMap = (char*)mmap(0 , _length , PROT_READ , MAP_PRIVATE , _fd , 0);
 
     //if mmap'ing fails, fall back to the read-lseek combination
     if (_fileMap == MAP_FAILED) {
         _readWriteBalance = 0;
         _fileMap = 0;
         qCDebug(KonsoleDebug) << "mmap'ing history failed.  errno = " << errno;
     }
 }
 
 void HistoryFile::unmap()
 {
     int result = munmap(_fileMap , _length);
     Q_ASSERT(result == 0);
     Q_UNUSED(result);
 
     _fileMap = 0;
 }
 
 bool HistoryFile::isMapped() const
 {
     return (_fileMap != 0);
 }
 
 void HistoryFile::add(const unsigned char* buffer, int count)
 {
     if (_fileMap != nullptr)
         unmap();
 
     _readWriteBalance++;
 
     int rc = 0;
 
     rc = QT_LSEEK(_fd, _length, SEEK_SET);
     if (rc < 0) {
         perror("HistoryFile::add.seek");
         return;
     }
     rc = write(_fd, buffer, count);
     if (rc < 0) {
         perror("HistoryFile::add.write");
         return;
     }
     _length += rc;
 }
 
 void HistoryFile::get(unsigned char* buffer, int size, int loc)
 {
     //count number of get() calls vs. number of add() calls.
     //If there are many more get() calls compared with add()
     //calls (decided by using MAP_THRESHOLD) then mmap the log
     //file to improve performance.
     _readWriteBalance--;
     if ((_fileMap == nullptr) && _readWriteBalance < MAP_THRESHOLD)
         map();
 
     if (loc < 0 || size < 0 || loc + size > _length) {
         fprintf(stderr, "getHist(...,%d,%d): invalid args.\n", size, loc);
         return;
     }
 
     if (_fileMap != nullptr) {
         for (int i = 0; i < size; i++)
             buffer[i] = _fileMap[loc + i];
     } else {
         int rc = 0;
 
         rc = QT_LSEEK(_fd, loc, SEEK_SET);
         if (rc < 0) {
             perror("HistoryFile::get.seek");
             return;
         }
         rc = read(_fd, buffer, size);
         if (rc < 0) {
             perror("HistoryFile::get.read");
             return;
         }
     }
 }
 
 int HistoryFile::len() const
 {
     return _length;
 }
 
 // History Scroll abstract base class //////////////////////////////////////
 
 HistoryScroll::HistoryScroll(HistoryType* t)
     : _historyType(t)
 {
 }
 
 HistoryScroll::~HistoryScroll()
 {
     delete _historyType;
 }
 
 bool HistoryScroll::hasScroll()
 {
     return true;
 }
 
 // History Scroll File //////////////////////////////////////
 
 /*
    The history scroll makes a Row(Row(Cell)) from
    two history buffers. The index buffer contains
    start of line positions which refer to the cells
    buffer.
 
    Note that index[0] addresses the second line
    (line #1), while the first line (line #0) starts
    at 0 in cells.
 */
 
 HistoryScrollFile::HistoryScrollFile(const QString& logFileName)
     : HistoryScroll(new HistoryTypeFile(logFileName))
 {
 }
 
 HistoryScrollFile::~HistoryScrollFile() = default;
 
 int HistoryScrollFile::getLines()
 {
     return _index.len() / sizeof(int);
 }
 
 int HistoryScrollFile::getLineLen(int lineno)
 {
     return (startOfLine(lineno + 1) - startOfLine(lineno)) / sizeof(Character);
 }
 
 bool HistoryScrollFile::isWrappedLine(int lineno)
 {
     if (lineno >= 0 && lineno <= getLines()) {
         unsigned char flag = 0;
         _lineflags.get((unsigned char*)&flag, sizeof(unsigned char), (lineno)*sizeof(unsigned char));
         return flag != 0u;
     }
     return false;
 }
 
 int HistoryScrollFile::startOfLine(int lineno)
 {
     if (lineno <= 0) return 0;
     if (lineno <= getLines()) {
         if (!_index.isMapped())
             _index.map();
 
         int res;
         _index.get((unsigned char*)&res, sizeof(int), (lineno - 1)*sizeof(int));
         return res;
     }
     return _cells.len();
 }
 
 void HistoryScrollFile::getCells(int lineno, int colno, int count, Character res[])
 {
     _cells.get((unsigned char*)res, count * sizeof(Character), startOfLine(lineno) + colno * sizeof(Character));
 }
 
 void HistoryScrollFile::addCells(const Character text[], int count)
 {
     _cells.add((unsigned char*)text, count * sizeof(Character));
 }
 
 void HistoryScrollFile::addLine(bool previousWrapped)
 {
     if (_index.isMapped())
         _index.unmap();
 
     int locn = _cells.len();
     _index.add((unsigned char*)&locn, sizeof(int));
     unsigned char flags = previousWrapped ? 0x01 : 0x00;
     _lineflags.add((unsigned char*)&flags, sizeof(unsigned char));
 }
 
 // History Scroll None //////////////////////////////////////
 
 HistoryScrollNone::HistoryScrollNone()
     : HistoryScroll(new HistoryTypeNone())
 {
 }
 
 HistoryScrollNone::~HistoryScrollNone() = default;
 
 bool HistoryScrollNone::hasScroll()
 {
     return false;
 }
 
 int  HistoryScrollNone::getLines()
 {
     return 0;
 }
 
 int  HistoryScrollNone::getLineLen(int)
 {
     return 0;
 }
 
 bool HistoryScrollNone::isWrappedLine(int /*lineno*/)
 {
     return false;
 }
 
 void HistoryScrollNone::getCells(int, int, int, Character [])
 {
 }
 
 void HistoryScrollNone::addCells(const Character [], int)
 {
 }
 
 void HistoryScrollNone::addLine(bool)
 {
 }
 
 ////////////////////////////////////////////////////////////////
 // Compact History Scroll //////////////////////////////////////
 ////////////////////////////////////////////////////////////////
 void* CompactHistoryBlock::allocate(size_t size)
 {
     Q_ASSERT(size > 0);
     if (_tail - _blockStart + size > _blockLength)
         return 0;
 
     void* block = _tail;
     _tail += size;
     ////qDebug() << "allocated " << length << " bytes at address " << block;
     _allocCount++;
     return block;
 }
 
 void CompactHistoryBlock::deallocate()
 {
     _allocCount--;
     Q_ASSERT(_allocCount >= 0);
 }
 
 void* CompactHistoryBlockList::allocate(size_t size)
 {
     CompactHistoryBlock* block;
     if (list.isEmpty() || list.last()->remaining() < size) {
         block = new CompactHistoryBlock();
         list.append(block);
         ////qDebug() << "new block created, remaining " << block->remaining() << "number of blocks=" << list.size();
     } else {
         block = list.last();
         ////qDebug() << "old block used, remaining " << block->remaining();
     }
     return block->allocate(size);
 }
 
 void CompactHistoryBlockList::deallocate(void* ptr)
 {
     Q_ASSERT(!list.isEmpty());
 
     int i = 0;
     CompactHistoryBlock* block = list.at(i);
     while (i < list.size() && !block->contains(ptr)) {
         i++;
         block = list.at(i);
     }
 
     Q_ASSERT(i < list.size());
 
     block->deallocate();
 
     if (!block->isInUse()) {
         list.removeAt(i);
         delete block;
         ////qDebug() << "block deleted, new size = " << list.size();
     }
 }
 
 CompactHistoryBlockList::~CompactHistoryBlockList()
 {
     qDeleteAll(list.begin(), list.end());
     list.clear();
 }
 
 void* CompactHistoryLine::operator new(size_t size, CompactHistoryBlockList& blockList)
 {
     return blockList.allocate(size);
 }
 
 CompactHistoryLine::CompactHistoryLine(const TextLine& line, CompactHistoryBlockList& bList)
     : _blockListRef(bList),
       _formatArray(0),
       _text(0),
       _formatLength(0),
       _wrapped(false)
 {
     _length = line.size();
 
     if (line.size() > 0) {
         _formatLength = 1;
         int k = 1;
 
         // count number of different formats in this text line
         Character c = line[0];
         while (k < _length) {
             if (!(line[k].equalsFormat(c))) {
                 _formatLength++; // format change detected
                 c = line[k];
             }
             k++;
         }
 
         ////qDebug() << "number of different formats in string: " << _formatLength;
         _formatArray = (CharacterFormat*) _blockListRef.allocate(sizeof(CharacterFormat) * _formatLength);
         Q_ASSERT(_formatArray != 0);
         _text = (quint16*) _blockListRef.allocate(sizeof(quint16) * line.size());
         Q_ASSERT(_text != 0);
 
         _length = line.size();
         _wrapped = false;
 
         // record formats and their positions in the format array
         c = line[0];
         _formatArray[0].setFormat(c);
         _formatArray[0].startPos = 0;                      // there's always at least 1 format (for the entire line, unless a change happens)
 
         k = 1;                                            // look for possible format changes
         int j = 1;
         while (k < _length && j < _formatLength) {
             if (!(line[k].equalsFormat(c))) {
                 c = line[k];
                 _formatArray[j].setFormat(c);
                 _formatArray[j].startPos = k;
                 ////qDebug() << "format entry " << j << " at pos " << _formatArray[j].startPos << " " << &(_formatArray[j].startPos) ;
                 j++;
             }
             k++;
         }
 
         // copy character values
         for (int i = 0; i < line.size(); i++) {
             _text[i] = line[i].character;
             ////qDebug() << "char " << i << " at mem " << &(text[i]);
         }
     }
     ////qDebug() << "line created, length " << length << " at " << &(length);
 }
 
 CompactHistoryLine::~CompactHistoryLine()
 {
     if (_length > 0) {
         _blockListRef.deallocate(_text);
         _blockListRef.deallocate(_formatArray);
     }
     _blockListRef.deallocate(this);
 }
 
 void CompactHistoryLine::getCharacter(int index, Character& r)
 {
     Q_ASSERT(index < _length);
     int formatPos = 0;
     while ((formatPos + 1) < _formatLength && index >= _formatArray[formatPos + 1].startPos)
         formatPos++;
 
     r.character = _text[index];
     r.rendition = _formatArray[formatPos].rendition;
     r.foregroundColor = _formatArray[formatPos].fgColor;
     r.backgroundColor = _formatArray[formatPos].bgColor;
     r.isRealCharacter = _formatArray[formatPos].isRealCharacter;
 }
 
 void CompactHistoryLine::getCharacters(Character* array, int size, int startColumn)
 {
     Q_ASSERT(startColumn >= 0 && size >= 0);
     Q_ASSERT(startColumn + size <= static_cast<int>(getLength()));
 
     for (int i = startColumn; i < size + startColumn; i++) {
         getCharacter(i, array[i - startColumn]);
     }
 }
 
 CompactHistoryScroll::CompactHistoryScroll(unsigned int maxLineCount)
     : HistoryScroll(new CompactHistoryType(maxLineCount))
     , _lines()
     , _blockList()
 {
     ////qDebug() << "scroll of length " << maxLineCount << " created";
     setMaxNbLines(maxLineCount);
 }
 
 CompactHistoryScroll::~CompactHistoryScroll()
 {
     qDeleteAll(_lines.begin(), _lines.end());
     _lines.clear();
 }
 
 void CompactHistoryScroll::addCellsVector(const TextLine& cells)
 {
     CompactHistoryLine* line;
     line = new(_blockList) CompactHistoryLine(cells, _blockList);
 
     if (_lines.size() > static_cast<int>(_maxLineCount)) {
         delete _lines.takeAt(0);
     }
     _lines.append(line);
 }
 
 void CompactHistoryScroll::addCells(const Character a[], int count)
 {
     TextLine newLine(count);
     qCopy(a, a + count, newLine.begin());
     addCellsVector(newLine);
 }
 
 void CompactHistoryScroll::addLine(bool previousWrapped)
 {
     CompactHistoryLine* line = _lines.last();
     ////qDebug() << "last line at address " << line;
     line->setWrapped(previousWrapped);
 }
 
 int CompactHistoryScroll::getLines()
 {
     return _lines.size();
 }
 
 int CompactHistoryScroll::getLineLen(int lineNumber)
 {
     if ((lineNumber < 0) || (lineNumber >= _lines.size())) {
         //qDebug() << "requested line invalid: 0 < " << lineNumber << " < " <<_lines.size();
         //Q_ASSERT(lineNumber >= 0 && lineNumber < _lines.size());
         return 0;
     }
     CompactHistoryLine* line = _lines[lineNumber];
     ////qDebug() << "request for line at address " << line;
     return line->getLength();
 }
 
 void CompactHistoryScroll::getCells(int lineNumber, int startColumn, int count, Character buffer[])
 {
     if (count == 0) return;
     Q_ASSERT(lineNumber < _lines.size());
     CompactHistoryLine* line = _lines[lineNumber];
     Q_ASSERT(startColumn >= 0);
     Q_ASSERT((unsigned int)startColumn <= line->getLength() - count);
     line->getCharacters(buffer, count, startColumn);
 }
 
 void CompactHistoryScroll::setMaxNbLines(unsigned int lineCount)
 {
     _maxLineCount = lineCount;
 
     while (_lines.size() > static_cast<int>(lineCount)) {
         delete _lines.takeAt(0);
     }
     ////qDebug() << "set max lines to: " << _maxLineCount;
 }
 
 bool CompactHistoryScroll::isWrappedLine(int lineNumber)
 {
     Q_ASSERT(lineNumber < _lines.size());
     return _lines[lineNumber]->isWrapped();
 }
 
 //////////////////////////////////////////////////////////////////////
 // History Types
 //////////////////////////////////////////////////////////////////////
 
 HistoryType::HistoryType() = default;
 HistoryType::~HistoryType() = default;
 
 //////////////////////////////
 
 HistoryTypeNone::HistoryTypeNone()
 {
 }
 
 bool HistoryTypeNone::isEnabled() const
 {
     return false;
 }
 
 HistoryScroll* HistoryTypeNone::scroll(HistoryScroll* old) const
 {
     delete old;
     return new HistoryScrollNone();
 }
 
 int HistoryTypeNone::maximumLineCount() const
 {
     return 0;
 }
 
 //////////////////////////////
 
 HistoryTypeFile::HistoryTypeFile(const QString& fileName)
     : _fileName(fileName)
 {
 }
 
 bool HistoryTypeFile::isEnabled() const
 {
     return true;
 }
 
 HistoryScroll* HistoryTypeFile::scroll(HistoryScroll* old) const
 {
     if (dynamic_cast<HistoryFile *>(old) != nullptr)
         return old; // Unchanged.
 
     HistoryScroll* newScroll = new HistoryScrollFile(_fileName);
 
     Character line[LINE_SIZE];
     int lines = (old != 0) ? old->getLines() : 0;
     for (int i = 0; i < lines; i++) {
         int size = old->getLineLen(i);
         if (size > LINE_SIZE) {
             auto tmp_line = new Character[size];
             old->getCells(i, 0, size, tmp_line);
             newScroll->addCells(tmp_line, size);
             newScroll->addLine(old->isWrappedLine(i));
             delete [] tmp_line;
         } else {
             old->getCells(i, 0, size, line);
             newScroll->addCells(line, size);
             newScroll->addLine(old->isWrappedLine(i));
         }
     }
 
     delete old;
     return newScroll;
 }
 
 int HistoryTypeFile::maximumLineCount() const
 {
     return -1;
 }
 
 //////////////////////////////
 
 CompactHistoryType::CompactHistoryType(unsigned int nbLines)
     : _maxLines(nbLines)
 {
 }
 
 bool CompactHistoryType::isEnabled() const
 {
     return true;
 }
 
 int CompactHistoryType::maximumLineCount() const
 {
     return _maxLines;
 }
 
 HistoryScroll* CompactHistoryType::scroll(HistoryScroll* old) const
 {
     if (old != nullptr) {
         CompactHistoryScroll* oldBuffer = dynamic_cast<CompactHistoryScroll*>(old);
         if (oldBuffer != nullptr) {
             oldBuffer->setMaxNbLines(_maxLines);
             return oldBuffer;
         }
         delete old;
     }
     return new CompactHistoryScroll(_maxLines);
 }
diff --git a/src/settings/FileLocationSettings.cpp b/src/settings/FileLocationSettings.cpp
index 008f502c..65f454b8 100644
--- a/src/settings/FileLocationSettings.cpp
+++ b/src/settings/FileLocationSettings.cpp
@@ -1,40 +1,41 @@
 /*
   Copyright 2015 Kurt Hindenburg <kurt.hindenburg@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) version 3 or any later version
   accepted by the membership of KDE e.V. (or its successor appro-
   ved by the membership of KDE e.V.), which shall act as a proxy
   defined in Section 14 of version 3 of the license.
 
   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, see http://www.gnu.org/licenses/.
 */
 
 // Own
 #include "FileLocationSettings.h"
 
 #include <QDir>
 #include <QStandardPaths>
 
 using namespace Konsole;
 
 FileLocationSettings::FileLocationSettings(QWidget* aParent) : QWidget(aParent)
 {
     setupUi(this);
 
     // TODO: worth adding gauge on free disk space?
     useSystemLocationText->setText(QDir::tempPath());
     useUsersHomeLocationText->setText(QStandardPaths::writableLocation(QStandardPaths::CacheLocation));
+    kcfg_scrollbackUseSpecifiedLocationDirectory->setMode(KFile::Directory);
 
 }
 
 FileLocationSettings::~FileLocationSettings() = default;
 
diff --git a/src/settings/FileLocationSettings.ui b/src/settings/FileLocationSettings.ui
index 5d566dd3..c2c71b07 100644
--- a/src/settings/FileLocationSettings.ui
+++ b/src/settings/FileLocationSettings.ui
@@ -1,166 +1,212 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>FileLocationSettings</class>
  <widget class="QWidget" name="FileLocationSettings">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>494</width>
     <height>354</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <widget class="QGroupBox" name="ButtonGroup1">
      <property name="sizePolicy">
       <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="whatsThis">
       <string>&lt;b&gt;Scrollback File Location&lt;/b&gt;&lt;p&gt;Use this groupbox to determine where Konsole will store the scrollback files.&lt;/p&gt;</string>
      </property>
      <property name="title">
       <string>Scrollback File Location</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="QLabel" name="label">
         <property name="text">
          <string>These settings only apply when Profile-&gt;Scrolling-&gt;Unlimited scrollback is selected.</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QRadioButton" name="kcfg_scrollbackUseSystemLocation">
         <property name="text">
          <string>Use system &amp;location</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout">
         <item>
          <spacer name="horizontalSpacer">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeType">
            <enum>QSizePolicy::Fixed</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>50</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item>
          <widget class="QLabel" name="useSystemLocationText">
           <property name="text">
            <string/>
           </property>
          </widget>
         </item>
        </layout>
       </item>
       <item>
        <widget class="QRadioButton" name="kcfg_scrollbackUseCacheLocation">
         <property name="sizePolicy">
          <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="text">
          <string>Use user specific location</string>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_2">
         <item>
          <spacer name="horizontalSpacer_2">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeType">
            <enum>QSizePolicy::Fixed</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>50</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item>
          <widget class="QLabel" name="useUsersHomeLocationText">
           <property name="text">
            <string/>
           </property>
          </widget>
         </item>
        </layout>
       </item>
+      <item>
+       <widget class="QRadioButton" name="kcfg_scrollbackUseSpecifiedLocation">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text">
+         <string>Use specified loca&amp;tion</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout_3">
+        <item>
+         <spacer name="horizontalSpacer_3">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeType">
+           <enum>QSizePolicy::Fixed</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>50</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item>
+         <widget class="KUrlRequester" name="kcfg_scrollbackUseSpecifiedLocationDirectory">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+            <horstretch>2</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="filter" stdset="0">
+           <string>text/css</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
       <item>
        <widget class="QLabel" name="label_2">
         <property name="font">
          <font>
           <pointsize>10</pointsize>
           <weight>75</weight>
           <bold>true</bold>
           <underline>true</underline>
          </font>
         </property>
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <property name="text">
          <string>For any changes to take effect, quit Konsole and restart.</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignCenter</set>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer>
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Expanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>50</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>
diff --git a/src/settings/konsole.kcfg b/src/settings/konsole.kcfg
index 3c85f6c4..79f05a41 100644
--- a/src/settings/konsole.kcfg
+++ b/src/settings/konsole.kcfg
@@ -1,128 +1,136 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
       http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
   <kcfgfile name="konsolerc" />
   <group name="KonsoleWindow">
     <entry name="ShowMenuBarByDefault" type="Bool">
       <label>Show menubar by default</label>
       <tooltip>Show menubar by default in each Konsole window</tooltip>
       <default>true</default>
     </entry>
     <entry name="ShowWindowTitleOnTitleBar" type="Bool">
       <label>Show window title on the titlebar</label>
       <tooltip>Show window title set by escape sequence on the titlebar</tooltip>
       <default>false</default>
     </entry>
     <entry name="ShowAppNameOnTitleBar" type="Bool">
       <label>Show "- Konsole" on the titlebar</label>
       <tooltip>Show "- Konsole" on the titlebar</tooltip>
       <default>true</default>
     </entry>
     <entry name="AllowMenuAccelerators" type="Bool">
       <label>Enable menu accelerators</label>
       <tooltip>Allow users to access top menu through Alt+Key combination</tooltip>
       <default>false</default>
     </entry>
     <entry name="ShowTerminalSizeHint" type="Bool">
       <label>Show hint for terminal size after resizing</label>
       <tooltip>Show terminal size in columns and lines in the center of window after resizing</tooltip>
       <default>true</default>
     </entry>
     <entry name="SaveGeometryOnExit" type="Bool">
       <label>Use current window size on next startup</label>
       <tooltip>The window size will be saved upon exiting Konsole</tooltip>
       <default>true</default>
     </entry>
     <entry name="UseSingleInstance" type="Bool">
       <label>Run all Konsole windows in a single process</label>
       <tooltip>When launching Konsole re-use existing process if possible</tooltip>
       <default>false</default>
     </entry>
   </group>
   <group name="SearchSettings">
     <entry name="SearchCaseSensitive" type="Bool">
       <label>Search is case sensitive</label>
       <tooltip>Sets whether the search is case sensitive</tooltip>
       <default>false</default>
     </entry>
     <entry name="SearchRegExpression" type="Bool">
       <label>Match using regular expressions</label>
       <default>false</default>
     </entry>
     <entry name="SearchHighlightMatches" type="Bool">
       <label>Highlight all search matches</label>
       <tooltip>Sets whether matching text should be highlighted</tooltip>
       <default>true</default>
     </entry>
     <entry name="SearchReverseSearch" type="Bool">
       <label>Search backwards</label>
       <tooltip>Sets whether search should start from the bottom</tooltip>
       <default>true</default>
     </entry>
   </group>
   <group name="TabBar">
     <entry name="TabBarVisibility" type="Enum">
       <label>Control the visibility of the whole tab bar</label>
       <choices>
         <choice name="AlwaysShowTabBar" />
         <choice name="ShowTabBarWhenNeeded" />
         <choice name="AlwaysHideTabBar" />
       </choices>
       <default>AlwaysShowTabBar</default>
     </entry>
     <entry name="TabBarPosition" type="Enum">
       <label>Control the position of the tab bar</label>
       <choices>
         <choice name="Top" />
         <choice name="Bottom" />
       </choices>
       <default>Bottom</default>
     </entry>
     <entry name="TabBarStyleSheet" type="String">
       <label>Control the visual style of the tab bar</label>
       <default>QTabBar::tab { min-width: 2em ; max-width: 25em }</default>
     </entry>
     <entry name="TabBarUseUserStyleSheet" type="Bool">
       <label>Use a user-defined .css file for the tab bar</label>
       <default>false</default>
     </entry>
     <entry name="TabBarUserStyleSheetFile" type="Url">
       <label>The .css file to use for the tab bar style</label>
       <default></default>
     </entry>
     <entry name="ShowQuickButtons" type="Bool">
       <label>Control the visibility of quick buttons on the tab bar</label>
       <default>false</default>
     </entry>
     <entry name="NewTabBehavior" type="Enum">
       <label>Control where to put the new tab</label>
       <choices>
         <choice name="PutNewTabAtTheEnd" />
         <choice name="PutNewTabAfterCurrentTab" />
       </choices>
       <default>PutNewTabAtTheEnd</default>
     </entry>
   </group>
   <group name="PrintOptions">
     <entry name="PrinterFriendly" type="Bool">
       <label>Printer &amp;friendly mode (black text, no background)</label>
       <default>true</default>
     </entry>
     <entry name="ScaleOutput" type="Bool">
       <label>&amp;Scale output</label>
       <default>true</default>
     </entry>
   </group>
   <group name="FileLocation">
     <entry name="scrollbackUseSystemLocation" type="Bool">
       <label>For scrollback files, use system-wide folder location</label>
       <default>true</default>
     </entry>
     <entry name="scrollbackUseCacheLocation" type="Bool">
       <label>For scrollback files, use user's specific folder location</label>
       <default>false</default>
     </entry>
+    <entry name="scrollbackUseSpecifiedLocation" type="Bool">
+      <label>For scrollback files, use specified folder location</label>
+      <default>false</default>
+    </entry>
+    <entry name="scrollbackUseSpecifiedLocationDirectory" type="Url">
+      <label>For scrollback files, use this folder</label>
+      <default></default>
+    </entry>
   </group>
 </kcfg>