Merge lp:~dpm/ubuntu-terminal-app/merge-plugin into lp:ubuntu-terminal-app

[David Planella]

Merge the terminal app's plugin into the app's repository

This branch merges the terminal app's plugin into the app's repository, enabling shipping the plugin into the same .click package. Separate .deb packages for the app and the plugin are still generated.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:67
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~dpm/ubuntu-terminal-app/merge-plugin/+merge/217380/+edit-commit-message

http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/49/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2254
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-raring-amd64-ci/49
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-saucy-amd64-ci/49
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-trusty-amd64-ci/37

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/49/rebuild

review: Needs Fixing (continuous-integration)

[lp:~dpm/ubuntu-terminal-app/merge-plugin]

68. By David Planella on 2014-04-28

Added rule to copy the plugin to the build directory

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:68
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/50/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2256
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-raring-amd64-ci/50
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-saucy-amd64-ci/50
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-trusty-amd64-ci/38

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/50/rebuild

review: Approve (continuous-integration)

[Alan Pope 🍺🐧🐱 🦄 (popey)]

Tried building this in qtcreator, it built a click package, but that fails the click-reviewers-tools..

ERROR: Could not find 'com.ubuntu.terminal.desktop.in'

[lp:~dpm/ubuntu-terminal-app/merge-plugin]

69. By David Planella on 2014-04-28

Fixed wrong desktop file in the manifest

[David Planella (dpm)]

Sorry, that was a typo in the manifest file. Fixed now.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:69
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/51/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2260
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-raring-amd64-ci/51
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-saucy-amd64-ci/51
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-trusty-amd64-ci/39

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/51/rebuild

review: Approve (continuous-integration)

[Alan Pope 🍺🐧🐱 🦄 (popey)]

Trying to test this but qtc is conspiring against me: bug 1314960

[Nicholas Skaggs (nskaggs)]

In order to get this to run, you need the python3-lxml lib added to /home/phablet/autopilot -- and you need the armhf version as it's a compiled module ;-) I would recommend adding this info to the readme.

I was able to successfully build and run this on my device.

[Nicholas Skaggs (nskaggs)]

I would also change the dependency to python3-lxml from python-lxml.

[lp:~dpm/ubuntu-terminal-app/merge-plugin]

70. By David Planella on 2014-05-06

Updated python-lxml dependency to Python 3, added note about manual set up for running tests on device

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:70
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/52/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2428/console
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-raring-amd64-ci/52
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-saucy-amd64-ci/52
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-trusty-amd64-ci/40

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/52/rebuild

review: Needs Fixing (continuous-integration)

[Nicholas Skaggs (nskaggs)]

could not import package ubuntu_terminal_app: No module named 'ubuntu_terminal_app'
Loading tests from:

Did not find any tests

We had this same issue with shorts; py3 meant jenkins couldn't find the tests. If you change back to python-lxml I assume it will work.

[Dimitri John Ledkov (xnox)]

On 6 May 2014 18:09, Nicholas Skaggs <email address hidden> wrote:
> could not import package ubuntu_terminal_app: No module named 'ubuntu_terminal_app'
> Loading tests from:
>
> Did not find any tests
>
> We had this same issue with shorts; py3 meant jenkins couldn't find the tests. If you change back to python-lxml I assume it will work.

Both Python2 & Python3 comes with an xml module in the standard
library is that not sufficient?

--
Regards,

Dimitri.

[Dimitri John Ledkov (xnox)]

See https://code.launchpad.net/~xnox/ubuntu-terminal-app/drop-lxml-dep/+merge/218482

[Nicholas Skaggs (nskaggs)]

Dimitri, yes in this case I think we simply drop the lxml dependency.

In regards to what I was saying about jenkins missing tests, I finally figured out why jenkins wasn't finding the tests. It requires the core app to depend on python3, and for the cmakelists file for autopilot tests to copy the module to the python3 path, instead of python2 :-)

[Nicholas Skaggs (nskaggs)]

See https://code.launchpad.net/~nskaggs/ubuntu-terminal-app/working-py3-jenkins/+merge/218488 for the fix

[Dimitri John Ledkov (xnox)]

On 6 May 2014 19:39, Nicholas Skaggs <email address hidden> wrote:
> See https://code.launchpad.net/~nskaggs/ubuntu-terminal-app/working-py3-jenkins/+merge/218488 for the fix
> --
> https://code.launchpad.net/~dpm/ubuntu-terminal-app/merge-plugin/+merge/217380
> Your team Ubuntu Terminal Developers is subscribed to branch lp:ubuntu-terminal-app.

Or see... https://code.launchpad.net/~xnox/ubuntu-terminal-app/merge-plugin+lxml+py3
which is mid-air colition, slightly older than your branch.

--
Regards,

Dimitri.

[David Planella (dpm)]

As far as I can tell, the standard module is not a drop-in replacement for lxml, so just replacing the import won't work.

In any case, as discussed on IRC, I'll split this MP to separate the change that introduced the lxml dependency.

[lp:~dpm/ubuntu-terminal-app/merge-plugin]

71. By David Planella on 2014-05-06

Reverted the feature of autodetecting Qt Creator's build dir. Will submit it in a separate MP

72. By David Planella on 2014-05-06

Updated README too

73. By David Planella on 2014-05-06

Merged nskagg's Jenkins Python 3 fixes

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:73
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/55/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2455/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-terminal-app-raring-amd64-ci/55/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-terminal-app-saucy-amd64-ci/55/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-terminal-app-trusty-amd64-ci/43/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/55/rebuild

review: Needs Fixing (continuous-integration)

[lp:~dpm/ubuntu-terminal-app/merge-plugin]

74. By David Planella on 2014-05-06

Merge Python 3 print() fix from balloons

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:74
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/56/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2461/console
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-raring-amd64-ci/56
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-saucy-amd64-ci/56
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-terminal-app-trusty-amd64-ci/44

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-terminal-app-ci/56/rebuild

review: Needs Fixing (continuous-integration)

[Nicholas Skaggs (nskaggs)]

Specify python3-autopilot so jenkins runs with it.

=== modified file 'debian/control'
--- debian/control 2014-05-06 19:04:04 +0000
+++ debian/control 2014-05-06 21:41:01 +0000
@@ -45,6 +45,7 @@
 Depends: ${misc:Depends},
          libautopilot-qt,
          libqt5test5,
+ python3-autopilot,
          ubuntu-terminal-app (>= ${source:Version}),
          ubuntu-ui-toolkit-autopilot,
 Description: Autopilot tests for Terminal Application

[lp:~dpm/ubuntu-terminal-app/merge-plugin]

75. By David Planella on 2014-05-06

Add Python 3 dependency to make Jenkins happy

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

review: Approve (continuous-integration)

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2014-05-06 21:50:22 +0000
@@ -0,0 +1,16 @@
+Makefile
+src/*.so
+*user
+
+.moc/
+.obj/
+
+debian/files
+debian/qtdeclarative5-konsole-qml-plugin/
+debian/*.debhelper.log
+debian/*.substvars
+.excludes
+obj-x86_64-linux-gnu
+debian/tmp
+debian/ubuntu-terminal-app
+debian/ubuntu-terminal-app-autopilot

=== removed file '.bzrignore'
--- .bzrignore	2013-04-23 20:42:10 +0000
+++ .bzrignore	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-*.qmlproject.user
-
-debian/files
-debian/ubuntu-terminal-app/
-debian/*.debhelper.log
-debian/*.substvars

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-04-15 18:00:53 +0000
+++ CMakeLists.txt	2014-05-06 21:50:22 +0000
@@ -1,6 +1,9 @@
-project(com.ubuntu.terminal)
+project(com.ubuntu.terminal C CXX)
 cmake_minimum_required(VERSION 2.8.9)
 
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-permissive -pedantic -Wall -Wextra -fPIC")
+
 # Standard install paths
 include(GNUInstallDirs)
 
@@ -8,49 +11,61 @@
 option(CLICK_MODE "Installs to a contained location" off)
 
 set(APP_NAME terminal)
-set(DESKTOP_FILE "${PROJECT_NAME}_${APP_NAME}.desktop")
-set(URLS_FILE "${PROJECT_NAME}_${APP_NAME}.url-dispatcher")
+set(DESKTOP_FILE "${PROJECT_NAME}.desktop")
+set(URLS_FILE "${PROJECT_NAME}.url-dispatcher")
 set(APP_HARDCODE ubuntu-terminal-app)
 set(MAIN_QML ubuntu-terminal-app.qml)
 set(ICON_FILE terminal64.png)
 set(AUTOPILOT_DIR ubuntu_terminal_app)
+set(EXEC "${APP_NAME}")
 
 if(CLICK_MODE)
     if(NOT DEFINED BZR_SOURCE)
         set(BZR_SOURCE "lp:${APP_HARDCODE}")
         message("-- Setting BZR_SOURCE to ${BZR_SOURCE}")
     endif(NOT DEFINED BZR_SOURCE)
+    # Find out the architecture for package building
+    # to determine the plugin's installation path
+    execute_process(
+        COMMAND dpkg-architecture -qDEB_HOST_MULTIARCH
+        OUTPUT_VARIABLE ARCH_TRIPLET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
     set(CMAKE_INSTALL_PREFIX /)
     set(CMAKE_INSTALL_BINDIR /)
     set(DATA_DIR /)
-    set(EXEC "qmlscene ${MAIN_QML}")
     set(DESKTOP_DIR ${DATA_DIR})
     set(URLS_DIR ${DATA_DIR})
-	set(ICON ${ICON_FILE})
+    set(ICON ${ICON_FILE})
+    set(QT_IMPORTS_DIR "/lib/${ARCH_TRIPLET}")
+    set(BIN_DIR /lib/${ARCH_TRIPLET}/bin)
+    if(NOT BZR_REVNO)
+        set(BZR_REVNO "latest")
+    endif(NOT BZR_REVNO)
+    configure_file(manifest.json ${CMAKE_CURRENT_BINARY_DIR}/manifest.json)
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/manifest.json apparmor.json DESTINATION ${CMAKE_INSTALL_PREFIX})
 else(CLICK_MODE)
-    set(DATA_DIR ${CMAKE_INSTALL_DATADIR}/${APP_HARDCODE})
-    set(EXEC ${APP_HARDCODE})
-	set(ICON ${CMAKE_INSTALL_PREFIX}/${DATA_DIR}/${ICON_FILE})
-    configure_file(${APP_HARDCODE}.in
-        ${CMAKE_CURRENT_BINARY_DIR}/${APP_HARDCODE})
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${APP_HARDCODE}
-        DESTINATION ${CMAKE_INSTALL_BINDIR})
+    execute_process(
+        COMMAND qmake -query QT_INSTALL_QML
+        OUTPUT_VARIABLE QT_IMPORTS_DIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    set(DATA_DIR ${CMAKE_INSTALL_DATADIR}/${APP_NAME})
+    set(ICON ${CMAKE_INSTALL_PREFIX}/${DATA_DIR}/${ICON_FILE})
     set(DESKTOP_DIR ${CMAKE_INSTALL_DATADIR}/applications)
     set(URLS_DIR ${CMAKE_INSTALL_DATADIR}/url-dispatcher/urls)
 endif(CLICK_MODE)
 
 file(GLOB_RECURSE I18N_SRC_FILES
      RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
-     rc/**.qml desktop/**.desktop.in)
+     src/app/**.qml *.desktop.in)
 list(SORT I18N_SRC_FILES)
 
-
 file(GLOB SRC_FILES
      RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
      *.qml *.js *.png *.js)
-install(DIRECTORY config extraPanel DESTINATION ${DATA_DIR})
-install(FILES Terminal.qml Configs.qml settings.png [e-mail]
-    ${MAIN_QML} ${ICON_FILE} DESTINATION ${DATA_DIR})
+install(FILES ${SRC_FILES}
+    DESTINATION ${DATA_DIR})
 
 configure_file(${DESKTOP_FILE}.in ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE}
@@ -61,6 +76,6 @@
 # Tests
 enable_testing()
 
-add_subdirectory(click)
 add_subdirectory(po)
 add_subdirectory(tests)
+add_subdirectory(src)

=== removed file 'README'
--- README	2013-02-12 16:18:48 +0000
+++ README	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-this is an example README file.

=== added file 'README.md'
--- README.md	1970-01-01 00:00:00 +0000
+++ README.md	2014-05-06 21:50:22 +0000
@@ -0,0 +1,152 @@
+# Ubuntu Terminal
+
+A terminal app for desktop and mobile devices. It provides access to terminal
+sessions and is based on KDE's Konsole plugin.
+
+The current plugin consists of:
+- KTerminal: offers access to terminal session from qml
+- KSessions: offers access to pty(s) from C++ layer
+
+## Building the app
+
+### For the desktop
+
+Install the following build dependencies:
+
+(none required at the moment) 
+
+Then open the CMakeLists.txt file in Qt Creator, and ensure that the kit
+selected on the left sidebar (just above the green "Run" button) is "Desktop"
+
+### For a device
+
+If you don't have one already, you'll need to create an armhf chroot to
+cross-compile the app. Here's how:
+
+1. In Qt Creator, open the CMakeLists.txt file
+2. Go to Tools > Options > Ubuntu > Click
+2. Click on Create Click Target
+3. Follow the prompts to generate the chroot. You will be asked for your sudo
+   password
+4. Once created, you'll need to add the build dependencies for the app:
+  - At this time, none are required, but the steps are shown for the sake of
+    completion
+  - Click on the Maintain button on your chroot
+  - On the terminal prompt that is started, type 
+    apt-get install $DEPENDENCY_NAME:armhf'
+  - Close the terminal when the installation finishes
+5. Now you can either do a clean checkout and wait to be prompted by Qt Creator
+   to add the armhf kit, or alternatively:
+6. Go to the Projects tab > Add kit and then select the UbuntuSDK armhf kit
+
+Additionally, you'll have to tell Qt Creator that you are doing a build for a
+device to ultimately create a click package for installation:
+
+1. In Qt Creator, go to the Projects tab on the sidebar
+2. Click on the "Build" subtab of the "UbuntuSDK for armhf..." tab
+3. Then go to the "CMake arguments" text field and add "-DCLICK_MODE=on"
+   without the quotes
+
+Before starting the build make sure to select the "UbuntuSDK" kit on Qt
+Creator's left sidebar (just above the green "Run" button).
+
+### Doing the build
+
+Ensure you've selected the kit you want for your build and press the build
+button on Qt Creator's left sidebar (or alternatively Ctrl+B).
+
+## Running the app
+
+### On the desktop
+
+No additional steps are required before running the app on the desktop.
+
+### On a device
+
+Due to Qt Creator's bug #1312094 in launchpad.net, there needs to be a manual
+workaround done before the app can run on the device:
+ 
+1. Modify the desktop.in file: change the Exec line to read:
+   Exec=lib/arm-linux-gnueabihf/bin/@EXEC@
+
+Remember to revert this temporary change if you are building a click package or
+if you're making other changes to be committed to the code!
+
+### Starting the app
+
+Ensure you've selected the kit you want for your build and press the run
+button on Qt Creator's left sidebar (or alternatively Ctrl+R).
+
+If the app hasn't been built yet, or if there are pending changes that require
+a build, the app will automatically be built first before running.
+
+If you're starting the app on a device, the build will be copied over and the
+code will run unconfined.
+
+## Building a click package
+
+There are two alternative ways of building a click package.
+
+### Using Qt Creator
+
+1. Ensure you've selected the UbuntuSDK for armhf kit on Qt Creator's sidebar
+2. Click on Publish on the sidebar
+3. Click on "Create package"
+4. If all goes well, you'll find the final click package in the build directory
+
+Notes:
+- You can see the output of the click build if you click on Edit on the sidebar
+  and then "Application Output" at the bottom. This is useful to identify any
+  failures during the build
+- Run `sudo apt-get install click-reviewers-tools` to enable click package
+  validation in Qt Creator. You might need to restart Qt Creator after you've
+  installed them for it to detect them
+
+### Using click-buddy
+
+1. Install phablet-tools: `sudo apt-get install phablet-tools`
+2. Run click-buddy in your source tree:
+   click-buddy --dir . --arch armhf --framework ubuntu-sdk-14.04
+3. Once finished, click-buddy will tell you the location of your source package
+
+## Installing a click package
+
+First of all, ensure you've got a working Ubuntu device attached over USB to
+your host computer
+
+### Manually
+
+Run the following commands to manually install the click package (replace 0.1
+with the version of your package):
+
+    adb push /home/phablet com.ubuntu.terminal_0.1_armhf.click
+    adb shell
+    sudo -H -u phablet pkcon install-local /home/phablet/com.ubuntu.terminal_0.1_armhf.click
+
+### Using click-buddy
+
+You can add the --provision argument to the previous command to install the
+click package on the device.
+
+### Starting the app
+
+1. Either kill unity8 with `pkill unity8` or restart the system for the Apps
+   (click) scope to pick up your newly installed click package
+2. Search for Reminders in the Apps scope and tap on its icon to start it
+3. You'll find the runtime logs at ~/.cache/upstart/application-click/
+
+## Uninstalling a click package
+
+Run the following commands, replacing the version of the click package you want
+to uninstall:
+
+    adb shell
+    sudo -iu phablet
+    sudo click unregister com.ubuntu.terminal 0.1
+
+## Run the autopilot tests
+
+Once the app has been built, you can go to the build directory and run:
+
+    cd tests/autopilot
+    autopilot run ubuntu_terminal_app

=== renamed file 'click/apparmor.json' => 'apparmor.json'
--- click/apparmor.json	2014-03-14 18:33:50 +0000
+++ apparmor.json	2014-05-06 21:50:22 +0000
@@ -1,4 +1,5 @@
 {
-    "policy_version": 1.1, 
+    "policy_groups": [],
+    "policy_version": 1.1,
     "template": "unconfined"
-}
+}
\ No newline at end of file

=== removed directory 'click'
=== removed file 'click/CMakeLists.txt'
--- click/CMakeLists.txt	2014-01-31 21:52:08 +0000
+++ click/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-if(CLICK_MODE)
-    if(NOT BZR_REVNO)
-        set(BZR_REVNO "latest")
-    endif(NOT BZR_REVNO)
-    configure_file(manifest.json.in ${CMAKE_CURRENT_BINARY_DIR}/manifest.json)
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/manifest.json apparmor.json
-            DESTINATION ${CMAKE_INSTALL_PREFIX})
-endif(CLICK_MODE)

=== renamed file 'com.ubuntu.terminal_terminal.desktop.in' => 'com.ubuntu.terminal.desktop.in'
=== renamed file 'com.ubuntu.terminal_terminal.url-dispatcher' => 'com.ubuntu.terminal.url-dispatcher'
=== modified file 'debian/changelog'
--- debian/changelog	2014-03-10 10:19:53 +0000
+++ debian/changelog	2014-05-06 21:50:22 +0000
@@ -1,8 +1,12 @@
-ubuntu-terminal-app (0.5ubuntu1) UNRELEASED; urgency=medium
+ubuntu-terminal-app (0.5ubuntu2) trusty; urgency=medium
 
+  [ Alan Pope ]
   * Add -qt5 command line option (LP: #1288885)  
 
- -- Alan Pope <[e-mail]>  Mon, 10 Mar 2014 10:19:27 +0000
+  [ David Planella ]
+  * Merge konsole plugin into the app's repo. 
+
+ -- David Planella <[e-mail]>  Sun, 27 Apr 2014 12:08:04 +0200
 
 ubuntu-terminal-app (0.5) raring; urgency=low
 

=== modified file 'debian/control'
--- debian/control	2014-03-07 21:06:44 +0000
+++ debian/control	2014-05-06 21:50:22 +0000
@@ -3,29 +3,50 @@
 Maintainer: Ubuntu App Cats <[e-mail]>
 Build-Depends: cmake,
                debhelper (>= 9),
-               python,
-Standards-Version: 3.9.4
+               python3-all,
+               gettext,
+               qtbase5-dev,
+               qtdeclarative5-dev,
+               qt5-default,
+Standards-Version: 3.9.5
 Section: misc
 Homepage: https://launchpad.net/ubuntu-terminal-app
 Vcs-Bzr: https://code.launchpad.net/~ubuntu-terminal-dev/ubuntu-terminal-app/trunk
 
 Package: ubuntu-terminal-app
 Section: misc
-Architecture: all
-Depends: qmlscene,
+Architecture: any
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
          qtdeclarative5-konsole-qml-plugin (>= 0.1.1),
          qtdeclarative5-localstorage-plugin,
          qtdeclarative5-qtquick2-plugin,
-         qtdeclarative5-ubuntu-ui-toolkit-plugin | qt-components-ubuntu,
-         ${misc:Depends},
+         qtdeclarative5-ubuntu-ui-toolkit-plugin,
 Description: Terminal application
  Core Terminal application
 
+Package: qtdeclarative5-konsole-qml-plugin
+Architecture: any
+Multi-Arch: same
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+         ${misc:Pre-Depends},
+Description: KDE Konsole QML plugin - qml terminal plugin
+ Konsole is a terminal emulator from KDE. This is a ported
+ version for the Ubuntu Terminal app and does not require KDE.
+ .
+ This package contains the Konsole terminal emulator plugin
+ for Qt Qml, which offers access to terminal by KTerminal and
+ KSession elements. KTerminal is used for displaying information
+ given by KSession.
+
 Package: ubuntu-terminal-app-autopilot
 Architecture: all
-Depends: libautopilot-qt,
+Depends: ${misc:Depends},
+         libautopilot-qt,
          libqt5test5,
-         ubuntu-terminal-app (= ${source:Version}),
+         python3-autopilot,
+         ubuntu-terminal-app (>= ${source:Version}),
          ubuntu-ui-toolkit-autopilot,
 Description: Autopilot tests for Terminal Application
  This package contains the autopilot tests for the Terminal

=== added file 'debian/qtdeclarative5-konsole-qml-plugin.install'
--- debian/qtdeclarative5-konsole-qml-plugin.install	1970-01-01 00:00:00 +0000
+++ debian/qtdeclarative5-konsole-qml-plugin.install	2014-05-06 21:50:22 +0000
@@ -0,0 +1,1 @@
+usr/lib/*/qt5/qml/org/kde/konsole/

=== renamed file 'click/manifest.json.in' => 'manifest.json'
--- click/manifest.json.in	2014-04-11 22:59:46 +0000
+++ manifest.json	2014-05-06 21:50:22 +0000
@@ -3,15 +3,15 @@
     "framework": "ubuntu-sdk-14.04-dev1",
     "architecture": "armhf",
     "hooks": {
-        "@APP_NAME@": {
+        "terminal": {
             "apparmor": "apparmor.json",
-            "desktop": "@DESKTOP_FILE@",
-            "urls": "@URLS_FILE@"
+            "desktop": "com.ubuntu.terminal.desktop",
+            "urls": "com.ubuntu.terminal.url-dispatcher"
         }
     },
-    "icon": "@ICON@",
+    "icon": "terminal64.png",
     "maintainer": "Ubuntu App Cats <[e-mail]>",
-    "name": "@PROJECT_NAME@",
+    "name": "com.ubuntu.terminal",
     "title": "Terminal",
     "version": "0.5.@BZR_REVNO@",
     "x-source": {
@@ -21,4 +21,4 @@
     "x-test": {
         "autopilot": "@AUTOPILOT_DIR@"
     }
-}
+}
\ No newline at end of file

=== removed file 'plugins.json'
--- plugins.json	2013-10-11 14:30:09 +0000
+++ plugins.json	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-[
-{
-    "package": "qtdeclarative5-konsole-qml-plugin",
-    "ppa": "ppa:ubuntu-touch-coreapps-drivers/daily"
-}
-]

=== added directory 'src'
=== added file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/CMakeLists.txt	2014-05-06 21:50:22 +0000
@@ -0,0 +1,2 @@
+add_subdirectory(plugin)
+add_subdirectory(app)

=== added directory 'src/app'
=== added file 'src/app/CMakeLists.txt'
--- src/app/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/app/CMakeLists.txt	2014-05-06 21:50:22 +0000
@@ -0,0 +1,24 @@
+file(GLOB_RECURSE QML_SRCS *.qml *.js)
+
+set(terminal_SRCS
+    main.cpp
+    ${QML_SRCS}
+)
+
+add_executable(terminal ${terminal_SRCS})
+
+qt5_use_modules(terminal Gui Qml Quick)
+
+if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+add_custom_target(terminal-qmlfiles ALL
+    COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/qml ${CMAKE_CURRENT_BINARY_DIR}
+    DEPENDS ${QMLFILES}
+)
+endif(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+
+install(DIRECTORY qml DESTINATION ${DATA_DIR})
+if(CLICK_MODE)
+  install(TARGETS terminal DESTINATION ${BIN_DIR})
+else()
+  install(TARGETS terminal RUNTIME DESTINATION bin)
+endif()

=== added file 'src/app/main.cpp'
--- src/app/main.cpp	1970-01-01 00:00:00 +0000
+++ src/app/main.cpp	2014-05-06 21:50:22 +0000
@@ -0,0 +1,120 @@
+/*
+ * Copyright: 2013 - 2014 Canonical, Ltd
+ *
+ * This file is part of ubuntu-terminal-app
+ *
+ * ubuntu-terminal-app 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * ubuntu-terminal-app 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/>.
+ *
+ * Authors: Michael Zanetti <[e-mail]>
+ *          Riccardo Padovani <[e-mail]>
+ *          David Planella <[e-mail]>
+ */
+
+#include <QtGui/QGuiApplication>
+#include <QtQuick/QQuickView>
+#include <QtQml/QtQml>
+#include <QLibrary>
+#include <QDir>
+
+#include <QDebug>
+
+int main(int argc, char *argv[])
+{
+    QGuiApplication a(argc, argv);
+    QQuickView view;
+    view.setResizeMode(QQuickView::SizeRootObjectToView);
+
+    // Set up import paths
+    QStringList importPathList = view.engine()->importPathList();
+    // Prepend the location of the plugin in the build dir,
+    // so that Qt Creator finds it there, thus overriding the one installed
+    // in the sistem if there is one
+    importPathList.prepend(QCoreApplication::applicationDirPath() + "/../plugin/");
+
+    QStringList args = a.arguments();
+    if (args.contains("-h") || args.contains("--help")) {
+        qDebug() << "usage: " + args.at(0) + " [-p|--phone] [-t|--tablet] [-h|--help] [-I <path>]";
+        qDebug() << "    -p|--phone    If running on Desktop, start in a phone sized window.";
+        qDebug() << "    -t|--tablet   If running on Desktop, start in a tablet sized window.";
+        qDebug() << "    -h|--help     Print this help.";
+        qDebug() << "    -I <path>     Give a path for an additional QML import directory. May be used multiple times.";
+        qDebug() << "    -q <qmlfile>  Give an alternative location for the main qml file.";
+        return 0;
+    }
+
+    QString qmlfile;
+    for (int i = 0; i < args.count(); i++) {
+        if (args.at(i) == "-I" && args.count() > i + 1) {
+            QString addedPath = args.at(i+1);
+            if (addedPath.startsWith('.')) {
+                addedPath = addedPath.right(addedPath.length() - 1);
+                addedPath.prepend(QDir::currentPath());
+            }
+            importPathList.append(addedPath);
+        } else if (args.at(i) == "-q" && args.count() > i + 1) {
+            qmlfile = args.at(i+1);
+        }
+    }
+
+    if (args.contains(QLatin1String("-testability")) || getenv("QT_LOAD_TESTABILITY")) {
+        QLibrary testLib(QLatin1String("qttestability"));
+        if (testLib.load()) {
+            typedef void (*TasInitialize)(void);
+            TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
+            if (initFunction) {
+                initFunction();
+            } else {
+                qCritical("Library qttestability resolve failed!");
+            }
+        } else {
+            qCritical("Library qttestability load failed!");
+        }
+    }
+
+    view.engine()->rootContext()->setContextProperty("tablet", QVariant(false));
+    view.engine()->rootContext()->setContextProperty("phone", QVariant(false));
+    if (args.contains("-t") || args.contains("--tablet")) {
+        qDebug() << "running in tablet mode";
+        view.engine()->rootContext()->setContextProperty("tablet", QVariant(true));
+    } else if (args.contains("-p") || args.contains("--phone")){
+        qDebug() << "running in phone mode";
+        view.engine()->rootContext()->setContextProperty("phone", QVariant(true));
+    } else if (qgetenv("QT_QPA_PLATFORM") != "ubuntumirclient") {
+        // Default to tablet size on X11
+        view.engine()->rootContext()->setContextProperty("tablet", QVariant(true));
+    }
+
+    view.engine()->setImportPathList(importPathList);
+
+    // load the qml file
+    if (qmlfile.isEmpty()) {
+        QStringList paths = QStandardPaths::standardLocations(QStandardPaths::DataLocation);
+        paths.prepend(QDir::currentPath());
+        paths.prepend(QCoreApplication::applicationDirPath());
+
+        foreach (const QString &path, paths) {
+            QFileInfo fi(path + "/qml/ubuntu-terminal-app.qml");
+            qDebug() << "Trying to load QML from:" << path + "/qml/ubuntu-terminal-app.qml";
+            if (fi.exists()) {
+                qmlfile = path +  "/qml/ubuntu-terminal-app.qml";
+                break;
+            }
+        }
+    }
+    qDebug() << "using main qml file from:" << qmlfile;
+    view.setSource(QUrl::fromLocalFile(qmlfile));
+    view.show();
+
+    return a.exec();
+}

=== added directory 'src/app/qml'
=== renamed file 'Configs.qml' => 'src/app/qml/Configs.qml'
=== renamed file 'Terminal.qml' => 'src/app/qml/Terminal.qml'
=== renamed file '[e-mail]' => 'src/app/qml/[e-mail]'
=== renamed directory 'config' => 'src/app/qml/config'
=== renamed directory 'extraPanel' => 'src/app/qml/extraPanel'
=== renamed file 'settings.png' => 'src/app/qml/settings.png'
=== renamed file 'terminal.qmlproject' => 'src/app/qml/terminal.qmlproject'
=== renamed file 'ubuntu-terminal-app.qml' => 'src/app/qml/ubuntu-terminal-app.qml'
=== added directory 'src/plugin'
=== added file 'src/plugin/CMakeLists.txt'
--- src/plugin/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/plugin/CMakeLists.txt	2014-05-06 21:50:22 +0000
@@ -0,0 +1,7 @@
+include(FindPkgConfig)
+find_package(Qt5Core)
+find_package(Qt5Qml)
+find_package(Qt5Quick)
+find_package(Qt5Widgets)
+
+add_subdirectory(konsole)

=== added directory 'src/plugin/konsole'
=== added file 'src/plugin/konsole/BlockArray.cpp'
--- src/plugin/konsole/BlockArray.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/BlockArray.cpp	2014-05-06 21:50:22 +0000
@@ -0,0 +1,377 @@
+/*
+    This file is part of Konsole, an X terminal.
+    Copyright (C) 2000 by Stephan Kulow <[e-mail]>
+
+    Rewritten for QT4 by e_k <e_k at users.sourceforge.net>, Copyright (C)2008
+
+    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 "BlockArray.h"
+
+#include <QtCore>
+
+// System
+#include <assert.h>
+#include <sys/mman.h>
+#include <sys/param.h>
+#include <unistd.h>
+#include <stdio.h>
+
+
+static int blocksize = 0;
+
+BlockArray::BlockArray()
+        : size(0),
+        current(size_t(-1)),
+        index(size_t(-1)),
+        lastmap(0),
+        lastmap_index(size_t(-1)),
+        lastblock(0), ion(-1),
+        length(0)
+{
+    // lastmap_index = index = current = size_t(-1);
+    if (blocksize == 0) {
+        blocksize = ((sizeof(Block) / getpagesize()) + 1) * getpagesize();
+    }
+
+}
+
+BlockArray::~BlockArray()
+{
+    setHistorySize(0);
+    assert(!lastblock);
+}
+
+size_t BlockArray::append(Block * block)
+{
+    if (!size) {
+        return size_t(-1);
+    }
+
+    ++current;
+    if (current >= size) {
+        current = 0;
+    }
+
+    int rc;
+    rc = lseek(ion, current * blocksize, SEEK_SET);
+    if (rc < 0) {
+        perror("HistoryBuffer::add.seek");
+        setHistorySize(0);
+        return size_t(-1);
+    }
+    rc = write(ion, block, blocksize);
+    if (rc < 0) {
+        perror("HistoryBuffer::add.write");
+        setHistorySize(0);
+        return size_t(-1);
+    }
+
+    length++;
+    if (length > size) {
+        length = size;
+    }
+
+    ++index;
+
+    delete block;
+    return current;
+}
+
+size_t BlockArray::newBlock()
+{
+    if (!size) {
+        return size_t(-1);
+    }
+    append(lastblock);
+
+    lastblock = new Block();
+    return index + 1;
+}
+
+Block * BlockArray::lastBlock() const
+{
+    return lastblock;
+}
+
+bool BlockArray::has(size_t i) const
+{
+    if (i == index + 1) {
+        return true;
+    }
+
+    if (i > index) {
+        return false;
+    }
+    if (index - i >= length) {
+        return false;
+    }
+    return true;
+}
+
+const Block * BlockArray::at(size_t i)
+{
+    if (i == index + 1) {
+        return lastblock;
+    }
+
+    if (i == lastmap_index) {
+        return lastmap;
+    }
+
+    if (i > index) {
+        qDebug() << "BlockArray::at() i > index\n";
+        return 0;
+    }
+
+//     if (index - i >= length) {
+//         kDebug(1211) << "BlockArray::at() index - i >= length\n";
+//         return 0;
+//     }
+
+    size_t j = i; // (current - (index - i) + (index/size+1)*size) % size ;
+
+    assert(j < size);
+    unmap();
+
+    Block * block = (Block *)mmap(0, blocksize, PROT_READ, MAP_PRIVATE, ion, j * blocksize);
+
+    if (block == (Block *)-1) {
+        perror("mmap");
+        return 0;
+    }
+
+    lastmap = block;
+    lastmap_index = i;
+
+    return block;
+}
+
+void BlockArray::unmap()
+{
+    if (lastmap) {
+        int res = munmap((char *)lastmap, blocksize);
+        if (res < 0) {
+            perror("munmap");
+        }
+    }
+    lastmap = 0;
+    lastmap_index = size_t(-1);
+}
+
+bool BlockArray::setSize(size_t newsize)
+{
+    return setHistorySize(newsize * 1024 / blocksize);
+}
+
+bool BlockArray::setHistorySize(size_t newsize)
+{
+//    kDebug(1211) << "setHistorySize " << size << " " << newsize;
+
+    if (size == newsize) {
+        return false;
+    }
+
+    unmap();
+
+    if (!newsize) {
+        delete lastblock;
+        lastblock = 0;
+        if (ion >= 0) {
+            close(ion);
+        }
+        ion = -1;
+        current = size_t(-1);
+        return true;
+    }
+
+    if (!size) {
+        FILE * tmp = tmpfile();
+        if (!tmp) {
+            perror("konsole: cannot open temp file.\n");
+        } else {
+            ion = dup(fileno(tmp));
+            if (ion<0) {
+                perror("konsole: cannot dup temp file.\n");
+                fclose(tmp);
+            }
+        }
+        if (ion < 0) {
+            return false;
+        }
+
+        assert(!lastblock);
+
+        lastblock = new Block();
+        size = newsize;
+        return false;
+    }
+
+    if (newsize > size) {
+        increaseBuffer();
+        size = newsize;
+        return false;
+    } else {
+        decreaseBuffer(newsize);
+        ftruncate(ion, length*blocksize);
+        size = newsize;
+
+        return true;
+    }
+}
+
+void moveBlock(FILE * fion, int cursor, int newpos, char * buffer2)
+{
+    int res = fseek(fion, cursor * blocksize, SEEK_SET);
+    if (res) {
+        perror("fseek");
+    }
+    res = fread(buffer2, blocksize, 1, fion);
+    if (res != 1) {
+        perror("fread");
+    }
+
+    res = fseek(fion, newpos * blocksize, SEEK_SET);
+    if (res) {
+        perror("fseek");
+    }
+    res = fwrite(buffer2, blocksize, 1, fion);
+    if (res != 1) {
+        perror("fwrite");
+    }
+    //    printf("moving block %d to %d\n", cursor, newpos);
+}
+
+void BlockArray::decreaseBuffer(size_t newsize)
+{
+    if (index < newsize) { // still fits in whole
+        return;
+    }
+
+    int offset = (current - (newsize - 1) + size) % size;
+
+    if (!offset) {
+        return;
+    }
+
+    // The Block constructor could do somthing in future...
+    char * buffer1 = new char[blocksize];
+
+    FILE * fion = fdopen(dup(ion), "w+b");
+    if (!fion) {
+        delete [] buffer1;
+        perror("fdopen/dup");
+        return;
+    }
+
+    int firstblock;
+    if (current <= newsize) {
+        firstblock = current + 1;
+    } else {
+        firstblock = 0;
+    }
+
+    size_t oldpos;
+    for (size_t i = 0, cursor=firstblock; i < newsize; i++) {
+        oldpos = (size + cursor + offset) % size;
+        moveBlock(fion, oldpos, cursor, buffer1);
+        if (oldpos < newsize) {
+            cursor = oldpos;
+        } else {
+            cursor++;
+        }
+    }
+
+    current = newsize - 1;
+    length = newsize;
+
+    delete [] buffer1;
+
+    fclose(fion);
+
+}
+
+void BlockArray::increaseBuffer()
+{
+    if (index < size) { // not even wrapped once
+        return;
+    }
+
+    int offset = (current + size + 1) % size;
+    if (!offset) { // no moving needed
+        return;
+    }
+
+    // The Block constructor could do somthing in future...
+    char * buffer1 = new char[blocksize];
+    char * buffer2 = new char[blocksize];
+
+    int runs = 1;
+    int bpr = size; // blocks per run
+
+    if (size % offset == 0) {
+        bpr = size / offset;
+        runs = offset;
+    }
+
+    FILE * fion = fdopen(dup(ion), "w+b");
+    if (!fion) {
+        perror("fdopen/dup");
+        delete [] buffer1;
+        delete [] buffer2;
+        return;
+    }
+
+    int res;
+    for (int i = 0; i < runs; i++) {
+        // free one block in chain
+        int firstblock = (offset + i) % size;
+        res = fseek(fion, firstblock * blocksize, SEEK_SET);
+        if (res) {
+            perror("fseek");
+        }
+        res = fread(buffer1, blocksize, 1, fion);
+        if (res != 1) {
+            perror("fread");
+        }
+        int newpos = 0;
+        for (int j = 1, cursor=firstblock; j < bpr; j++) {
+            cursor = (cursor + offset) % size;
+            newpos = (cursor - offset + size) % size;
+            moveBlock(fion, cursor, newpos, buffer2);
+        }
+        res = fseek(fion, i * blocksize, SEEK_SET);
+        if (res) {
+            perror("fseek");
+        }
+        res = fwrite(buffer1, blocksize, 1, fion);
+        if (res != 1) {
+            perror("fwrite");
+        }
+    }
+    current = size - 1;
+    length = size;
+
+    delete [] buffer1;
+    delete [] buffer2;
+
+    fclose(fion);
+
+}
+

=== added file 'src/plugin/konsole/BlockArray.h'
--- src/plugin/konsole/BlockArray.h	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/BlockArray.h	2014-05-06 21:50:22 +0000
@@ -0,0 +1,126 @@
+/*
+    This file is part of Konsole, an X terminal.
+    Copyright (C) 2000 by Stephan Kulow <[e-mail]>
+
+    Rewritten for QT4 by e_k <e_k at users.sourceforge.net>, Copyright (C)2008
+
+    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 BLOCKARRAY_H
+#define BLOCKARRAY_H
+
+#include <unistd.h>
+
+//#error Do not use in KDE 2.1
+
+#define BlockSize (1 << 12)
+#define ENTRIES   ((BlockSize - sizeof(size_t) ) / sizeof(unsigned char))
+
+struct Block {
+    Block() {
+        size = 0;
+    }
+    unsigned char data[ENTRIES];
+    size_t size;
+};
+
+// ///////////////////////////////////////////////////////
+
+class BlockArray {
+public:
+    /**
+    * Creates a history file for holding
+    * maximal size blocks. If more blocks
+    * are requested, then it drops earlier
+    * added ones.
+    */
+    BlockArray();
+
+    /// destructor
+    ~BlockArray();
+
+    /**
+    * adds the Block at the end of history.
+    * This may drop other blocks.
+    *
+    * The ownership on the block is transfered.
+    * An unique index number is returned for accessing
+    * it later (if not yet dropped then)
+    *
+    * Note, that the block may be dropped completely
+    * if history is turned off.
+    */
+    size_t append(Block * block);
+
+    /**
+    * gets the block at the index. Function may return
+    * 0 if the block isn't available any more.
+    *
+    * The returned block is strictly readonly as only
+    * maped in memory - and will be invalid on the next
+    * operation on this class.
+    */
+    const Block * at(size_t index);
+
+    /**
+    * reorders blocks as needed. If newsize is null,
+    * the history is emptied completely. The indices
+    * returned on append won't change their semantic,
+    * but they may not be valid after this call.
+    */
+    bool setHistorySize(size_t newsize);
+
+    size_t newBlock();
+
+    Block * lastBlock() const;
+
+    /**
+    * Convenient function to set the size in KBytes
+    * instead of blocks
+    */
+    bool setSize(size_t newsize);
+
+    size_t len() const {
+        return length;
+    }
+
+    bool has(size_t index) const;
+
+    size_t getCurrent() const {
+        return current;
+    }
+
+private:
+    void unmap();
+    void increaseBuffer();
+    void decreaseBuffer(size_t newsize);
+
+    size_t size;
+    // current always shows to the last inserted block
+    size_t current;
+    size_t index;
+
+    Block * lastmap;
+    size_t lastmap_index;
+    Block * lastblock;
+
+    int ion;
+    size_t length;
+
+};
+
+#endif

=== added file 'src/plugin/konsole/CMakeLists.txt'
--- src/plugin/konsole/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/CMakeLists.txt	2014-05-06 21:50:22 +0000
@@ -0,0 +1,93 @@
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set(PLUGIN_DIR org/kde/konsole)
+add_definitions(-DHAVE_POSIX_OPENPT -DHAVE_SYS_TIME_H -DHAVE_UPDWTMPX)
+add_definitions(-DQ_WS_UBUNTU)
+
+set(konsole_SRCS
+    BlockArray.cpp
+    BlockArray.h
+    CharacterColor.h
+    Character.h
+    ColorScheme.cpp
+    ColorScheme.h
+    ColorTables.h
+    DefaultTranslatorText.h
+    Emulation.cpp
+    Emulation.h
+    ExtendedDefaultTranslator.h
+    Filter.cpp
+    Filter.h
+    History.cpp
+    History.h
+    KeyboardTranslator.cpp
+    KeyboardTranslator.h
+    konsole_wcwidth.cpp
+    konsole_wcwidth.h
+    kprocess.cpp
+    kprocess.h
+    kpty.cpp
+    kptydevice.cpp
+    kptydevice.h
+    kpty.h
+    kpty_p.h
+    kptyprocess.cpp
+    kptyprocess.h
+    ksession.cpp
+    ksession.h
+    LineFont.h
+    plugin.cpp
+    plugin.h
+    Pty.cpp
+    Pty.h
+    Screen.cpp
+    Screen.h
+    ScreenWindow.cpp
+    ScreenWindow.h
+    Session.cpp
+    Session.h
+    ShellCommand.cpp
+    ShellCommand.h
+    TerminalCharacterDecoder.cpp
+    TerminalCharacterDecoder.h
+    TerminalDisplay.cpp
+    TerminalDisplay.h
+    tools.cpp
+    tools.h
+    Vt102Emulation.cpp
+    Vt102Emulation.h
+)
+
+add_library(kdekonsole MODULE
+    ${konsole_SRCS}
+)
+
+qt5_use_modules(kdekonsole Gui Qml Quick Widgets)
+
+# Copy the plugin, the qmldir file and other assets to the build dir for running in QtCreator
+if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+    add_custom_target(konsole-qmldir ALL
+        COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/qmldir ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
+        DEPENDS ${QMLFILES}
+    )
+    add_custom_target(konsole-layouts-schemes ALL
+        COMMAND cp -a ${CMAKE_CURRENT_SOURCE_DIR}/assets/color-schemes ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
+        COMMAND cp -a ${CMAKE_CURRENT_SOURCE_DIR}/assets/kb-layouts ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
+        DEPENDS ${QMLFILES}
+    )
+    add_custom_command(TARGET kdekonsole POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
+        COMMENT "Creating plugin directory layout in the build dir"
+        COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:kdekonsole> ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
+        COMMENT "Copying to output directory"
+    )
+endif(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+
+
+install(TARGETS kdekonsole DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN_DIR})
+install(FILES qmldir DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN_DIR})
+install(DIRECTORY assets/color-schemes DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN_DIR})
+install(DIRECTORY assets/kb-layouts DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN_DIR})
+

=== added file 'src/plugin/konsole/Character.h'
--- src/plugin/konsole/Character.h	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/Character.h	2014-05-06 21:50:22 +0000
@@ -0,0 +1,221 @@
+/*
+    This file is part of Konsole, KDE's terminal.
+    
+    Copyright 2007-2008 by Robert Knight <[e-mail]>
+    Copyright 1997,1998 by Lars Doelle <[e-mail]>
+
+    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 CHARACTER_H
+#define CHARACTER_H
+
+// Qt
+#include <QtCore/QHash>
+
+// Local
+#include "CharacterColor.h"
+
+typedef unsigned char LineProperty;
+
+static const int LINE_DEFAULT        = 0;
+static const int LINE_WRAPPED          = (1 << 0);
+static const int LINE_DOUBLEWIDTH      = (1 << 1);
+static const int LINE_DOUBLEHEIGHT    = (1 << 2);
+
+#define DEFAULT_RENDITION  0
+#define RE_BOLD            (1 << 0)
+#define RE_BLINK           (1 << 1)
+#define RE_UNDERLINE       (1 << 2)
+#define RE_REVERSE         (1 << 3) // Screen only
+#define RE_INTENSIVE       (1 << 3) // Widget only
+#define RE_CURSOR          (1 << 4)
+#define RE_EXTENDED_CHAR   (1 << 5)
+
+/**
+ * A single character in the terminal which consists of a unicode character
+ * value, foreground and background colors and a set of rendition attributes
+ * which specify how it should be drawn.
+ */
+class Character
+{
+public:
+  /** 
+   * Constructs a new character.
+   *
+   * @param _c The unicode character value of this character.
+   * @param _f The foreground color used to draw the character.
+   * @param _b The color used to draw the character's background.
+   * @param _r A set of rendition flags which specify how this character is to be drawn.
+   */
+  inline Character(quint16 _c = ' ',
+            CharacterColor  _f = CharacterColor(COLOR_SPACE_DEFAULT,DEFAULT_FORE_COLOR),
+            CharacterColor  _b = CharacterColor(COLOR_SPACE_DEFAULT,DEFAULT_BACK_COLOR),
+            quint8  _r = DEFAULT_RENDITION)
+       : character(_c), rendition(_r), foregroundColor(_f), backgroundColor(_b) {}
+
+  union
+  {
+    /** The unicode character value for this character. */
+    quint16 character;
+    /** 
+     * Experimental addition which allows a single Character instance to contain more than
+     * one unicode character.
+     *
+     * charSequence is a hash code which can be used to look up the unicode
+     * character sequence in the ExtendedCharTable used to create the sequence.
+     */
+    quint16 charSequence; 
+  };
+
+  /** A combination of RENDITION flags which specify options for drawing the character. */
+  quint8  rendition;
+
+  /** The foreground color used to draw this character. */
+  CharacterColor  foregroundColor; 
+  /** The color used to draw this character's background. */
+  CharacterColor  backgroundColor;
+
+  /** 
+   * Returns true if this character has a transparent background when
+   * it is drawn with the specified @p palette.
+   */
+  bool   isTransparent(const ColorEntry* palette) const;
+  /**
+   * Returns true if this character should always be drawn in bold when
+   * it is drawn with the specified @p palette, independent of whether
+   * or not the character has the RE_BOLD rendition flag. 
+   */
+  ColorEntry::FontWeight fontWeight(const ColorEntry* base) const;
+  
+  /** 
+   * returns true if the format (color, rendition flag) of the compared characters is equal
+   */
+  bool equalsFormat(const Character &other) const;
+
+  /** 
+   * Compares two characters and returns true if they have the same unicode character value,
+   * rendition and colors.
+   */
+  friend bool operator == (const Character& a, const Character& b);
+  /**
+   * Compares two characters and returns true if they have different unicode character values,
+   * renditions or colors.
+   */
+  friend bool operator != (const Character& a, const Character& b);
+};
+
+inline bool operator == (const Character& a, const Character& b)
+{ 
+  return a.character == b.character && 
+         a.rendition == b.rendition && 
+         a.foregroundColor == b.foregroundColor && 
+         a.backgroundColor == b.backgroundColor;
+}
+
+inline bool operator != (const Character& a, const Character& b)
+{
+  return    a.character != b.character || 
+            a.rendition != b.rendition || 
+            a.foregroundColor != b.foregroundColor || 
+            a.backgroundColor != b.backgroundColor;
+}
+
+inline bool Character::isTransparent(const ColorEntry* base) const
+{
+  return ((backgroundColor._colorSpace == COLOR_SPACE_DEFAULT) && 
+          base[backgroundColor._u+0+(backgroundColor._v?BASE_COLORS:0)].transparent)
+      || ((backgroundColor._colorSpace == COLOR_SPACE_SYSTEM) && 
+          base[backgroundColor._u+2+(backgroundColor._v?BASE_COLORS:0)].transparent);
+}
+
+inline bool Character::equalsFormat(const Character& other) const
+{
+  return 
+    backgroundColor==other.backgroundColor &&
+    foregroundColor==other.foregroundColor &&
+    rendition==other.rendition;
+}	
+
+inline ColorEntry::FontWeight Character::fontWeight(const ColorEntry* base) const
+{
+    if (backgroundColor._colorSpace == COLOR_SPACE_DEFAULT)
+        return base[backgroundColor._u+0+(backgroundColor._v?BASE_COLORS:0)].fontWeight;
+    else if (backgroundColor._colorSpace == COLOR_SPACE_SYSTEM)
+        return base[backgroundColor._u+2+(backgroundColor._v?BASE_COLORS:0)].fontWeight;
+    else
+        return ColorEntry::UseCurrentFormat;
+}
+
+extern unsigned short vt100_graphics[32];
+
+
+/**
+ * A table which stores sequences of unicode characters, referenced
+ * by hash keys.  The hash key itself is the same size as a unicode
+ * character ( ushort ) so that it can occupy the same space in
+ * a structure.
+ */
+class ExtendedCharTable
+{
+public:
+    /** Constructs a new character table. */
+    ExtendedCharTable();
+    ~ExtendedCharTable();
+
+    /**
+     * Adds a sequences of unicode characters to the table and returns
+     * a hash code which can be used later to look up the sequence
+     * using lookupExtendedChar()
+     *
+     * If the same sequence already exists in the table, the hash
+     * of the existing sequence will be returned.
+     *
+     * @param unicodePoints An array of unicode character points
+     * @param length Length of @p unicodePoints
+     */
+    ushort createExtendedChar(ushort* unicodePoints , ushort length);
+    /**
+     * Looks up and returns a pointer to a sequence of unicode characters
+     * which was added to the table using createExtendedChar().
+     *
+     * @param hash The hash key returned by createExtendedChar()
+     * @param length This variable is set to the length of the 
+     * character sequence.
+     *
+     * @return A unicode character sequence of size @p length.
+     */
+    ushort* lookupExtendedChar(ushort hash , ushort& length) const;
+
+    /** The global ExtendedCharTable instance. */
+    static ExtendedCharTable instance;
+private:
+    // calculates the hash key of a sequence of unicode points of size 'length'
+    ushort extendedCharHash(ushort* unicodePoints , ushort length) const;
+    // tests whether the entry in the table specified by 'hash' matches the 
+    // character sequence 'unicodePoints' of size 'length'
+    bool extendedCharMatch(ushort hash , ushort* unicodePoints , ushort length) const;
+    // internal, maps hash keys to character sequence buffers.  The first ushort
+    // in each value is the length of the buffer, followed by the ushorts in the buffer
+    // themselves.
+    QHash<ushort,ushort*> extendedCharTable;
+};
+
+
+Q_DECLARE_TYPEINFO(Character, Q_MOVABLE_TYPE);
+
+#endif // CHARACTER_H
+

=== added file 'src/plugin/konsole/CharacterColor.h'
--- src/plugin/konsole/CharacterColor.h	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/CharacterColor.h	2014-05-06 21:50:22 +0000
@@ -0,0 +1,294 @@
+/*
+    This file is part of Konsole, KDE's terminal.
+    
+    Copyright 2007-2008 by Robert Knight <[e-mail]>
+    Copyright 1997,1998 by Lars Doelle <[e-mail]>
+
+    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 CHARACTERCOLOR_H
+#define CHARACTERCOLOR_H
+
+// Qt
+#include <QtGui/QColor>
+
+//#include <kdemacros.h>
+#define KDE_NO_EXPORT
+
+/** 
+ * An entry in a terminal display's color palette. 
+ *
+ * A color palette is an array of 16 ColorEntry instances which map
+ * system color indexes (from 0 to 15) into actual colors.
+ *
+ * Each entry can be set as bold, in which case any text
+ * drawn using the color should be drawn in bold.  
+ *
+ * Each entry can also be transparent, in which case the terminal
+ * display should avoid drawing the background for any characters
+ * using the entry as a background.
+ */
+class ColorEntry
+{
+public:
+  /** Specifies the weight to use when drawing text with this color. */
+  enum FontWeight 
+  {
+    /** Always draw text in this color with a bold weight. */
+    Bold,
+    /** Always draw text in this color with a normal weight. */
+    Normal,
+    /** 
+     * Use the current font weight set by the terminal application.  
+     * This is the default behavior.
+     */
+    UseCurrentFormat
+  };
+
+  /** 
+   * Constructs a new color palette entry.
+   *
+   * @param c The color value for this entry.
+   * @param tr Specifies that the color should be transparent when used as a background color.
+   * @param weight Specifies the font weight to use when drawing text with this color. 
+   */
+  ColorEntry(QColor c, bool tr, FontWeight weight = UseCurrentFormat) 
+          : color(c), transparent(tr), fontWeight(weight) {}
+
+  /**
+   * Constructs a new color palette entry with an undefined color, and
+   * with the transparent and bold flags set to false.
+   */ 
+  ColorEntry() : transparent(false), fontWeight(UseCurrentFormat) {} 
+ 
+  /**
+   * Sets the color, transparency and boldness of this color to those of @p rhs.
+   */ 
+  void operator=(const ColorEntry& rhs) 
+  { 
+       color = rhs.color; 
+       transparent = rhs.transparent; 
+       fontWeight = rhs.fontWeight; 
+  }
+
+  /** The color value of this entry for display. */
+  QColor color;
+
+  /** 
+   * If true character backgrounds using this color should be transparent. 
+   * This is not applicable when the color is used to render text.
+   */
+  bool   transparent;
+  /**
+   * Specifies the font weight to use when drawing text with this color. 
+   * This is not applicable when the color is used to draw a character's background.
+   */
+  FontWeight fontWeight;        
+};
+
+
+// Attributed Character Representations ///////////////////////////////
+
+// Colors
+
+#define BASE_COLORS   (2+8)
+#define INTENSITIES   2
+#define TABLE_COLORS  (INTENSITIES*BASE_COLORS)
+
+#define DEFAULT_FORE_COLOR 0
+#define DEFAULT_BACK_COLOR 1
+
+//a standard set of colors using black text on a white background.
+//defined in TerminalDisplay.cpp
+
+extern const ColorEntry base_color_table[TABLE_COLORS] KDE_NO_EXPORT;
+
+/* CharacterColor is a union of the various color spaces.
+
+   Assignment is as follows:
+
+   Type  - Space        - Values
+
+   0     - Undefined   - u:  0,      v:0        w:0
+   1     - Default     - u:  0..1    v:intense  w:0
+   2     - System      - u:  0..7    v:intense  w:0
+   3     - Index(256)  - u: 16..255  v:0        w:0
+   4     - RGB         - u:  0..255  v:0..256   w:0..256
+
+   Default colour space has two separate colours, namely
+   default foreground and default background colour.
+*/
+
+#define COLOR_SPACE_UNDEFINED   0
+#define COLOR_SPACE_DEFAULT     1
+#define COLOR_SPACE_SYSTEM      2
+#define COLOR_SPACE_256         3
+#define COLOR_SPACE_RGB         4
+
+/**
+ * Describes the color of a single character in the terminal.
+ */
+class CharacterColor
+{
+    friend class Character;
+
+public:
+  /** Constructs a new CharacterColor whoose color and color space are undefined. */
+  CharacterColor() 
+      : _colorSpace(COLOR_SPACE_UNDEFINED), 
+        _u(0), 
+        _v(0), 
+        _w(0) 
+  {}
+
+  /** 
+   * Constructs a new CharacterColor using the specified @p colorSpace and with 
+   * color value @p co
+   *
+   * The meaning of @p co depends on the @p colorSpace used.
+   *
+   * TODO : Document how @p co relates to @p colorSpace
+   *
+   * TODO : Add documentation about available color spaces.
+   */
+  CharacterColor(quint8 colorSpace, int co) 
+      : _colorSpace(colorSpace), 
+        _u(0), 
+        _v(0), 
+        _w(0)
+  {
+    switch (colorSpace)
+    {
+        case COLOR_SPACE_DEFAULT:
+            _u = co & 1;
+            break;
+        case COLOR_SPACE_SYSTEM:
+            _u = co & 7;
+            _v = (co >> 3) & 1;
+            break;
+        case COLOR_SPACE_256:  
+            _u = co & 255;
+            break;
+        case COLOR_SPACE_RGB:
+            _u = co >> 16;
+            _v = co >> 8;
+            _w = co;
+            break;
+        default:
+            _colorSpace = COLOR_SPACE_UNDEFINED;
+    }
+  }
+
+  /** 
+   * Returns true if this character color entry is valid.
+   */
+  bool isValid() 
+  {
+        return _colorSpace != COLOR_SPACE_UNDEFINED;
+  }
+    
+  /** 
+   * Toggles the value of this color between a normal system color and the corresponding intensive
+   * system color.
+   * 
+   * This is only applicable if the color is using the COLOR_SPACE_DEFAULT or COLOR_SPACE_SYSTEM
+   * color spaces.
+   */
+  void toggleIntensive();
+
+  /** 
+   * Returns the color within the specified color @p palette
+   *
+   * The @p palette is only used if this color is one of the 16 system colors, otherwise
+   * it is ignored.
+   */
+  QColor color(const ColorEntry* palette) const;
+ 
+  /** 
+   * Compares two colors and returns true if they represent the same color value and
+   * use the same color space.
+   */
+  friend bool operator == (const CharacterColor& a, const CharacterColor& b);
+  /**
+   * Compares two colors and returns true if they represent different color values
+   * or use different color spaces.
+   */
+  friend bool operator != (const CharacterColor& a, const CharacterColor& b);
+
+private:
+  quint8 _colorSpace;
+
+  // bytes storing the character color 
+  quint8 _u; 
+  quint8 _v; 
+  quint8 _w; 
+};
+
+inline bool operator == (const CharacterColor& a, const CharacterColor& b)
+{ 
+    return     a._colorSpace == b._colorSpace &&
+            a._u == b._u &&
+            a._v == b._v &&
+            a._w == b._w;
+}
+inline bool operator != (const CharacterColor& a, const CharacterColor& b)
+{
+    return !operator==(a,b);
+}
+
+inline const QColor color256(quint8 u, const ColorEntry* base)
+{
+  //   0.. 16: system colors
+  if (u <   8) return base[u+2            ].color; u -= 8;
+  if (u <   8) return base[u+2+BASE_COLORS].color; u -= 8;
+
+  //  16..231: 6x6x6 rgb color cube
+  if (u < 216) return QColor(((u/36)%6) ? (40*((u/36)%6)+55) : 0,
+                             ((u/ 6)%6) ? (40*((u/ 6)%6)+55) : 0,
+                             ((u/ 1)%6) ? (40*((u/ 1)%6)+55) : 0); u -= 216;
+  
+  // 232..255: gray, leaving out black and white
+  int gray = u*10+8; return QColor(gray,gray,gray);
+}
+
+inline QColor CharacterColor::color(const ColorEntry* base) const
+{
+  switch (_colorSpace)
+  {
+    case COLOR_SPACE_DEFAULT: return base[_u+0+(_v?BASE_COLORS:0)].color;
+    case COLOR_SPACE_SYSTEM: return base[_u+2+(_v?BASE_COLORS:0)].color;
+    case COLOR_SPACE_256: return color256(_u,base);
+    case COLOR_SPACE_RGB: return QColor(_u,_v,_w);
+    case COLOR_SPACE_UNDEFINED: return QColor();
+  }
+
+  Q_ASSERT(false); // invalid color space
+
+  return QColor();
+}
+
+inline void CharacterColor::toggleIntensive()
+{
+  if (_colorSpace == COLOR_SPACE_SYSTEM || _colorSpace == COLOR_SPACE_DEFAULT)
+  {
+    _v = !_v;
+  }
+}
+
+
+#endif // CHARACTERCOLOR_H
+

=== added file 'src/plugin/konsole/ColorScheme.cpp'
--- src/plugin/konsole/ColorScheme.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/ColorScheme.cpp	2014-05-06 21:50:22 +0000
@@ -0,0 +1,774 @@
+/*
+    This source file is part of Konsole, a terminal emulator.
+
+    Copyright 2007-2008 by Robert Knight <[e-mail]>
+
+    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 "ColorScheme.h"
+#include "tools.h"
+
+// Qt
+#include <QtGui/QBrush>
+#include <QtCore/QFile>
+#include <QtCore/QFileInfo>
+#include <QtDebug>
+#include <QSettings>
+#include <QDir>
+
+
+// KDE
+//#include <KColorScheme>
+//#include <KConfig>
+//#include <KLocale>
+//#include <KDebug>
+//#include <KConfigGroup>
+//#include <KStandardDirs>
+
+
+const ColorEntry ColorScheme::defaultTable[TABLE_COLORS] =
+ // The following are almost IBM standard color codes, with some slight
+ // gamma correction for the dim colors to compensate for bright X screens.
+ // It contains the 8 ansiterm/xterm colors in 2 intensities.
+{
+    ColorEntry( QColor(0x00,0x00,0x00), 0), ColorEntry(
+QColor(0xFF,0xFF,0xFF), 1), // Dfore, Dback
+    ColorEntry( QColor(0x00,0x00,0x00), 0), ColorEntry(
+QColor(0xB2,0x18,0x18), 0), // Black, Red
+    ColorEntry( QColor(0x18,0xB2,0x18), 0), ColorEntry(
+QColor(0xB2,0x68,0x18), 0), // Green, Yellow
+    ColorEntry( QColor(0x18,0x18,0xB2), 0), ColorEntry(
+QColor(0xB2,0x18,0xB2), 0), // Blue, Magenta
+    ColorEntry( QColor(0x18,0xB2,0xB2), 0), ColorEntry(
+QColor(0xB2,0xB2,0xB2), 0), // Cyan, White
+    // intensive
+    ColorEntry( QColor(0x00,0x00,0x00), 0), ColorEntry(
+QColor(0xFF,0xFF,0xFF), 1),
+    ColorEntry( QColor(0x68,0x68,0x68), 0), ColorEntry(
+QColor(0xFF,0x54,0x54), 0),
+    ColorEntry( QColor(0x54,0xFF,0x54), 0), ColorEntry(
+QColor(0xFF,0xFF,0x54), 0),
+    ColorEntry( QColor(0x54,0x54,0xFF), 0), ColorEntry(
+QColor(0xFF,0x54,0xFF), 0),
+    ColorEntry( QColor(0x54,0xFF,0xFF), 0), ColorEntry(
+QColor(0xFF,0xFF,0xFF), 0)
+};
+
+const char* const ColorScheme::colorNames[TABLE_COLORS] =
+{
+  "Foreground",
+  "Background",
+  "Color0",
+  "Color1",
+  "Color2",
+  "Color3",
+  "Color4",
+  "Color5",
+  "Color6",
+  "Color7",
+  "ForegroundIntense",
+  "BackgroundIntense",
+  "Color0Intense",
+  "Color1Intense",
+  "Color2Intense",
+  "Color3Intense",
+  "Color4Intense",
+  "Color5Intense",
+  "Color6Intense",
+  "Color7Intense"
+};
+// dummy silently comment out the tr_NOOP
+#define tr_NOOP
+const char* const ColorScheme::translatedColorNames[TABLE_COLORS] =
+{
+    tr_NOOP("Foreground"),
+    tr_NOOP("Background"),
+    tr_NOOP("Color 1"),
+    tr_NOOP("Color 2"),
+    tr_NOOP("Color 3"),
+    tr_NOOP("Color 4"),
+    tr_NOOP("Color 5"),
+    tr_NOOP("Color 6"),
+    tr_NOOP("Color 7"),
+    tr_NOOP("Color 8"),
+    tr_NOOP("Foreground (Intense)"),
+    tr_NOOP("Background (Intense)"),
+    tr_NOOP("Color 1 (Intense)"),
+    tr_NOOP("Color 2 (Intense)"),
+    tr_NOOP("Color 3 (Intense)"),
+    tr_NOOP("Color 4 (Intense)"),
+    tr_NOOP("Color 5 (Intense)"),
+    tr_NOOP("Color 6 (Intense)"),
+    tr_NOOP("Color 7 (Intense)"),
+    tr_NOOP("Color 8 (Intense)")
+};
+
+ColorScheme::ColorScheme()
+{
+    _table = 0;
+    _randomTable = 0;
+    _opacity = 1.0;
+}
+ColorScheme::ColorScheme(const ColorScheme& other)
+      : _opacity(other._opacity)
+       ,_table(0)
+       ,_randomTable(0)
+{
+    setName(other.name());
+    setDescription(other.description());
+
+    if ( other._table != 0 )
+    {
+        for ( int i = 0 ; i < TABLE_COLORS ; i++ )
+            setColorTableEntry(i,other._table[i]);
+    }
+
+    if ( other._randomTable != 0 )
+    {
+        for ( int i = 0 ; i < TABLE_COLORS ; i++ )
+        {
+            const RandomizationRange& range = other._randomTable[i];
+            setRandomizationRange(i,range.hue,range.saturation,range.value);
+        }
+    }
+}
+ColorScheme::~ColorScheme()
+{
+    delete[] _table;
+    delete[] _randomTable;
+}
+
+void ColorScheme::setDescription(const QString& description) { _description = description; }
+QString ColorScheme::description() const { return _description; }
+
+void ColorScheme::setName(const QString& name) { _name = name; }
+QString ColorScheme::name() const { return _name; }
+
+void ColorScheme::setColorTableEntry(int index , const ColorEntry& entry)
+{
+    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
+
+    if ( !_table ) 
+    {
+        _table = new ColorEntry[TABLE_COLORS];
+
+        for (int i=0;i<TABLE_COLORS;i++)
+            _table[i] = defaultTable[i];
+    }
+    
+    _table[index] = entry; 
+}
+ColorEntry ColorScheme::colorEntry(int index , uint randomSeed) const
+{
+    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
+
+    if ( randomSeed != 0 )
+        qsrand(randomSeed);
+
+    ColorEntry entry = colorTable()[index];
+
+    if ( randomSeed != 0 && 
+        _randomTable != 0 && 
+        !_randomTable[index].isNull() )
+    {
+        const RandomizationRange& range = _randomTable[index];
+      
+
+        int hueDifference = range.hue ? (qrand() % range.hue) - range.hue/2 : 0;
+        int saturationDifference = range.saturation ? (qrand() % range.saturation) - range.saturation/2 : 0;
+        int  valueDifference = range.value ? (qrand() % range.value) - range.value/2 : 0;
+
+        QColor& color = entry.color;
+      
+        int newHue = qAbs( (color.hue() + hueDifference) % MAX_HUE );
+        int newValue = qMin( qAbs(color.value() + valueDifference) , 255 );
+        int newSaturation = qMin( qAbs(color.saturation() + saturationDifference) , 255 );
+
+        color.setHsv(newHue,newSaturation,newValue);
+    }
+
+    return entry;
+}
+void ColorScheme::getColorTable(ColorEntry* table , uint randomSeed) const
+{
+    for ( int i = 0 ; i < TABLE_COLORS ; i++ )
+        table[i] = colorEntry(i,randomSeed);
+}
+bool ColorScheme::randomizedBackgroundColor() const
+{
+    return _randomTable == 0 ? false : !_randomTable[1].isNull();
+}
+void ColorScheme::setRandomizedBackgroundColor(bool randomize)
+{
+    // the hue of the background colour is allowed to be randomly 
+    // adjusted as much as possible.
+    //
+    // the value and saturation are left alone to maintain read-ability
+    if ( randomize )
+    {
+        setRandomizationRange( 1 /* background color index */ , MAX_HUE , 255 , 0 ); 
+    }
+    else
+    {
+        if ( _randomTable )
+            setRandomizationRange( 1 /* background color index */ , 0 , 0 , 0 );
+    }
+}
+
+void ColorScheme::setRandomizationRange( int index , quint16 hue , quint8 saturation ,
+                                         quint8 value )
+{
+    Q_ASSERT( hue <= MAX_HUE );
+    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
+
+    if ( _randomTable == 0 )
+        _randomTable = new RandomizationRange[TABLE_COLORS];
+
+    _randomTable[index].hue = hue;
+    _randomTable[index].value = value;
+    _randomTable[index].saturation = saturation;
+}
+
+const ColorEntry* ColorScheme::colorTable() const
+{
+    if ( _table )
+        return _table;
+    else
+        return defaultTable;
+}
+QColor ColorScheme::foregroundColor() const
+{
+    return colorTable()[0].color;
+}
+QColor ColorScheme::backgroundColor() const
+{
+    return colorTable()[1].color;
+}
+bool ColorScheme::hasDarkBackground() const
+{
+    // value can range from 0 - 255, with larger values indicating higher brightness.
+    // so 127 is in the middle, anything less is deemed 'dark'
+    return backgroundColor().value() < 127;
+}
+void ColorScheme::setOpacity(qreal opacity) { _opacity = opacity; }
+qreal ColorScheme::opacity() const { return _opacity; }
+
+void ColorScheme::read(const QString & fileName)
+{
+    QSettings s(fileName, QSettings::IniFormat);
+    s.beginGroup("General");
+
+    _description = s.value("Description", QObject::tr("Un-named Color Scheme")).toString();
+    _opacity = s.value("Opacity",qreal(1.0)).toDouble();
+    s.endGroup();
+
+    for (int i=0 ; i < TABLE_COLORS ; i++)
+    {
+        readColorEntry(&s, i);
+    }
+}
+#if 0
+// implemented upstream - user apps
+void ColorScheme::read(KConfig& config)
+{
+    KConfigGroup configGroup = config.group("General");
+
+    QString description = configGroup.readEntry("Description", QObject::tr("Un-named Color Scheme"));
+
+    _description = tr(description.toUtf8());
+    _opacity = configGroup.readEntry("Opacity",qreal(1.0));
+
+    for (int i=0 ; i < TABLE_COLORS ; i++)
+    {
+        readColorEntry(config,i);
+    }
+}
+void ColorScheme::write(KConfig& config) const
+{
+    KConfigGroup configGroup = config.group("General");
+
+    configGroup.writeEntry("Description",_description);
+    configGroup.writeEntry("Opacity",_opacity);
+    
+    for (int i=0 ; i < TABLE_COLORS ; i++)
+    {
+        RandomizationRange random = _randomTable != 0 ? _randomTable[i] : RandomizationRange();
+        writeColorEntry(config,colorNameForIndex(i),colorTable()[i],random);
+    }
+}
+#endif
+
+QString ColorScheme::colorNameForIndex(int index) 
+{
+    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
+
+    return QString(colorNames[index]);
+}
+QString ColorScheme::translatedColorNameForIndex(int index) 
+{
+    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
+
+    return translatedColorNames[index];
+}
+
+void ColorScheme::readColorEntry(QSettings * s , int index)
+{
+    s->beginGroup(colorNameForIndex(index));
+    
+    ColorEntry entry;
+
+    QStringList rgbList = s->value("Color", QStringList()).toStringList();
+    if (rgbList.count() != 3)
+    {
+        Q_ASSERT(0);
+    }
+    int r, g, b;
+    r = rgbList[0].toInt();
+    g = rgbList[1].toInt();
+    b = rgbList[2].toInt();
+    entry.color = QColor(r, g, b);
+    
+    entry.transparent = s->value("Transparent",false).toBool();
+
+    // Deprecated key from KDE 4.0 which set 'Bold' to true to force
+    // a color to be bold or false to use the current format
+    //
+    // TODO - Add a new tri-state key which allows for bold, normal or
+    // current format
+    if (s->contains("Bold"))
+        entry.fontWeight = s->value("Bold",false).toBool() ? ColorEntry::Bold :
+                                                                 ColorEntry::UseCurrentFormat;
+
+    quint16 hue = s->value("MaxRandomHue",0).toInt();
+    quint8 value = s->value("MaxRandomValue",0).toInt();
+    quint8 saturation = s->value("MaxRandomSaturation",0).toInt();
+
+    setColorTableEntry( index , entry );
+
+    if ( hue != 0 || value != 0 || saturation != 0 )
+       setRandomizationRange( index , hue , saturation , value ); 
+
+    s->endGroup();
+}
+#if 0
+// implemented upstream - user apps
+void ColorScheme::writeColorEntry(KConfig& config , const QString& colorName, const ColorEntry& entry , const RandomizationRange& random) const
+{
+    KConfigGroup configGroup(&config,colorName);
+
+    configGroup.writeEntry("Color",entry.color);
+    configGroup.writeEntry("Transparency",(bool)entry.transparent);
+    if (entry.fontWeight != ColorEntry::UseCurrentFormat)
+    {
+        configGroup.writeEntry("Bold",entry.fontWeight == ColorEntry::Bold);
+    }
+
+    // record randomization if this color has randomization or 
+    // if one of the keys already exists 
+    if ( !random.isNull() || configGroup.hasKey("MaxRandomHue") )
+    {
+        configGroup.writeEntry("MaxRandomHue",(int)random.hue);
+        configGroup.writeEntry("MaxRandomValue",(int)random.value);
+        configGroup.writeEntry("MaxRandomSaturation",(int)random.saturation);
+    }
+}
+#endif
+
+// 
+// Work In Progress - A color scheme for use on KDE setups for users
+// with visual disabilities which means that they may have trouble
+// reading text with the supplied color schemes.
+//
+// This color scheme uses only the 'safe' colors defined by the
+// KColorScheme class.  
+//
+// A complication this introduces is that each color provided by 
+// KColorScheme is defined as a 'background' or 'foreground' color.
+// Only foreground colors are allowed to be used to render text and 
+// only background colors are allowed to be used for backgrounds.
+//
+// The ColorEntry and TerminalDisplay classes do not currently
+// support this restriction.  
+//
+// Requirements:
+//  - A color scheme which uses only colors from the KColorScheme class
+//  - Ability to restrict which colors the TerminalDisplay widget 
+//    uses as foreground and background color
+//  - Make use of KGlobalSettings::allowDefaultBackgroundImages() as
+//    a hint to determine whether this accessible color scheme should 
+//    be used by default.
+//
+//
+// -- Robert Knight <[e-mail]> 21/07/2007
+//
+AccessibleColorScheme::AccessibleColorScheme()
+    : ColorScheme()
+{
+#if 0
+// It's not finished in konsole and it breaks Qt4 compilation as well
+    // basic attributes
+    setName("accessible");
+    setDescription(QObject::tr("Accessible Color Scheme"));
+
+    // setup colors
+    const int ColorRoleCount = 8;
+
+    const KColorScheme colorScheme(QPalette::Active);
+
+    QBrush colors[ColorRoleCount] =
+    {
+        colorScheme.foreground( colorScheme.NormalText ),
+        colorScheme.background( colorScheme.NormalBackground ),
+
+        colorScheme.foreground( colorScheme.InactiveText ),
+        colorScheme.foreground( colorScheme.ActiveText ),
+        colorScheme.foreground( colorScheme.LinkText ),
+        colorScheme.foreground( colorScheme.VisitedText ),
+        colorScheme.foreground( colorScheme.NegativeText ),
+        colorScheme.foreground( colorScheme.NeutralText )
+    };
+
+    for ( int i = 0 ; i < TABLE_COLORS ; i++ ) 
+    {
+        ColorEntry entry;
+        entry.color = colors[ i % ColorRoleCount ].color();
+
+        setColorTableEntry( i , entry ); 
+    }   
+#endif
+}
+
+KDE3ColorSchemeReader::KDE3ColorSchemeReader( QIODevice* device ) :
+    _device(device)
+{
+}
+ColorScheme* KDE3ColorSchemeReader::read() 
+{
+    Q_ASSERT( _device->openMode() == QIODevice::ReadOnly ||
+              _device->openMode() == QIODevice::ReadWrite  );
+
+    ColorScheme* scheme = new ColorScheme();
+
+    QRegExp comment("#.*$");
+    while ( !_device->atEnd() )
+    {
+        QString line(_device->readLine());
+        line.remove(comment);
+        line = line.simplified();
+
+        if ( line.isEmpty() )
+            continue;
+
+        if ( line.startsWith(QLatin1String("color")) )
+        {
+            if (!readColorLine(line,scheme))
+                qDebug() << "Failed to read KDE 3 color scheme line" << line;
+        }
+        else if ( line.startsWith(QLatin1String("title")) )
+        {
+            if (!readTitleLine(line,scheme))
+                qDebug() << "Failed to read KDE 3 color scheme title line" << line;
+        }
+        else
+        {
+            qDebug() << "KDE 3 color scheme contains an unsupported feature, '" <<
+                line << "'";
+        } 
+    }
+
+    return scheme;
+}
+bool KDE3ColorSchemeReader::readColorLine(const QString& line,ColorScheme* scheme)
+{
+    QStringList list = line.split(QChar(' '));
+
+    if (list.count() != 7)
+        return false;
+    if (list.first() != "color")
+        return false;
+    
+    int index = list[1].toInt();
+    int red = list[2].toInt();
+    int green = list[3].toInt();
+    int blue = list[4].toInt();
+    int transparent = list[5].toInt();
+    int bold = list[6].toInt();
+
+    const int MAX_COLOR_VALUE = 255;
+
+    if(     (index < 0 || index >= TABLE_COLORS )
+        ||  (red < 0 || red > MAX_COLOR_VALUE )
+        ||  (blue < 0 || blue > MAX_COLOR_VALUE )
+        ||  (green < 0 || green > MAX_COLOR_VALUE )
+        ||  (transparent != 0 && transparent != 1 )
+        ||  (bold != 0 && bold != 1)    )
+        return false;
+
+    ColorEntry entry;
+    entry.color = QColor(red,green,blue);
+    entry.transparent = ( transparent != 0 );
+    entry.fontWeight = ( bold != 0 ) ? ColorEntry::Bold : ColorEntry::UseCurrentFormat;
+
+    scheme->setColorTableEntry(index,entry);
+    return true;
+}
+bool KDE3ColorSchemeReader::readTitleLine(const QString& line,ColorScheme* scheme)
+{
+    if( !line.startsWith(QLatin1String("title")) )
+        return false;
+
+    int spacePos = line.indexOf(' ');
+    if( spacePos == -1 )
+        return false;
+
+    QString description = line.mid(spacePos+1);
+
+    scheme->setDescription(description.toUtf8());
+    return true;
+}
+ColorSchemeManager::ColorSchemeManager()
+    : _haveLoadedAll(false)
+{
+}
+ColorSchemeManager::~ColorSchemeManager()
+{
+    QHashIterator<QString,const ColorScheme*> iter(_colorSchemes);
+    while (iter.hasNext())
+    {
+        iter.next();
+        delete iter.value();
+    }
+}
+void ColorSchemeManager::loadAllColorSchemes()
+{
+    qDebug() << "loadAllColorSchemes";
+    int success = 0;
+    int failed = 0;
+
+    QList<QString> nativeColorSchemes = listColorSchemes();
+
+    QListIterator<QString> nativeIter(nativeColorSchemes);
+    while ( nativeIter.hasNext() )
+    {
+        if ( loadColorScheme( nativeIter.next() ) )
+            success++;
+        else
+            failed++;
+    }
+
+    QList<QString> kde3ColorSchemes = listKDE3ColorSchemes();
+    QListIterator<QString> kde3Iter(kde3ColorSchemes);
+    while ( kde3Iter.hasNext() )
+    {
+        if ( loadKDE3ColorScheme( kde3Iter.next() ) )
+            success++;
+        else
+            failed++;
+    }
+
+    if ( failed > 0 )
+        qDebug() << "failed to load " << failed << " color schemes.";
+
+    _haveLoadedAll = true;
+}
+QList<const ColorScheme*> ColorSchemeManager::allColorSchemes()
+{
+    if ( !_haveLoadedAll )
+    {
+        loadAllColorSchemes();
+    }
+
+    return _colorSchemes.values();
+}
+bool ColorSchemeManager::loadKDE3ColorScheme(const QString& filePath)
+{
+    QFile file(filePath);
+    if (!filePath.endsWith(QLatin1String(".schema")) || !file.open(QIODevice::ReadOnly))
+        return false;
+
+    KDE3ColorSchemeReader reader(&file);
+    ColorScheme* scheme = reader.read();
+    scheme->setName(QFileInfo(file).baseName());
+    file.close();
+
+    if (scheme->name().isEmpty())
+    {
+        qDebug() << "color scheme name is not valid.";
+        delete scheme;
+        return false;
+    }
+    
+    QFileInfo info(filePath);
+
+    if ( !_colorSchemes.contains(info.baseName()) )
+        _colorSchemes.insert(scheme->name(),scheme);
+    else
+    {
+        qDebug() << "color scheme with name" << scheme->name() << "has already been" <<
+            "found, ignoring.";
+        delete scheme;
+    }
+
+    return true;
+}
+#if 0
+void ColorSchemeManager::addColorScheme(ColorScheme* scheme) 
+{
+    _colorSchemes.insert(scheme->name(),scheme);
+
+    // save changes to disk
+    QString path = KGlobal::dirs()->saveLocation("data","konsole/") + scheme->name() + ".colorscheme";
+    KConfig config(path , KConfig::NoGlobals);
+
+    scheme->write(config);
+}
+#endif
+bool ColorSchemeManager::loadColorScheme(const QString& filePath)
+{
+    if ( !filePath.endsWith(QLatin1String(".colorscheme")) || !QFile::exists(filePath) )
+        return false;
+
+    QFileInfo info(filePath);
+    
+    ColorScheme* scheme = new ColorScheme();
+    scheme->setName(info.baseName());
+    scheme->read(filePath);
+
+    if (scheme->name().isEmpty()) 
+    {
+        qDebug() << "Color scheme in" << filePath << "does not have a valid name and was not loaded.";
+        delete scheme;
+        return false;
+    }    
+
+    if ( !_colorSchemes.contains(info.baseName()) )
+    {
+        _colorSchemes.insert(scheme->name(),scheme);
+    }
+    else
+    {
+        qDebug() << "color scheme with name" << scheme->name() << "has already been" <<
+            "found, ignoring.";
+        
+        delete scheme;
+    }
+
+    return true; 
+}
+QList<QString> ColorSchemeManager::listKDE3ColorSchemes()
+{
+    QString dname(get_color_schemes_dir());
+    QDir dir(dname);
+    QStringList filters;
+    filters << "*.schema";
+    dir.setNameFilters(filters);
+    QStringList list = dir.entryList(filters); 
+    QStringList ret;
+    foreach(QString i, list)
+        ret << dname + "/" + i;
+    return ret;
+    //return KGlobal::dirs()->findAllResources("data",
+    //                                         "konsole/*.schema",
+    //                                          KStandardDirs::NoDuplicates);
+    //
+}
+QList<QString> ColorSchemeManager::listColorSchemes()
+{
+    QString dname(get_color_schemes_dir());
+    QDir dir(dname);
+    QStringList filters;
+    filters << "*.colorscheme";
+    dir.setNameFilters(filters);
+    QStringList list = dir.entryList(filters);
+    QStringList ret;
+    foreach(QString i, list)
+        ret << dname + "/" + i;
+    return ret;
+//    return KGlobal::dirs()->findAllResources("data",
+//                                             "konsole/*.colorscheme",
+//                                             KStandardDirs::NoDuplicates);
+}
+const ColorScheme ColorSchemeManager::_defaultColorScheme;
+const ColorScheme* ColorSchemeManager::defaultColorScheme() const
+{
+    return &_defaultColorScheme;
+}
+bool ColorSchemeManager::deleteColorScheme(const QString& name)
+{
+    Q_ASSERT( _colorSchemes.contains(name) );
+
+    // lookup the path and delete 
+    QString path = findColorSchemePath(name);
+    if ( QFile::remove(path) )
+    {
+        _colorSchemes.remove(name);
+        return true;
+    }
+    else
+    {
+        qDebug() << "Failed to remove color scheme -" << path;
+        return false;
+    }
+}
+QString ColorSchemeManager::findColorSchemePath(const QString& name) const
+{
+//    QString path = KStandardDirs::locate("data","konsole/"+name+".colorscheme");
+    QString path(get_color_schemes_dir() + "/"+ name + ".colorscheme");
+    if ( !path.isEmpty() )
+       return path; 
+
+    //path = KStandardDirs::locate("data","konsole/"+name+".schema");
+    path = get_color_schemes_dir() + "/"+ name + ".schema";
+
+    return path;
+}
+const ColorScheme* ColorSchemeManager::findColorScheme(const QString& name) 
+{
+    if ( name.isEmpty() )
+        return defaultColorScheme();
+
+    if ( _colorSchemes.contains(name) )
+        return _colorSchemes[name];
+    else
+    {
+        // look for this color scheme
+        QString path = findColorSchemePath(name); 
+        if ( !path.isEmpty() && loadColorScheme(path) )
+        {
+            return findColorScheme(name); 
+        } 
+        else 
+        {
+            if (!path.isEmpty() && loadKDE3ColorScheme(path))
+                return findColorScheme(name);
+        }
+
+        qDebug() << "Could not find color scheme - " << name;
+
+        return 0; 
+    }
+}
+
+ColorSchemeManager* ColorSchemeManager::theColorSchemeManager = 0;
+//K_GLOBAL_STATIC( ColorSchemeManager , theColorSchemeManager )
+ColorSchemeManager* ColorSchemeManager::instance()
+{
+    if (! theColorSchemeManager)
+        theColorSchemeManager = new ColorSchemeManager();
+    return theColorSchemeManager;
+}

=== added file 'src/plugin/konsole/ColorScheme.h'
--- src/plugin/konsole/ColorScheme.h	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/ColorScheme.h	2014-05-06 21:50:22 +0000
@@ -0,0 +1,342 @@
+/*
+    This source file is part of Konsole, a terminal emulator.
+
+    Copyright 2007-2008 by Robert Knight <[e-mail]>
+
+    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 COLORSCHEME_H
+#define COLORSCHEME_H
+
+// Qt
+#include <QtCore/QHash>
+#include <QtCore/QList>
+#include <QtCore/QMetaType>
+#include <QtCore/QIODevice>
+#include <QtCore/QSet>
+#include <QSettings>
+
+// Konsole
+#include "CharacterColor.h"
+
+class QIODevice;
+//class KConfig;
+
+
+/**
+ * Represents a color scheme for a terminal display.  
+ *
+ * The color scheme includes the palette of colors used to draw the text and character backgrounds
+ * in the display and the opacity level of the display background. 
+ */
+class ColorScheme
+{
+public:
+    /** 
+     * Constructs a new color scheme which is initialised to the default color set 
+     * for Konsole.
+     */
+    ColorScheme();
+    ColorScheme(const ColorScheme& other);
+    ~ColorScheme();
+
+    /** Sets the descriptive name of the color scheme. */
+    void setDescription(const QString& description);
+    /** Returns the descriptive name of the color scheme. */
+    QString description() const;
+
+    /** Sets the name of the color scheme */
+    void setName(const QString& name);
+    /** Returns the name of the color scheme */
+    QString name() const;
+
+#if 0
+// Implemented upstream - in user apps
+    /** Reads the color scheme from the specified configuration source */
+    void read(KConfig& config);
+    /** Writes the color scheme to the specified configuration source */
+    void write(KConfig& config) const;
+#endif
+    void read(const QString & filename);
+
+    /** Sets a single entry within the color palette. */
+    void setColorTableEntry(int index , const ColorEntry& entry);
+
+    /** 
+     * Copies the color entries which form the palette for this color scheme
+     * into @p table.  @p table should be an array with TABLE_COLORS entries.
+     *
+     * @param table Array into which the color entries for this color scheme
+     * are copied.
+     * @param randomSeed Color schemes may allow certain colors in their
+     * palette to be randomized.  The seed is used to pick the random color.
+     */
+    void getColorTable(ColorEntry* table, uint randomSeed = 0) const;
+   
+    /**
+     * Retrieves a single color entry from the table.
+     *
+     * See getColorTable()
+     */
+    ColorEntry colorEntry(int index , uint randomSeed = 0) const;
+
+    /** 
+     * Convenience method.  Returns the 
+     * foreground color for this scheme, 
+     * this is the primary color used to draw the 
+     * text in this scheme.
+     */
+    QColor foregroundColor() const;
+    /**
+     * Convenience method.  Returns the background color for 
+     * this scheme, this is the primary color used to 
+     * draw the terminal background in this scheme.
+     */
+    QColor backgroundColor() const;
+
+    /** 
+     * Returns true if this color scheme has a dark background.
+     * The background color is said to be dark if it has a value of less than 127
+     * in the HSV color space.
+     */
+    bool hasDarkBackground() const;
+
+    /** 
+     * Sets the opacity level of the display background. @p opacity ranges
+     * between 0 (completely transparent background) and 1 (completely
+     * opaque background).
+     *
+     * Defaults to 1.
+     *
+     * TODO: More documentation
+     */
+    void setOpacity(qreal opacity);
+    /** 
+     * Returns the opacity level for this color scheme, see setOpacity()
+     * TODO: More documentation
+     */
+    qreal opacity() const;
+
+    /** 
+     * Enables randomization of the background color.  This will cause
+     * the palette returned by getColorTable() and colorEntry() to
+     * be adjusted depending on the value of the random seed argument
+     * to them.
+     */ 
+    void setRandomizedBackgroundColor(bool randomize);
+
+    /** Returns true if the background color is randomized. */
+    bool randomizedBackgroundColor() const;
+
+    static QString colorNameForIndex(int index);
+    static QString translatedColorNameForIndex(int index);
+
+private:
+    // specifies how much a particular color can be randomized by
+    class RandomizationRange
+    {
+    public:
+        RandomizationRange() : hue(0) , saturation(0) , value(0) {}
+
+        bool isNull() const 
+        {
+            return ( hue == 0 && saturation == 0 && value == 0 );
+        }
+
+        quint16 hue;
+        quint8  saturation;
+        quint8  value;
+    };
+
+    // returns the active color table.  if none has been set specifically,
+    // this is the default color table.
+    const ColorEntry* colorTable() const;
+
+#if 0
+// implemented upstream - user apps
+    // reads a single colour entry from a KConfig source
+    // and sets the palette entry at 'index' to the entry read.
+    void readColorEntry(KConfig& config , int index); 
+    // writes a single colour entry to a KConfig source
+    void writeColorEntry(KConfig& config , const QString& colorName, const ColorEntry& entry,const RandomizationRange& range) const;
+#endif
+    void readColorEntry(QSettings *s, int index);
+
+    // sets the amount of randomization allowed for a particular color 
+    // in the palette.  creates the randomization table if 
+    // it does not already exist
+    void setRandomizationRange( int index , quint16 hue , quint8 saturation , quint8 value );
+
+    QString _description;
+    QString _name;
+    qreal _opacity;
+    ColorEntry* _table; // pointer to custom color table or 0 if the default
+                        // color scheme is being used
+
+
+    static const quint16 MAX_HUE = 340;
+
+    RandomizationRange* _randomTable;   // pointer to randomization table or 0
+                                        // if no colors in the color scheme support
+                                        // randomization
+
+    static const char* const colorNames[TABLE_COLORS];
+    static const char* const translatedColorNames[TABLE_COLORS];
+
+    static const ColorEntry defaultTable[]; // table of default color entries
+};
+
+/** 
+ * A color scheme which uses colors from the standard KDE color palette.
+ *
+ * This is designed primarily for the benefit of users who are using specially
+ * designed colors.
+ *
+ * TODO Implement and make it the default on systems with specialized KDE
+ * color schemes.
+ */
+class AccessibleColorScheme : public ColorScheme
+{
+public:
+    AccessibleColorScheme();
+};
+
+/**
+ * Reads a color scheme stored in the .schema format used in the KDE 3 incarnation
+ * of Konsole
+ *
+ * Only the basic essentials ( title and color palette entries ) are currently
+ * supported.  Additional options such as background image and background
+ * blend colors are ignored.
+ */
+class KDE3ColorSchemeReader
+{
+public:
+    /** 
+     * Constructs a new reader which reads from the specified device. 
+     * The device should be open in read-only mode. 
+     */
+    KDE3ColorSchemeReader( QIODevice* device );
+
+    /** 
+     * Reads and parses the contents of the .schema file from the input
+     * device and returns the ColorScheme defined within it.
+     *
+     * Returns a null pointer if an error occurs whilst parsing
+     * the contents of the file.
+     */
+    ColorScheme* read();
+
+private:
+    // reads a line from the file specifying a colour palette entry
+    // format is: color [index] [red] [green] [blue] [transparent] [bold]
+    bool readColorLine(const QString& line , ColorScheme* scheme);
+    bool readTitleLine(const QString& line , ColorScheme* scheme);
+
+    QIODevice* _device;
+};
+
+/**
+ * Manages the color schemes available for use by terminal displays.
+ * See ColorScheme
+ */
+class ColorSchemeManager
+{
+public:
+
+    /**
+     * Constructs a new ColorSchemeManager and loads the list
+     * of available color schemes.
+     *
+     * The color schemes themselves are not loaded until they are first
+     * requested via a call to findColorScheme()
+     */
+    ColorSchemeManager();
+    /**
+     * Destroys the ColorSchemeManager and saves any modified color schemes to disk.
+     */
+    ~ColorSchemeManager();
+
+    /**
+     * Returns the default color scheme for Konsole
+     */
+    const ColorScheme* defaultColorScheme() const;
+ 
+    /**
+     * Returns the color scheme with the given name or 0 if no
+     * scheme with that name exists.  If @p name is empty, the
+     * default color scheme is returned.
+     *
+     * The first time that a color scheme with a particular name is
+     * requested, the configuration information is loaded from disk.
+     */
+    const ColorScheme* findColorScheme(const QString& name);
+
+#if 0
+    /**
+     * Adds a new color scheme to the manager.  If @p scheme has the same name as
+     * an existing color scheme, it replaces the existing scheme.
+     *
+     * TODO - Ensure the old color scheme gets deleted
+     */
+    void addColorScheme(ColorScheme* scheme);
+#endif
+    /**
+     * Deletes a color scheme.  Returns true on successful deletion or false otherwise. 
+     */
+    bool deleteColorScheme(const QString& name);
+
+    /** 
+     * Returns a list of the all the available color schemes. 
+     * This may be slow when first called because all of the color
+     * scheme resources on disk must be located, read and parsed.
+     *
+     * Subsequent calls will be inexpensive. 
+     */
+    QList<const ColorScheme*> allColorSchemes();    
+
+    /** Returns the global color scheme manager instance. */
+    static ColorSchemeManager* instance();
+
+private:
+    // loads a color scheme from a KDE 4+ .colorscheme file
+    bool loadColorScheme(const QString& path);
+    // loads a color scheme from a KDE 3 .schema file
+    bool loadKDE3ColorScheme(const QString& path);
+    // returns a list of paths of color schemes in the KDE 4+ .colorscheme file format
+    QList<QString> listColorSchemes();
+    // returns a list of paths of color schemes in the .schema file format
+    // used in KDE 3
+    QList<QString> listKDE3ColorSchemes();
+    // loads all of the color schemes
+    void loadAllColorSchemes();
+    // finds the path of a color scheme
+    QString findColorSchemePath(const QString& name) const;
+
+    QHash<QString,const ColorScheme*> _colorSchemes;
+    QSet<ColorScheme*> _modifiedSchemes;
+
+    bool _haveLoadedAll;
+
+    static const ColorScheme _defaultColorScheme;
+
+    static ColorSchemeManager * theColorSchemeManager;
+};
+
+Q_DECLARE_METATYPE(const ColorScheme*)
+
+#endif //COLORSCHEME_H

=== added file 'src/plugin/konsole/ColorTables.h'
--- src/plugin/konsole/ColorTables.h	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/ColorTables.h	2014-05-06 21:50:22 +0000
@@ -0,0 +1,55 @@
+#ifndef _COLOR_TABLE_H
+#define _COLOR_TABLE_H
+
+#include "CharacterColor.h"
+
+//using namespace Konsole;
+#if 0
+static const ColorEntry whiteonblack_color_table[TABLE_COLORS] = {
+    // normal
+    ColorEntry(QColor(0xFF,0xFF,0xFF), false ), ColorEntry( QColor(0x00,0x00,0x00), true ), // Dfore, Dback
+    ColorEntry(QColor(0x00,0x00,0x00), false ), ColorEntry( QColor(0xB2,0x18,0x18), false ), // Black, Red
+    ColorEntry(QColor(0x18,0xB2,0x18), false ), ColorEntry( QColor(0xB2,0x68,0x18), false ), // Green, Yellow
+    ColorEntry(QColor(0x18,0x18,0xB2), false ), ColorEntry( QColor(0xB2,0x18,0xB2), false ), // Blue, Magenta
+    ColorEntry(QColor(0x18,0xB2,0xB2), false ), ColorEntry( QColor(0xB2,0xB2,0xB2), false ), // Cyan, White
+    // intensiv
+    ColorEntry(QColor(0x00,0x00,0x00), false ), ColorEntry( QColor(0xFF,0xFF,0xFF), true ),
+    ColorEntry(QColor(0x68,0x68,0x68), false ), ColorEntry( QColor(0xFF,0x54,0x54), false ),
+    ColorEntry(QColor(0x54,0xFF,0x54), false ), ColorEntry( QColor(0xFF,0xFF,0x54), false ),
+    ColorEntry(QColor(0x54,0x54,0xFF), false ), ColorEntry( QColor(0xFF,0x54,0xFF), false ),
+    ColorEntry(QColor(0x54,0xFF,0xFF), false ), ColorEntry( QColor(0xFF,0xFF,0xFF), false )
+};
+
+static const ColorEntry greenonblack_color_table[TABLE_COLORS] = {
+    ColorEntry(QColor(    24, 240,  24),  false), ColorEntry(QColor(     0,   0,   0),  true),
+    ColorEntry(QColor(     0,   0,   0),  false), ColorEntry(QColor(   178,  24,  24),  false),
+    ColorEntry(QColor(    24, 178,  24),  false), ColorEntry(QColor(   178, 104,  24),  false),
+    ColorEntry(QColor(    24,  24, 178),  false), ColorEntry(QColor(   178,  24, 178),  false),
+    ColorEntry(QColor(    24, 178, 178),  false), ColorEntry(QColor(   178, 178, 178),  false),
+    // intensive colors
+    ColorEntry(QColor(   24, 240,  24),  false ), ColorEntry(QColor(    0,   0,   0),  true ),
+    ColorEntry(QColor(  104, 104, 104),  false ), ColorEntry(QColor(  255,  84,  84),  false ),
+    ColorEntry(QColor(   84, 255,  84),  false ), ColorEntry(QColor(  255, 255,  84),  false ),
+    ColorEntry(QColor(   84,  84, 255),  false ), ColorEntry(QColor(  255,  84, 255),  false ),
+    ColorEntry(QColor(   84, 255, 255),  false ), ColorEntry(QColor(  255, 255, 255),  false )
+};
+
+static const ColorEntry blackonlightyellow_color_table[TABLE_COLORS] = {
+    ColorEntry(QColor(  0,   0,   0),  false),  ColorEntry(QColor( 255, 255, 221),  true),
+    ColorEntry(QColor(  0,   0,   0),  false),  ColorEntry(QColor( 178,  24,  24),  false),
+    ColorEntry(QColor( 24, 178,  24),  false),  ColorEntry(QColor( 178, 104,  24),  false),
+    ColorEntry(QColor( 24,  24, 178),  false),  ColorEntry(QColor( 178,  24, 178),  false),
+    ColorEntry(QColor( 24, 178, 178),  false),  ColorEntry(QColor( 178, 178, 178),  false),
+    ColorEntry(QColor(  0,   0,   0),  false),  ColorEntry(QColor( 255, 255, 221),  true),
+    ColorEntry(QColor(104, 104, 104),  false),  ColorEntry(QColor( 255,  84,  84),  false),
+    ColorEntry(QColor( 84, 255,  84),  false),  ColorEntry(QColor( 255, 255,  84),  false),
+    ColorEntry(QColor( 84,  84, 255),  false),  ColorEntry(QColor( 255,  84, 255),  false),
+    ColorEntry(QColor( 84, 255, 255),  false),  ColorEntry(QColor( 255, 255, 255),  false)
+};
+
+
+#endif
+
+
+#endif
+

=== added file 'src/plugin/konsole/DefaultTranslatorText.h'
--- src/plugin/konsole/DefaultTranslatorText.h	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/DefaultTranslatorText.h	2014-05-06 21:50:22 +0000
@@ -0,0 +1,2 @@
+"keyboard \"Fallback Key Translator\"\n"
+"key Tab : \"\\t\" \0"

=== added file 'src/plugin/konsole/Emulation.cpp'
--- src/plugin/konsole/Emulation.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/Emulation.cpp	2014-05-06 21:50:22 +0000
@@ -0,0 +1,458 @@
+/*
+    Copyright 2007-2008 Robert Knight <[e-mail]> 
+    Copyright 1997,1998 by Lars Doelle <[e-mail]>
+    Copyright 1996 by Matthias Ettrich <[e-mail]>
+
+    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 "Emulation.h"
+
+// System
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+// Qt
+#include <QGuiApplication>
+#include <QtGui/QClipboard>
+#include <QtCore/QHash>
+#include <QtGui/QKeyEvent>
+#include <QtCore/QRegExp>
+#include <QtCore/QTextStream>
+#include <QtCore/QThread>
+
+#include <QtCore/QTime>
+
+// KDE
+//#include <kdebug.h>
+
+// Konsole
+#include "KeyboardTranslator.h"
+#include "Screen.h"
+#include "TerminalCharacterDecoder.h"
+#include "ScreenWindow.h"
+
+Emulation::Emulation() :
+  _currentScreen(0),
+  _codec(0),
+  _decoder(0),
+  _keyTranslator(0),
+  _usesMouse(false)
+{
+  // create screens with a default size
+  _screen[0] = new Screen(40,80);
+  _screen[1] = new Screen(40,80);
+  _currentScreen = _screen[0];
+
+  QObject::connect(&_bulkTimer1, SIGNAL(timeout()), this, SLOT(showBulk()) );
+  QObject::connect(&_bulkTimer2, SIGNAL(timeout()), this, SLOT(showBulk()) );
+   
+  // listen for mouse status changes
+  connect( this , SIGNAL(programUsesMouseChanged(bool)) , 
+           SLOT(usesMouseChanged(bool)) );
+}
+
+bool Emulation::programUsesMouse() const
+{
+    return _usesMouse;
+}
+
+void Emulation::usesMouseChanged(bool usesMouse)
+{
+    _usesMouse = usesMouse;
+}
+
+ScreenWindow* Emulation::createWindow()
+{
+    ScreenWindow* window = new ScreenWindow();
+    window->setScreen(_currentScreen);
+    _windows << window;
+
+    connect(window , SIGNAL(selectionChanged()),
+            this , SLOT(bufferedUpdate()));
+
+    connect(this , SIGNAL(outputChanged()),
+            window , SLOT(notifyOutputChanged()) );
+    return window;
+}
+
+Emulation::~Emulation()
+{
+  QListIterator<ScreenWindow*> windowIter(_windows);
+
+  while (windowIter.hasNext())
+  {
+    delete windowIter.next();
+  }
+
+  delete _screen[0];
+  delete _screen[1];
+  delete _decoder;
+}
+
+void Emulation::setScreen(int n)
+{
+  Screen *old = _currentScreen;
+  _currentScreen = _screen[n & 1];
+  if (_currentScreen != old) 
+  {
+     // tell all windows onto this emulation to switch to the newly active screen
+     foreach(ScreenWindow* window,_windows)
+         window->setScreen(_currentScreen);
+  }
+}
+
+void Emulation::clearHistory()
+{
+    _screen[0]->setScroll( _screen[0]->getScroll() , false );
+}
+void Emulation::setHistory(const HistoryType& t)
+{
+  _screen[0]->setScroll(t);
+
+  showBulk();
+}
+
+const HistoryType& Emulation::history() const
+{
+  return _screen[0]->getScroll();
+}
+
+void Emulation::setCodec(const QTextCodec * qtc)
+{
+  if (qtc)
+      _codec = qtc;
+  else
+     setCodec(LocaleCodec);
+
+  delete _decoder;
+  _decoder = _codec->makeDecoder();
+
+  emit useUtf8Request(utf8());
+}
+
+void Emulation::setCodec(EmulationCodec codec)
+{
+    if ( codec == Utf8Codec )
+        setCodec( QTextCodec::codecForName("utf8") );
+    else if ( codec == LocaleCodec )
+        setCodec( QTextCodec::codecForLocale() );
+}
+
+void Emulation::setKeyBindings(const QString& name)
+{
+  _keyTranslator = KeyboardTranslatorManager::instance()->findTranslator(name);
+  if (!_keyTranslator)
+  {
+      _keyTranslator = KeyboardTranslatorManager::instance()->defaultTranslator();
+  }
+}
+
+QString Emulation::keyBindings() const
+{
+  return _keyTranslator->name();
+}
+
+void Emulation::receiveChar(int c)
+// process application unicode input to terminal
+// this is a trivial scanner
+{
+  c &= 0xff;
+  switch (c)
+  {
+    case '\b'      : _currentScreen->backspace();                 break;
+    case '\t'      : _currentScreen->tab();                       break;
+    case '\n'      : _currentScreen->newLine();                   break;
+    case '\r'      : _currentScreen->toStartOfLine();             break;
+    case 0x07      : emit stateSet(NOTIFYBELL);
+                     break;
+    default        : _currentScreen->displayCharacter(c);         break;
+  };
+}
+
+void Emulation::sendKeyEvent( QKeyEvent* ev )
+{
+  emit stateSet(NOTIFYNORMAL);
+  
+  if (!ev->text().isEmpty())
+  { // A block of text
+    // Note that the text is proper unicode.
+    // We should do a conversion here
+    emit sendData(ev->text().toUtf8(),ev->text().length());
+  }
+}
+
+void Emulation::sendString(const char*,int)
+{
+    // default implementation does nothing
+}
+
+void Emulation::sendMouseEvent(int /*buttons*/, int /*column*/, int /*row*/, int /*eventType*/)
+{
+    // default implementation does nothing
+}
+
+/*
+   We are doing code conversion from locale to unicode first.
+TODO: Character composition from the old code.  See #96536
+*/
+
+void Emulation::receiveData(const char* text, int length)
+{
+    emit stateSet(NOTIFYACTIVITY);
+
+    bufferedUpdate();
+        
+    QString unicodeText = _decoder->toUnicode(text,length);
+
+    //send characters to terminal emulator
+    for (int i=0;i<unicodeText.length();i++)
+        receiveChar(unicodeText[i].unicode());
+
+    //look for z-modem indicator
+    //-- someone who understands more about z-modems that I do may be able to move
+    //this check into the above for loop?
+    for (int i=0;i<length;i++)
+    {
+        if (text[i] == '\030')
+        {
+            if ((length-i-1 > 3) && (strncmp(text+i+1, "B00", 3) == 0))
+                emit zmodemDetected();
+        }
+    }
+}
+
+//OLDER VERSION
+//This version of onRcvBlock was commented out because
+//    a)  It decoded incoming characters one-by-one, which is slow in the current version of Qt (4.2 tech preview)
+//    b)  It messed up decoding of non-ASCII characters, with the result that (for example) chinese characters
+//        were not printed properly.
+//
+//There is something about stopping the _decoder if "we get a control code halfway a multi-byte sequence" (see below)
+//which hasn't been ported into the newer function (above).  Hopefully someone who understands this better
+//can find an alternative way of handling the check.  
+
+
+/*void Emulation::onRcvBlock(const char *s, int len)
+{
+  emit notifySessionState(NOTIFYACTIVITY);
+  
+  bufferedUpdate();
+  for (int i = 0; i < len; i++)
+  {
+
+    QString result = _decoder->toUnicode(&s[i],1);
+    int reslen = result.length();
+
+    // If we get a control code halfway a multi-byte sequence
+    // we flush the _decoder and continue with the control code.
+    if ((s[i] < 32) && (s[i] > 0))
+    {
+       // Flush _decoder
+       while(!result.length())
+          result = _decoder->toUnicode(&s[i],1);
+       reslen = 1;
+       result.resize(reslen);
+       result[0] = QChar(s[i]);
+    }
+
+    for (int j = 0; j < reslen; j++)
+    {
+      if (result[j].characterategory() == QChar::Mark_NonSpacing)
+         _currentScreen->compose(result.mid(j,1));
+      else
+         onRcvChar(result[j].unicode());
+    }
+    if (s[i] == '\030')
+    {
+      if ((len-i-1 > 3) && (strncmp(s+i+1, "B00", 3) == 0))
+          emit zmodemDetected();
+    }
+  }
+}*/
+
+void Emulation::writeToStream( TerminalCharacterDecoder* _decoder , 
+                               int startLine ,
+                               int endLine) 
+{
+  _currentScreen->writeLinesToStream(_decoder,startLine,endLine);
+}
+
+int Emulation::lineCount() const
+{
+    // sum number of lines currently on _screen plus number of lines in history
+    return _currentScreen->getLines() + _currentScreen->getHistLines();
+}
+
+#define BULK_TIMEOUT1 10
+#define BULK_TIMEOUT2 40
+
+void Emulation::showBulk()
+{
+    _bulkTimer1.stop();
+    _bulkTimer2.stop();
+
+    emit outputChanged();
+
+    _currentScreen->resetScrolledLines();
+    _currentScreen->resetDroppedLines();
+}
+
+void Emulation::bufferedUpdate()
+{
+   _bulkTimer1.setSingleShot(true);
+   _bulkTimer1.start(BULK_TIMEOUT1);
+   if (!_bulkTimer2.isActive())
+   {
+      _bulkTimer2.setSingleShot(true);
+      _bulkTimer2.start(BULK_TIMEOUT2);
+   }
+}
+
+char Emulation::eraseChar() const
+{
+  return '\b';
+}
+
+void Emulation::setImageSize(int lines, int columns)
+{
+  if ((lines < 1) || (columns < 1)) 
+    return;
+
+  QSize screenSize[2] = { QSize(_screen[0]->getColumns(),
+                                _screen[0]->getLines()),
+                          QSize(_screen[1]->getColumns(),
+                                _screen[1]->getLines()) };
+  QSize newSize(columns,lines);
+
+  if (newSize == screenSize[0] && newSize == screenSize[1])
+    return;    
+
+  _screen[0]->resizeImage(lines,columns);
+  _screen[1]->resizeImage(lines,columns);
+
+  emit imageSizeChanged(lines,columns);
+
+  bufferedUpdate();
+}
+
+QSize Emulation::imageSize() const
+{
+  return QSize(_currentScreen->getColumns(), _currentScreen->getLines());
+}
+
+ushort ExtendedCharTable::extendedCharHash(ushort* unicodePoints , ushort length) const
+{
+    ushort hash = 0;
+    for ( ushort i = 0 ; i < length ; i++ )
+    {
+        hash = 31*hash + unicodePoints[i];
+    }
+    return hash;
+}
+bool ExtendedCharTable::extendedCharMatch(ushort hash , ushort* unicodePoints , ushort length) const
+{
+    ushort* entry = extendedCharTable[hash];
+
+    // compare given length with stored sequence length ( given as the first ushort in the 
+    // stored buffer ) 
+    if ( entry == 0 || entry[0] != length ) 
+       return false;
+    // if the lengths match, each character must be checked.  the stored buffer starts at
+    // entry[1]
+    for ( int i = 0 ; i < length ; i++ )
+    {
+        if ( entry[i+1] != unicodePoints[i] )
+           return false; 
+    } 
+    return true;
+}
+ushort ExtendedCharTable::createExtendedChar(ushort* unicodePoints , ushort length)
+{
+    // look for this sequence of points in the table
+    ushort hash = extendedCharHash(unicodePoints,length);
+
+    // check existing entry for match
+    while ( extendedCharTable.contains(hash) )
+    {
+        if ( extendedCharMatch(hash,unicodePoints,length) )
+        {
+            // this sequence already has an entry in the table, 
+            // return its hash
+            return hash;
+        }
+        else
+        {
+            // if hash is already used by another, different sequence of unicode character
+            // points then try next hash
+            hash++;
+        }
+    }    
+
+    
+     // add the new sequence to the table and
+     // return that index
+    ushort* buffer = new ushort[length+1];
+    buffer[0] = length;
+    for ( int i = 0 ; i < length ; i++ )
+       buffer[i+1] = unicodePoints[i]; 
+    
+    extendedCharTable.insert(hash,buffer);
+
+    return hash;
+}
+
+ushort* ExtendedCharTable::lookupExtendedChar(ushort hash , ushort& length) const
+{
+    // lookup index in table and if found, set the length
+    // argument and return a pointer to the character sequence
+
+    ushort* buffer = extendedCharTable[hash];
+    if ( buffer )
+    {
+        length = buffer[0];
+        return buffer+1;
+    }
+    else
+    {
+        length = 0;
+        return 0;
+    }
+}
+
+ExtendedCharTable::ExtendedCharTable()
+{
+}
+ExtendedCharTable::~ExtendedCharTable()
+{
+    // free all allocated character buffers
+    QHashIterator<ushort,ushort*> iter(extendedCharTable);
+    while ( iter.hasNext() )
+    {
+        iter.next();
+        delete[] iter.value();
+    }
+}
+
+// global instance
+ExtendedCharTable ExtendedCharTable::instance;
+
+
+//#include "Emulation.moc"
+

=== added file 'src/plugin/konsole/Emulation.h'
--- src/plugin/konsole/Emulation.h	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/Emulation.h	2014-05-06 21:50:22 +0000
@@ -0,0 +1,467 @@
+/*
+    This file is part of Konsole, an X terminal.
+    
+    Copyright 2007-2008 by Robert Knight <[e-mail]>
+    Copyright 1997,1998 by Lars Doelle <[e-mail]>
+
+    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 EMULATION_H
+#define EMULATION_H
+
+// System
+#include <stdio.h>
+
+// Qt 
+#include <QtGui/QKeyEvent>
+//#include <QPointer>
+#include <QtCore/QTextCodec>
+#include <QtCore/QTextStream>
+#include <QtCore/QTimer>
+
+// Konsole
+//#include "konsole_export.h"
+#define KONSOLEPRIVATE_EXPORT
+
+class KeyboardTranslator;
+class HistoryType;
+class Screen;
+class ScreenWindow;
+class TerminalCharacterDecoder;
+
+/** 
+ * This enum describes the available states which 
+ * the terminal emulation may be set to.
+ *
+ * These are the values used by Emulation::stateChanged() 
+ */
+enum 
+{ 
+    /** The emulation is currently receiving user input. */
+    NOTIFYNORMAL=0, 
+    /** 
+     * The terminal program has triggered a bell event
+     * to get the user's attention.
+     */
+    NOTIFYBELL=1, 
+    /** 
+     * The emulation is currently receiving data from its 
+     * terminal input.
+     */
+    NOTIFYACTIVITY=2,
+
+    // unused here? 
+    NOTIFYSILENCE=3 
+};
+
+/**
+ * Base class for terminal emulation back-ends.
+ *
+ * The back-end is responsible for decoding an incoming character stream and 
+ * producing an output image of characters.
+ *
+ * When input from the terminal is received, the receiveData() slot should be called with
+ * the data which has arrived.  The emulation will process the data and update the 
+ * screen image accordingly.  The codec used to decode the incoming character stream
+ * into the unicode characters used internally can be specified using setCodec() 
+ *
+ * The size of the screen image can be specified by calling setImageSize() with the 
+ * desired number of lines and columns.  When new lines are added, old content
+ * is moved into a history store, which can be set by calling setHistory(). 
+ *
+ * The screen image can be accessed by creating a ScreenWindow onto this emulation 
+ * by calling createWindow().  Screen windows provide access to a section of the 
+ * output.  Each screen window covers the same number of lines and columns as the 
+ * image size returned by imageSize().  The screen window can be moved up and down
+ * and provides transparent access to both the current on-screen image and the 
+ * previous output.  The screen windows emit an outputChanged signal
+ * when the section of the image they are looking at changes.
+ * Graphical views can then render the contents of a screen window, listening for notifications
+ * of output changes from the screen window which they are associated with and updating 
+ * accordingly. 
+ *
+ * The emulation also is also responsible for converting input from the connected views such
+ * as keypresses and mouse activity into a character string which can be sent
+ * to the terminal program.  Key presses can be processed by calling the sendKeyEvent() slot,
+ * while mouse events can be processed using the sendMouseEvent() slot.  When the character
+ * stream has been produced, the emulation will emit a sendData() signal with a pointer
+ * to the character buffer.  This data should be fed to the standard input of the terminal
+ * process.  The translation of key presses into an output character stream is performed
+ * using a lookup in a set of key bindings which map key sequences to output
+ * character sequences.  The name of the key bindings set used can be specified using
+ * setKeyBindings()
+ *
+ * The emulation maintains certain state information which changes depending on the 
+ * input received.  The emulation can be reset back to its starting state by calling 
+ * reset().  
+ *
+ * The emulation also maintains an activity state, which specifies whether
+ * terminal is currently active ( when data is received ), normal
+ * ( when the terminal is idle or receiving user input ) or trying
+ * to alert the user ( also known as a "Bell" event ).  The stateSet() signal
+ * is emitted whenever the activity state is set.  This can be used to determine
+ * how long the emulation has been active/idle for and also respond to
+ * a 'bell' event in different ways.
+ */
+class KONSOLEPRIVATE_EXPORT Emulation : public QObject
+{ 
+Q_OBJECT
+
+public:
+ 
+   /** Constructs a new terminal emulation */ 
+   Emulation();
+  ~Emulation();
+
+  /**
+   * Creates a new window onto the output from this emulation.  The contents
+   * of the window are then rendered by views which are set to use this window using the
+   * TerminalDisplay::setScreenWindow() method.
+   */
+  ScreenWindow* createWindow();
+
+  /** Returns the size of the screen image which the emulation produces */
+  QSize imageSize() const;
+
+  /**
+   * Returns the total number of lines, including those stored in the history.
+   */ 
+  int lineCount() const;
+
+  /** 
+   * Sets the history store used by this emulation.  When new lines
+   * are added to the output, older lines at the top of the screen are transferred to a history
+   * store.   
+   *
+   * The number of lines which are kept and the storage location depend on the 
+   * type of store.
+   */
+  void setHistory(const HistoryType&);
+  /** Returns the history store used by this emulation.  See setHistory() */
+  const HistoryType& history() const;
+  /** Clears the history scroll. */
+  void clearHistory();
+
+  /** 
+   * Copies the output history from @p startLine to @p endLine 
+   * into @p stream, using @p decoder to convert the terminal
+   * characters into text. 
+   *
+   * @param decoder A decoder which converts lines of terminal characters with 
+   * appearance attributes into output text.  PlainTextDecoder is the most commonly
+   * used decoder.
+   * @param startLine Index of first line to copy
+   * @param endLine Index of last line to copy
+   */
+  virtual void writeToStream(TerminalCharacterDecoder* decoder,int startLine,int endLine);
+  
+  /** Returns the codec used to decode incoming characters.  See setCodec() */
+  const QTextCodec* codec() const { return _codec; }
+  /** Sets the codec used to decode incoming characters.  */
+  void setCodec(const QTextCodec*);
+
+  /** 
+   * Convenience method.  
+   * Returns true if the current codec used to decode incoming
+   * characters is UTF-8
+   */
+  bool utf8() const
+  { Q_ASSERT(_codec); return _codec->mibEnum() == 106; }
+  
+
+  /** TODO Document me */
+  virtual char eraseChar() const;
+
+  /** 
+   * Sets the key bindings used to key events
+   * ( received through sendKeyEvent() ) into character
+   * streams to send to the terminal.
+   */
+  void setKeyBindings(const QString& name);
+  /** 
+   * Returns the name of the emulation's current key bindings.
+   * See setKeyBindings()
+   */
+  QString keyBindings() const;
+
+  /** 
+   * Copies the current image into the history and clears the screen.
+   */
+  virtual void clearEntireScreen() =0;
+
+  /** Resets the state of the terminal. */
+  virtual void reset() =0;
+
+  /** 
+   * Returns true if the active terminal program wants
+   * mouse input events.
+   *
+   * The programUsesMouseChanged() signal is emitted when this
+   * changes.
+   */
+  bool programUsesMouse() const;
+
+public slots: 
+
+  /** Change the size of the emulation's image */
+  virtual void setImageSize(int lines, int columns);
+  
+  /** 
+   * Interprets a sequence of characters and sends the result to the terminal.
+   * This is equivalent to calling sendKeyEvent() for each character in @p text in succession.
+   */
+  virtual void sendText(const QString& text) = 0;
+
+  /** 
+   * Interprets a key press event and emits the sendData() signal with
+   * the resulting character stream. 
+   */
+  virtual void sendKeyEvent(QKeyEvent*);
+ 
+  /** 
+   * Converts information about a mouse event into an xterm-compatible escape
+   * sequence and emits the character sequence via sendData()
+   */
+  virtual void sendMouseEvent(int buttons, int column, int line, int eventType);
+  
+  /**
+   * Sends a string of characters to the foreground terminal process. 
+   *
+   * @param string The characters to send.  
+   * @param length Length of @p string or if set to a negative value, @p string will
+   * be treated as a null-terminated string and its length will be determined automatically.
+   */
+  virtual void sendString(const char* string, int length = -1) = 0;
+
+  /** 
+   * Processes an incoming stream of characters.  receiveData() decodes the incoming
+   * character buffer using the current codec(), and then calls receiveChar() for
+   * each unicode character in the resulting buffer.  
+   *
+   * receiveData() also starts a timer which causes the outputChanged() signal
+   * to be emitted when it expires.  The timer allows multiple updates in quick
+   * succession to be buffered into a single outputChanged() signal emission.
+   *
+   * @param buffer A string of characters received from the terminal program.
+   * @param len The length of @p buffer
+   */
+  void receiveData(const char* buffer,int len);
+
+signals:
+
+  /** 
+   * Emitted when a buffer of data is ready to send to the 
+   * standard input of the terminal.
+   *
+   * @param data The buffer of data ready to be sent
+   * @param len The length of @p data in bytes
+   */
+  void sendData(const char* data,int len);
+
+  /** 
+   * Requests that sending of input to the emulation
+   * from the terminal process be suspended or resumed.
+   *
+   * @param suspend If true, requests that sending of 
+   * input from the terminal process' stdout be 
+   * suspended.  Otherwise requests that sending of
+   * input be resumed. 
+   */
+  void lockPtyRequest(bool suspend);
+
+  /**
+   * Requests that the pty used by the terminal process
+   * be set to UTF 8 mode.  
+   *
+   * TODO: More documentation
+   */
+  void useUtf8Request(bool);
+
+  /**
+   * Emitted when the activity state of the emulation is set.
+   *
+   * @param state The new activity state, one of NOTIFYNORMAL, NOTIFYACTIVITY
+   * or NOTIFYBELL
+   */
+  void stateSet(int state);
+
+  /** TODO Document me */
+  void zmodemDetected();
+
+
+  /**
+   * Requests that the color of the text used
+   * to represent the tabs associated with this
+   * emulation be changed.  This is a Konsole-specific
+   * extension from pre-KDE 4 times.
+   *
+   * TODO: Document how the parameter works.
+   */
+  void changeTabTextColorRequest(int color);
+
+  /** 
+   * This is emitted when the program running in the shell indicates whether or
+   * not it is interested in mouse events.
+   *
+   * @param usesMouse This will be true if the program wants to be informed about
+   * mouse events or false otherwise.
+   */
+  void programUsesMouseChanged(bool usesMouse);
+
+  /** 
+   * Emitted when the contents of the screen image change.
+   * The emulation buffers the updates from successive image changes,
+   * and only emits outputChanged() at sensible intervals when
+   * there is a lot of terminal activity.
+   *
+   * Normally there is no need for objects other than the screen windows
+   * created with createWindow() to listen for this signal.
+   *
+   * ScreenWindow objects created using createWindow() will emit their
+   * own outputChanged() signal in response to this signal. 
+   */
+  void outputChanged();
+
+  /**
+   * Emitted when the program running in the terminal wishes to update the 
+   * session's title.  This also allows terminal programs to customize other
+   * aspects of the terminal emulation display. 
+   *
+   * This signal is emitted when the escape sequence "\033]ARG;VALUE\007"
+   * is received in the input string, where ARG is a number specifying what
+   * should change and VALUE is a string specifying the new value.
+   *
+   * TODO:  The name of this method is not very accurate since this method
+   * is used to perform a whole range of tasks besides just setting
+   * the user-title of the session.    
+   *
+   * @param title Specifies what to change.
+   * <ul>
+   * <li>0 - Set window icon text and session title to @p newTitle</li>
+   * <li>1 - Set window icon text to @p newTitle</li>
+   * <li>2 - Set session title to @p newTitle</li>
+   * <li>11 - Set the session's default background color to @p newTitle,
+   *         where @p newTitle can be an HTML-style string ("#RRGGBB") or a named
+   *         color (eg 'red', 'blue').  
+   *         See http://doc.trolltech.com/4.2/qcolor.html#setNamedColor for more
+   *         details.
+   * </li>
+   * <li>31 - Supposedly treats @p newTitle as a URL and opens it (NOT IMPLEMENTED)</li>
+   * <li>32 - Sets the icon associated with the session.  @p newTitle is the name 
+   *    of the icon to use, which can be the name of any icon in the current KDE icon
+   *    theme (eg: 'konsole', 'kate', 'folder_home')</li>
+   * </ul>
+   * @param newTitle Specifies the new title 
+   */
+
+  void titleChanged(int title,const QString& newTitle);
+
+  /**
+   * Emitted when the program running in the terminal changes the
+   * screen size.
+   */
+  void imageSizeChanged(int lineCount , int columnCount);
+
+  /** 
+   * Emitted when the terminal program requests to change various properties
+   * of the terminal display.  
+   *
+   * A profile change command occurs when a special escape sequence, followed
+   * by a string containing a series of name and value pairs is received.
+   * This string can be parsed using a ProfileCommandParser instance.
+   *
+   * @param text A string expected to contain a series of key and value pairs in
+   * the form:  name=value;name2=value2 ...
+   */
+  void profileChangeCommandReceived(const QString& text);
+
+  /** 
+   * Emitted when a flow control key combination ( Ctrl+S or Ctrl+Q ) is pressed.
+   * @param suspendKeyPressed True if Ctrl+S was pressed to suspend output or Ctrl+Q to
+   * resume output.
+   */
+  void flowControlKeyPressed(bool suspendKeyPressed);
+
+protected:
+  virtual void setMode(int mode) = 0;
+  virtual void resetMode(int mode) = 0;
+   
+  /** 
+   * Processes an incoming character.  See receiveData()
+   * @p ch A unicode character code. 
+   */
+  virtual void receiveChar(int ch);
+
+  /** 
+   * Sets the active screen.  The terminal has two screens, primary and alternate.
+   * The primary screen is used by default.  When certain interactive programs such
+   * as Vim are run, they trigger a switch to the alternate screen.
+   *
+   * @param index 0 to switch to the primary screen, or 1 to switch to the alternate screen
+   */
+  void setScreen(int index); 
+
+  enum EmulationCodec
+  {
+      LocaleCodec = 0,
+      Utf8Codec   = 1
+  };
+  void setCodec(EmulationCodec codec); // codec number, 0 = locale, 1=utf8
+
+
+  QList<ScreenWindow*> _windows;
+  
+  Screen* _currentScreen;  // pointer to the screen which is currently active, 
+                            // this is one of the elements in the screen[] array
+
+  Screen* _screen[2];      // 0 = primary screen ( used by most programs, including the shell
+                            //                      scrollbars are enabled in this mode )
+                            // 1 = alternate      ( used by vi , emacs etc.
+                            //                      scrollbars are not enabled in this mode )
+                            
+  
+  //decodes an incoming C-style character stream into a unicode QString using 
+  //the current text codec.  (this allows for rendering of non-ASCII characters in text files etc.)
+  const QTextCodec* _codec;
+  QTextDecoder* _decoder;
+  const KeyboardTranslator* _keyTranslator; // the keyboard layout
+
+protected slots:
+  /** 
+   * Schedules an update of attached views.
+   * Repeated calls to bufferedUpdate() in close succession will result in only a single update,
+   * much like the Qt buffered update of widgets. 
+   */
+  void bufferedUpdate();
+
+private slots: 
+
+  // triggered by timer, causes the emulation to send an updated screen image to each
+  // view
+  void showBulk(); 
+
+  void usesMouseChanged(bool usesMouse);
+
+private:
+  bool _usesMouse;
+  QTimer _bulkTimer1;
+  QTimer _bulkTimer2;
+  
+};
+
+
+#endif // ifndef EMULATION_H

=== added file 'src/plugin/konsole/ExtendedDefaultTranslator.h'
--- src/plugin/konsole/ExtendedDefaultTranslator.h	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/ExtendedDefaultTranslator.h	2014-05-06 21:50:22 +0000
@@ -0,0 +1,74 @@
+"keyboard \"Default (XFree 4)\""
+"key Escape             : \"\\E\""
+"key Tab   -Shift       : \"\\t\"\n"
+"key Tab   +Shift+Ansi  : \"\\E[Z\"\n"
+"key Tab   +Shift-Ansi  : \"\\t\"\n"
+"key Backtab     +Ansi  : \"\\E[Z\"\n"
+"key Backtab     -Ansi  : \"\\t\"\n"
+"key Return-Shift-NewLine : \"\\r\"\n"
+"key Return-Shift+NewLine : \"\\r\\n\"\n"
+"key Return+Shift         : \"\\EOM\"\n"
+"key Backspace      : \"\\x7f\"\n"
+"key Up   -Shift-Ansi : \"\\EA\"\n"
+"key Down -Shift-Ansi : \"\\EB\"\n"
+"key Right-Shift-Ansi : \"\\EC\"\n"
+"key Left -Shift-Ansi : \"\\ED\"\n"
+"key Up    -Shift-AnyMod+Ansi+AppCuKeys           : \"\\EOA\"\n"
+"key Down  -Shift-AnyMod+Ansi+AppCuKeys           : \"\\EOB\"\n"
+"key Right -Shift-AnyMod+Ansi+AppCuKeys           : \"\\EOC\"\n"
+"key Left  -Shift-AnyMod+Ansi+AppCuKeys           : \"\\EOD\"\n"
+"key Up    -Shift-AnyMod+Ansi-AppCuKeys           : \"\\E[A\"\n"
+"key Down  -Shift-AnyMod+Ansi-AppCuKeys           : \"\\E[B\"\n"
+"key Right -Shift-AnyMod+Ansi-AppCuKeys           : \"\\E[C\"\n"
+"key Left  -Shift-AnyMod+Ansi-AppCuKeys           : \"\\E[D\"\n"
+"key Up    -Shift+AnyMod+Ansi                     : \"\\E[1;*A\"\n"
+"key Down  -Shift+AnyMod+Ansi                     : \"\\E[1;*B\"\n"
+"key Right -Shift+AnyMod+Ansi                     : \"\\E[1;*C\"\n"
+"key Left  -Shift+AnyMod+Ansi                     : \"\\E[1;*D\"\n"
+"key Enter+NewLine : \"\\r\\n\"\n"
+"key Enter-NewLine : \"\\r\"\n"
+"key Home        -AnyMod     -AppCuKeys           : \"\\E[H\"  \n"
+"key End         -AnyMod     -AppCuKeys           : \"\\E[F\"  \n"
+"key Home        -AnyMod     +AppCuKeys           : \"\\EOH\"  \n"
+"key End         -AnyMod     +AppCuKeys           : \"\\EOF\"  \n"
+"key Home        +AnyMod                          : \"\\E[1;*H\"\n"
+"key End         +AnyMod                          : \"\\E[1;*F\"\n"
+"key Insert      -AnyMod                          : \"\\E[2~\"\n"
+"key Delete      -AnyMod                          : \"\\E[3~\"\n"
+"key Insert      +AnyMod                          : \"\\E[2;*~\"\n"
+"key Delete      +AnyMod                          : \"\\E[3;*~\"\n"
+"key Prior -Shift-AnyMod                          : \"\\E[5~\"\n"
+"key Next  -Shift-AnyMod                          : \"\\E[6~\"\n"
+"key Prior -Shift+AnyMod                          : \"\\E[5;*~\"\n"
+"key Next  -Shift+AnyMod                          : \"\\E[6;*~\"\n"
+"key F1          -AnyMod                          : \"\\EOP\"\n"
+"key F2          -AnyMod                          : \"\\EOQ\"\n"
+"key F3          -AnyMod                          : \"\\EOR\"\n"
+"key F4          -AnyMod                          : \"\\EOS\"\n"
+"key F5          -AnyMod                          : \"\\E[15~\"\n"
+"key F6          -AnyMod                          : \"\\E[17~\"\n"
+"key F7          -AnyMod                          : \"\\E[18~\"\n"
+"key F8          -AnyMod                          : \"\\E[19~\"\n"
+"key F9          -AnyMod                          : \"\\E[20~\"\n"
+"key F10         -AnyMod                          : \"\\E[21~\"\n"
+"key F11         -AnyMod                          : \"\\E[23~\"\n"
+"key F12         -AnyMod                          : \"\\E[24~\"\n"
+"key F1          +AnyMod                          : \"\\EO*P\"\n"
+"key F2          +AnyMod                          : \"\\EO*Q\"\n"
+"key F3          +AnyMod                          : \"\\EO*R\"\n"
+"key F4          +AnyMod                          : \"\\EO*S\"\n"
+"key F5          +AnyMod                          : \"\\E[15;*~\"\n"
+"key F6          +AnyMod                          : \"\\E[17;*~\"\n"
+"key F7          +AnyMod                          : \"\\E[18;*~\"\n"
+"key F8          +AnyMod                          : \"\\E[19;*~\"\n"
+"key F9          +AnyMod                          : \"\\E[20;*~\"\n"
+"key F10         +AnyMod                          : \"\\E[21;*~\"\n"
+"key F11         +AnyMod                          : \"\\E[23;*~\"\n"
+"key F12         +AnyMod                          : \"\\E[24;*~\"\n"
+"key Space +Control : \"\\x00\"\n"
+"key Up    +Shift-AppScreen  : scrollLineUp\n"
+"key Prior +Shift-AppScreen  : scrollPageUp\n"
+"key Down  +Shift-AppScreen  : scrollLineDown\n"
+"key Next  +Shift-AppScreen  : scrollPageDown\n"
+"key ScrollLock     : scrollLock\n"
+"\0"

=== added file 'src/plugin/konsole/Filter.cpp'
--- src/plugin/konsole/Filter.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/Filter.cpp	2014-05-06 21:50:22 +0000
@@ -0,0 +1,542 @@
+/*
+    Copyright 2007-2008 by Robert Knight <[e-mail]>
+
+    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 "Filter.h"
+
+// System
+#include <iostream>
+
+// Qt
+#include <QtWidgets/QAction>
+#include <QtWidgets/QApplication>
+#include <QtGui/QClipboard>
+#include <QtCore/QString>
+#include <QtCore/QTextStream>
+#include <QtCore/QSharedData>
+#include <QtCore/QFile>
+#include <QDesktopServices>
+#include <QUrl>
+
+// KDE
+//#include <KLocale>
+//#include <KRun>
+
+// Konsole
+#include "TerminalCharacterDecoder.h"
+#include "konsole_wcwidth.h"
+
+
+FilterChain::~FilterChain()
+{
+    QMutableListIterator<Filter*> iter(*this);
+    
+    while ( iter.hasNext() )
+    {
+        Filter* filter = iter.next();
+        iter.remove();
+        delete filter;
+    }
+}
+
+void FilterChain::addFilter(Filter* filter)
+{
+    append(filter);
+}
+void FilterChain::removeFilter(Filter* filter)
+{
+    removeAll(filter);
+}
+bool FilterChain::containsFilter(Filter* filter)
+{
+    return contains(filter);
+}
+void FilterChain::reset()
+{
+    QListIterator<Filter*> iter(*this);
+    while (iter.hasNext())
+        iter.next()->reset();
+}
+void FilterChain::setBuffer(const QString* buffer , const QList<int>* linePositions)
+{
+    QListIterator<Filter*> iter(*this);
+    while (iter.hasNext())
+        iter.next()->setBuffer(buffer,linePositions);
+}
+void FilterChain::process()
+{
+    QListIterator<Filter*> iter(*this);
+    while (iter.hasNext())
+        iter.next()->process();
+}
+void FilterChain::clear()
+{
+    QList<Filter*>::clear();
+}
+Filter::HotSpot* FilterChain::hotSpotAt(int line , int column) const
+{
+    QListIterator<Filter*> iter(*this);
+    while (iter.hasNext())
+    {
+        Filter* filter = iter.next();
+        Filter::HotSpot* spot = filter->hotSpotAt(line,column);
+        if ( spot != 0 )
+        {
+            return spot;
+        }
+    }
+
+    return 0;
+}
+
+QList<Filter::HotSpot*> FilterChain::hotSpots() const
+{
+    QList<Filter::HotSpot*> list;
+    QListIterator<Filter*> iter(*this);
+    while (iter.hasNext())
+    {
+        Filter* filter = iter.next();
+        list << filter->hotSpots();
+    }
+    return list;
+}
+//QList<Filter::HotSpot*> FilterChain::hotSpotsAtLine(int line) const;
+
+TerminalImageFilterChain::TerminalImageFilterChain()
+: _buffer(0)
+, _linePositions(0)
+{
+}
+
+TerminalImageFilterChain::~TerminalImageFilterChain()
+{
+    delete _buffer;
+    delete _linePositions;
+}
+
+void TerminalImageFilterChain::setImage(const Character* const image , int lines , int columns, const QVector<LineProperty>& lineProperties)
+{
+    if (empty())
+        return;
+
+    // reset all filters and hotspots
+    reset();
+
+    PlainTextDecoder decoder;
+    decoder.setTrailingWhitespace(false);
+    
+    // setup new shared buffers for the filters to process on
+    QString* newBuffer = new QString();
+    QList<int>* newLinePositions = new QList<int>();
+    setBuffer( newBuffer , newLinePositions );
+
+    // free the old buffers
+    delete _buffer;
+    delete _linePositions;
+
+    _buffer = newBuffer;
+    _linePositions = newLinePositions;
+
+    QTextStream lineStream(_buffer);
+    decoder.begin(&lineStream);
+
+    for (int i=0 ; i < lines ; i++)
+    {
+        _linePositions->append(_buffer->length());
+        decoder.decodeLine(image + i*columns,columns,LINE_DEFAULT);
+
+        // pretend that each line ends with a newline character.
+        // this prevents a link that occurs at the end of one line
+        // being treated as part of a link that occurs at the start of the next line
+        //
+        // the downside is that links which are spread over more than one line are not
+        // highlighted.  
+        //
+        // TODO - Use the "line wrapped" attribute associated with lines in a
+        // terminal image to avoid adding this imaginary character for wrapped
+        // lines
+        if ( !(lineProperties.value(i,LINE_DEFAULT) & LINE_WRAPPED) )
+            lineStream << QChar('\n');
+    }
+    decoder.end();
+}
+
+Filter::Filter() :
+_linePositions(0),
+_buffer(0)
+{
+}
+
+Filter::~Filter()
+{
+    QListIterator<HotSpot*> iter(_hotspotList);
+    while (iter.hasNext())
+    {
+        delete iter.next();
+    }
+}
+void Filter::reset()
+{
+    _hotspots.clear();
+    _hotspotList.clear();
+}
+
+void Filter::setBuffer(const QString* buffer , const QList<int>* linePositions)
+{
+    _buffer = buffer;
+    _linePositions = linePositions;
+}
+
+void Filter::getLineColumn(int position , int& startLine , int& startColumn)
+{
+    Q_ASSERT( _linePositions );
+    Q_ASSERT( _buffer );
+
+
+    for (int i = 0 ; i < _linePositions->count() ; i++)
+    {
+        int nextLine = 0;
+
+        if ( i == _linePositions->count()-1 )
+            nextLine = _buffer->length() + 1;
+        else
+            nextLine = _linePositions->value(i+1);
+
+        if ( _linePositions->value(i) <= position && position < nextLine ) 
+        {
+            startLine = i;
+            startColumn = string_width(buffer()->mid(_linePositions->value(i),position - _linePositions->value(i)));
+            return;
+        }
+    }
+}
+    
+
+/*void Filter::addLine(const QString& text)
+{
+    _linePositions << _buffer.length();
+    _buffer.append(text);
+}*/
+
+const QString* Filter::buffer()
+{
+    return _buffer;
+}
+Filter::HotSpot::~HotSpot()
+{
+}
+void Filter::addHotSpot(HotSpot* spot)
+{
+    _hotspotList << spot;
+
+    for (int line = spot->startLine() ; line <= spot->endLine() ; line++)
+    {
+        _hotspots.insert(line,spot);
+    }    
+}
+QList<Filter::HotSpot*> Filter::hotSpots() const
+{
+    return _hotspotList;
+}
+QList<Filter::HotSpot*> Filter::hotSpotsAtLine(int line) const
+{
+    return _hotspots.values(line);
+}
+
+Filter::HotSpot* Filter::hotSpotAt(int line , int column) const
+{
+    QListIterator<HotSpot*> spotIter(_hotspots.values(line));
+
+    while (spotIter.hasNext())
+    {
+        HotSpot* spot = spotIter.next();
+        
+        if ( spot->startLine() == line && spot->startColumn() > column )
+            continue;
+        if ( spot->endLine() == line && spot->endColumn() < column )
+            continue;
+       
+        return spot;
+    }
+
+    return 0;
+}
+
+Filter::HotSpot::HotSpot(int startLine , int startColumn , int endLine , int endColumn)
+    : _startLine(startLine)
+    , _startColumn(startColumn)
+    , _endLine(endLine)
+    , _endColumn(endColumn)
+    , _type(NotSpecified)
+{
+}
+QString Filter::HotSpot::tooltip() const
+{
+    return QString();
+}
+QList<QAction*> Filter::HotSpot::actions()
+{
+    return QList<QAction*>();
+}
+int Filter::HotSpot::startLine() const
+{
+    return _startLine;
+}
+int Filter::HotSpot::endLine() const
+{
+    return _endLine;
+}
+int Filter::HotSpot::startColumn() const
+{
+    return _startColumn;
+}
+int Filter::HotSpot::endColumn() const
+{
+    return _endColumn;
+}
+Filter::HotSpot::Type Filter::HotSpot::type() const
+{
+    return _type;
+}
+void Filter::HotSpot::setType(Type type)
+{
+    _type = type;
+}
+
+RegExpFilter::RegExpFilter()
+{
+}
+
+RegExpFilter::HotSpot::HotSpot(int startLine,int startColumn,int endLine,int endColumn)
+    : Filter::HotSpot(startLine,startColumn,endLine,endColumn)
+{
+    setType(Marker);
+}
+
+void RegExpFilter::HotSpot::activate(QObject*)
+{
+}
+
+void RegExpFilter::HotSpot::setCapturedTexts(const QStringList& texts)
+{
+    _capturedTexts = texts;
+}
+QStringList RegExpFilter::HotSpot::capturedTexts() const
+{
+    return _capturedTexts;
+}
+
+void RegExpFilter::setRegExp(const QRegExp& regExp) 
+{
+    _searchText = regExp;
+}
+QRegExp RegExpFilter::regExp() const
+{
+    return _searchText;
+}
+/*void RegExpFilter::reset(int)
+{
+    _buffer = QString();
+}*/
+void RegExpFilter::process()
+{
+    int pos = 0;
+    const QString* text = buffer();
+
+    Q_ASSERT( text );
+
+    // ignore any regular expressions which match an empty string.
+    // otherwise the while loop below will run indefinitely
+    static const QString emptyString("");
+    if ( _searchText.exactMatch(emptyString) )
+        return;
+
+    while(pos >= 0)
+    {
+        pos = _searchText.indexIn(*text,pos);
+
+        if ( pos >= 0 )
+        {
+            int startLine = 0;
+            int endLine = 0;
+            int startColumn = 0;
+            int endColumn = 0;
+
+            getLineColumn(pos,startLine,startColumn);
+            getLineColumn(pos + _searchText.matchedLength(),endLine,endColumn);
+
+            RegExpFilter::HotSpot* spot = newHotSpot(startLine,startColumn,
+                                           endLine,endColumn);
+            spot->setCapturedTexts(_searchText.capturedTexts());
+
+            addHotSpot( spot );  
+            pos += _searchText.matchedLength();
+
+            // if matchedLength == 0, the program will get stuck in an infinite loop
+            if ( _searchText.matchedLength() == 0 )
+                pos = -1;
+        }
+    }    
+}
+
+RegExpFilter::HotSpot* RegExpFilter::newHotSpot(int startLine,int startColumn,
+                                                int endLine,int endColumn)
+{
+    return new RegExpFilter::HotSpot(startLine,startColumn,
+                                                  endLine,endColumn);
+}
+RegExpFilter::HotSpot* UrlFilter::newHotSpot(int startLine,int startColumn,int endLine,
+                                                    int endColumn)
+{
+    return new UrlFilter::HotSpot(startLine,startColumn,
+                                               endLine,endColumn);
+}
+UrlFilter::HotSpot::HotSpot(int startLine,int startColumn,int endLine,int endColumn)
+: RegExpFilter::HotSpot(startLine,startColumn,endLine,endColumn)
+, _urlObject(new FilterObject(this))
+{
+    setType(Link);
+}
+QString UrlFilter::HotSpot::tooltip() const
+{
+    QString url = capturedTexts().first();
+
+    const UrlType kind = urlType();
+
+    if ( kind == StandardUrl )
+        return QString(); 
+    else if ( kind == Email )
+        return QString(); 
+    else
+        return QString();
+}
+UrlFilter::HotSpot::UrlType UrlFilter::HotSpot::urlType() const
+{
+    QString url = capturedTexts().first();
+    
+    if ( FullUrlRegExp.exactMatch(url) )
+        return StandardUrl;
+    else if ( EmailAddressRegExp.exactMatch(url) )
+        return Email;
+    else
+        return Unknown;
+}
+
+void UrlFilter::HotSpot::activate(QObject* object)
+{
+    QString url = capturedTexts().first();
+
+    const UrlType kind = urlType();
+
+    const QString& actionName = object ? object->objectName() : QString();
+
+    if ( actionName == "copy-action" )
+    {
+        QApplication::clipboard()->setText(url);
+        return;
+    }
+
+    if ( !object || actionName == "open-action" )
+    {
+        if ( kind == StandardUrl )
+        {
+            // if the URL path does not include the protocol ( eg. "www.kde.org" ) then
+            // prepend http:// ( eg. "www.kde.org" --> "http://www.kde.org" )
+            if (!url.contains("://"))
+            {
+                url.prepend("http://");
+            }
+        } 
+        else if ( kind == Email )
+        {
+            url.prepend("mailto:");
+        }
+    
+        QDesktopServices::openUrl(QUrl(url));
+        //new KRun(url,QApplication::activeWindow());
+    }
+}
+
+// Note:  Altering these regular expressions can have a major effect on the performance of the filters 
+// used for finding URLs in the text, especially if they are very general and could match very long
+// pieces of text.
+// Please be careful when altering them.
+
+//regexp matches:
+// full url:  
+// protocolname:// or www. followed by anything other than whitespaces, <, >, ' or ", and ends before whitespaces, <, >, ', ", ], !, comma and dot
+const QRegExp UrlFilter::FullUrlRegExp("(www\\.(?!\\.)|[a-z][a-z0-9+.-]*://)[^\\s<>'\"]+[^!,\\.\\s<>'\"\\]]");
+// email address:
+// [word chars, dots or dashes]@[word chars, dots or dashes].[word chars]
+const QRegExp UrlFilter::EmailAddressRegExp("\\b(\\w|\\.|-)+@(\\w|\\.|-)+\\.\\w+\\b");
+
+// matches full url or email address
+const QRegExp UrlFilter::CompleteUrlRegExp('('+FullUrlRegExp.pattern()+'|'+
+                                            EmailAddressRegExp.pattern()+')');
+
+UrlFilter::UrlFilter()
+{
+    setRegExp( CompleteUrlRegExp );
+}
+UrlFilter::HotSpot::~HotSpot()
+{
+    delete _urlObject;
+}
+void FilterObject::activated()
+{
+    _filter->activate(sender());
+}
+QList<QAction*> UrlFilter::HotSpot::actions()
+{
+    QList<QAction*> list;
+
+    const UrlType kind = urlType();
+
+    QAction* openAction = new QAction(_urlObject);
+    QAction* copyAction = new QAction(_urlObject);;
+
+    Q_ASSERT( kind == StandardUrl || kind == Email );
+
+    if ( kind == StandardUrl )
+    {
+        openAction->setText(QObject::tr("Open Link"));
+        copyAction->setText(QObject::tr("Copy Link Address"));
+    }
+    else if ( kind == Email )
+    {
+        openAction->setText(QObject::tr("Send Email To..."));
+        copyAction->setText(QObject::tr("Copy Email Address"));
+    }
+
+    // object names are set here so that the hotspot performs the
+    // correct action when activated() is called with the triggered
+    // action passed as a parameter.
+    openAction->setObjectName( QLatin1String("open-action" ));
+    copyAction->setObjectName( QLatin1String("copy-action" ));
+
+    QObject::connect( openAction , SIGNAL(triggered()) , _urlObject , SLOT(activated()) );
+    QObject::connect( copyAction , SIGNAL(triggered()) , _urlObject , SLOT(activated()) );
+
+    list << openAction;
+    list << copyAction;
+
+    return list; 
+}
+
+//#include "Filter.moc"

=== added file 'src/plugin/konsole/Filter.h'
--- src/plugin/konsole/Filter.h	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/Filter.h	2014-05-06 21:50:22 +0000
@@ -0,0 +1,380 @@
+/*
+    Copyright 2007-2008 by Robert Knight <[e-mail]>
+
+    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 FILTER_H
+#define FILTER_H
+
+// Qt
+#include <QtWidgets/QAction>
+#include <QtCore/QList>
+#include <QtCore/QObject>
+#include <QtCore/QStringList>
+#include <QtCore/QHash>
+#include <QtCore/QRegExp>
+
+// Local
+#include "Character.h"
+
+
+/**
+ * A filter processes blocks of text looking for certain patterns (such as URLs or keywords from a list)
+ * and marks the areas which match the filter's patterns as 'hotspots'.
+ *
+ * Each hotspot has a type identifier associated with it ( such as a link or a highlighted section ),
+ * and an action.  When the user performs some activity such as a mouse-click in a hotspot area ( the exact
+ * action will depend on what is displaying the block of text which the filter is processing ), the hotspot's
+ * activate() method should be called.  Depending on the type of hotspot this will trigger a suitable response.
+ *
+ * For example, if a hotspot represents a URL then a suitable action would be opening that URL in a web browser.
+ * Hotspots may have more than one action, in which case the list of actions can be obtained using the 
+ * actions() method.
+ *
+ * Different subclasses of filter will return different types of hotspot.
+ * Subclasses must reimplement the process() method to examine a block of text and identify sections of interest.
+ * When processing the text they should create instances of Filter::HotSpot subclasses for sections of interest
+ * and add them to the filter's list of hotspots using addHotSpot()
+ */
+class Filter
+{
+public:
+    /**
+    * Represents an area of text which matched the pattern a particular filter has been looking for.
+    *
+    * Each hotspot has a type identifier associated with it ( such as a link or a highlighted section ),
+    * and an action.  When the user performs some activity such as a mouse-click in a hotspot area ( the exact
+    * action will depend on what is displaying the block of text which the filter is processing ), the hotspot's
+    * activate() method should be called.  Depending on the type of hotspot this will trigger a suitable response.
+    *
+    * For example, if a hotspot represents a URL then a suitable action would be opening that URL in a web browser.
+    * Hotspots may have more than one action, in which case the list of actions can be obtained using the 
+    * actions() method.  These actions may then be displayed in a popup menu or toolbar for example. 
+    */
+    class HotSpot
+    {
+    public:
+       /** 
+        * Constructs a new hotspot which covers the area from (@p startLine,@p startColumn) to (@p endLine,@p endColumn)
+        * in a block of text.
+        */
+       HotSpot(int startLine , int startColumn , int endLine , int endColumn);
+       virtual ~HotSpot();
+
+       enum Type
+       {
+            // the type of the hotspot is not specified
+            NotSpecified,
+            // this hotspot represents a clickable link
+            Link,
+            // this hotspot represents a marker
+            Marker
+       }; 
+
+       /** Returns the line when the hotspot area starts */
+       int startLine() const;
+       /** Returns the line where the hotspot area ends */
+       int endLine() const;
+       /** Returns the column on startLine() where the hotspot area starts */
+       int startColumn() const;
+       /** Returns the column on endLine() where the hotspot area ends */
+       int endColumn() const;
+       /** 
+        * Returns the type of the hotspot.  This is usually used as a hint for views on how to represent
+        * the hotspot graphically.  eg.  Link hotspots are typically underlined when the user mouses over them
+        */
+       Type type() const;
+       /** 
+        * Causes the an action associated with a hotspot to be triggered. 
+        *
+        * @param object The object which caused the hotspot to be triggered.  This is
+        * typically null ( in which case the default action should be performed ) or
+        * one of the objects from the actions() list.  In which case the associated
+        * action should be performed. 
+        */
+       virtual void activate(QObject* object = 0) = 0; 
+       /** 
+        * Returns a list of actions associated with the hotspot which can be used in a 
+        * menu or toolbar 
+        */
+       virtual QList<QAction*> actions();
+
+       /** 
+        * Returns the text of a tooltip to be shown when the mouse moves over the hotspot, or
+        * an empty string if there is no tooltip associated with this hotspot.
+        *
+        * The default implementation returns an empty string. 
+        */
+       virtual QString tooltip() const;
+
+    protected:
+       /** Sets the type of a hotspot.  This should only be set once */
+       void setType(Type type);
+
+    private:
+       int    _startLine;
+       int    _startColumn;
+       int    _endLine;
+       int    _endColumn;
+       Type _type;
+    
+    };
+
+    /** Constructs a new filter. */
+    Filter();
+    virtual ~Filter();
+
+    /** Causes the filter to process the block of text currently in its internal buffer */
+    virtual void process() = 0;
+
+    /** 
+     * Empties the filters internal buffer and resets the line count back to 0.
+     * All hotspots are deleted. 
+     */
+    void reset();
+
+    /** Adds a new line of text to the filter and increments the line count */
+    //void addLine(const QString& string);
+
+    /** Returns the hotspot which covers the given @p line and @p column, or 0 if no hotspot covers that area */
+    HotSpot* hotSpotAt(int line , int column) const;
+
+    /** Returns the list of hotspots identified by the filter */
+    QList<HotSpot*> hotSpots() const;
+
+    /** Returns the list of hotspots identified by the filter which occur on a given line */
+    QList<HotSpot*> hotSpotsAtLine(int line) const;
+
+    /** 
+     * TODO: Document me
+     */
+    void setBuffer(const QString* buffer , const QList<int>* linePositions);
+
+protected:
+    /** Adds a new hotspot to the list */
+    void addHotSpot(HotSpot*);
+    /** Returns the internal buffer */
+    const QString* buffer();
+    /** Converts a character position within buffer() to a line and column */
+    void getLineColumn(int position , int& startLine , int& startColumn);
+
+private:
+    QMultiHash<int,HotSpot*> _hotspots;
+    QList<HotSpot*> _hotspotList;
+    
+    const QList<int>* _linePositions;
+    const QString* _buffer;
+};
+
+/** 
+ * A filter which searches for sections of text matching a regular expression and creates a new RegExpFilter::HotSpot 
+ * instance for them.
+ *
+ * Subclasses can reimplement newHotSpot() to return custom hotspot types when matches for the regular expression
+ * are found. 
+ */
+class RegExpFilter : public Filter
+{
+public:
+    /** 
+     * Type of hotspot created by RegExpFilter.  The capturedTexts() method can be used to find the text
+     * matched by the filter's regular expression.
+     */
+    class HotSpot : public Filter::HotSpot
+    {
+    public:
+        HotSpot(int startLine, int startColumn, int endLine , int endColumn);
+        virtual void activate(QObject* object = 0);
+
+        /** Sets the captured texts associated with this hotspot */
+        void setCapturedTexts(const QStringList& texts);
+        /** Returns the texts found by the filter when matching the filter's regular expression */
+        QStringList capturedTexts() const;
+    private:
+        QStringList _capturedTexts;
+    };
+
+    /** Constructs a new regular expression filter */
+    RegExpFilter();
+
+    /** 
+     * Sets the regular expression which the filter searches for in blocks of text. 
+     *
+     * Regular expressions which match the empty string are treated as not matching
+     * anything. 
+     */
+    void setRegExp(const QRegExp& text);
+    /** Returns the regular expression which the filter searches for in blocks of text */
+    QRegExp regExp() const;
+
+    /** 
+     * Reimplemented to search the filter's text buffer for text matching regExp() 
+     *
+     * If regexp matches the empty string, then process() will return immediately
+     * without finding results. 
+     */
+    virtual void process();
+
+protected:
+    /** 
+     * Called when a match for the regular expression is encountered.  Subclasses should reimplement this
+     * to return custom hotspot types
+     */
+    virtual RegExpFilter::HotSpot* newHotSpot(int startLine,int startColumn,
+                                    int endLine,int endColumn);
+
+private:
+    QRegExp _searchText;
+};
+
+class FilterObject;
+
+/** A filter which matches URLs in blocks of text */
+class UrlFilter : public RegExpFilter 
+{
+public:
+    /** 
+     * Hotspot type created by UrlFilter instances.  The activate() method opens a web browser 
+     * at the given URL when called.
+     */
+    class HotSpot : public RegExpFilter::HotSpot 
+    {
+    public:
+        HotSpot(int startLine,int startColumn,int endLine,int endColumn);
+        virtual ~HotSpot();
+
+        virtual QList<QAction*> actions();
+
+        /** 
+         * Open a web browser at the current URL.  The url itself can be determined using
+         * the capturedTexts() method.
+         */
+        virtual void activate(QObject* object = 0);
+
+        virtual QString tooltip() const;
+    private:
+        enum UrlType
+        {
+            StandardUrl,
+            Email,
+            Unknown
+        };
+        UrlType urlType() const;
+
+        FilterObject* _urlObject;
+    };
+
+    UrlFilter();
+
+protected:
+    virtual RegExpFilter::HotSpot* newHotSpot(int,int,int,int);
+
+private:
+    
+    static const QRegExp FullUrlRegExp;
+    static const QRegExp EmailAddressRegExp;
+
+    // combined OR of FullUrlRegExp and EmailAddressRegExp
+    static const QRegExp CompleteUrlRegExp; 
+};
+
+class FilterObject : public QObject
+{
+Q_OBJECT
+public:
+    FilterObject(Filter::HotSpot* filter) : _filter(filter) {}
+private slots:
+    void activated();
+private:
+    Filter::HotSpot* _filter;
+};
+
+/** 
+ * A chain which allows a group of filters to be processed as one. 
+ * The chain owns the filters added to it and deletes them when the chain itself is destroyed.
+ *
+ * Use addFilter() to add a new filter to the chain.  
+ * When new text to be filtered arrives, use addLine() to add each additional
+ * line of text which needs to be processed and then after adding the last line, use
+ * process() to cause each filter in the chain to process the text.
+ *
+ * After processing a block of text, the reset() method can be used to set the filter chain's
+ * internal cursor back to the first line.
+ *
+ * The hotSpotAt() method will return the first hotspot which covers a given position.
+ *
+ * The hotSpots() and hotSpotsAtLine() method return all of the hotspots in the text and on
+ * a given line respectively.
+ */
+class FilterChain : protected QList<Filter*>
+{
+public:
+    virtual ~FilterChain();
+
+    /** Adds a new filter to the chain.  The chain will delete this filter when it is destroyed */
+    void addFilter(Filter* filter);
+    /** Removes a filter from the chain.  The chain will no longer delete the filter when destroyed */
+    void removeFilter(Filter* filter);
+    /** Returns true if the chain contains @p filter */
+    bool containsFilter(Filter* filter);
+    /** Removes all filters from the chain */
+    void clear();
+
+    /** Resets each filter in the chain */
+    void reset();
+    /**
+     * Processes each filter in the chain 
+     */
+    void process();
+
+    /** Sets the buffer for each filter in the chain to process. */
+    void setBuffer(const QString* buffer , const QList<int>* linePositions); 
+
+    /** Returns the first hotspot which occurs at @p line, @p column or 0 if no hotspot was found */
+    Filter::HotSpot* hotSpotAt(int line , int column) const;
+    /** Returns a list of all the hotspots in all the chain's filters */
+    QList<Filter::HotSpot*> hotSpots() const;
+    /** Returns a list of all hotspots at the given line in all the chain's filters */
+    QList<Filter::HotSpot> hotSpotsAtLine(int line) const;
+
+};
+
+/** A filter chain which processes character images from terminal displays */
+class TerminalImageFilterChain : public FilterChain
+{
+public:
+    TerminalImageFilterChain();
+    virtual ~TerminalImageFilterChain();
+
+    /**
+     * Set the current terminal image to @p image.
+     *
+     * @param image The terminal image
+     * @param lines The number of lines in the terminal image
+     * @param columns The number of columns in the terminal image
+     * @param lineProperties The line properties to set for image
+     */
+    void setImage(const Character* const image , int lines , int columns,
+                  const QVector<LineProperty>& lineProperties);  
+
+private:
+    QString* _buffer;
+    QList<int>* _linePositions;
+};
+
+
+#endif //FILTER_H

=== added file 'src/plugin/konsole/History.cpp'
--- src/plugin/konsole/History.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/konsole/History.cpp	2014-05-06 21:50:22 +0000
@@ -0,0 +1,986 @@
+/*
+    This file is part of Konsole, an X terminal.
+    Copyright 1997,1998 by Lars Doelle <[e-mail]>
+
+    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"
+
+// System
+#include <iostream>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <QtDebug>
+
+// KDE
+//#include <kde_file.h>
+//#include <kdebug.h>
+
+// Reasonable line size
+#define LINE_SIZE    1024
+#define KDE_lseek lseek
+
+
+/*
+   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 serie of lines and each line is
+   a serie 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.
+
+KDE4: Can we use QTemporaryFile here, instead of KTempFile?
+
+FIXME: some complain about the history buffer comsuming the
+       memory of their machines. This problem is critical
+       since the history does not behave gracefully in cases
+       where the memory is used up completely.
+
+       I put in a workaround that should handle it problem
+       now gracefully. I'm not satisfied with the solution.
+
+FIXME: Terminating the history is not properly indicated
+       in the menu. We should throw a signal.
+
+FIXME: There is noticeable decrease in speed, also. Perhaps,
+       there whole feature needs to be revisited therefore.
+       Disadvantage of a more elaborated, say block-oriented
+       scheme with wrap around would be it's complexity.
+*/
+
+//FIXME: tempory replacement for tmpfile
+//       this is here one for debugging purpose.