1
=== added file '.bzrignore'
2
--- .bzrignore	1970-01-01 00:00:00 +0000
3
+++ .bzrignore	2014-05-06 21:50:22 +0000
4
@@ -0,0 +1,16 @@
5
1
Makefile
6
2
src/*.so
7
3
*user
8
4
9
5
.moc/
10
6
.obj/
11
7
12
8
debian/files
13
9
debian/qtdeclarative5-konsole-qml-plugin/
14
10
debian/*.debhelper.log
15
11
debian/*.substvars
16
12
.excludes
17
13
obj-x86_64-linux-gnu
18
14
debian/tmp
19
15
debian/ubuntu-terminal-app
20
16
debian/ubuntu-terminal-app-autopilot
21
0
17
22
=== removed file '.bzrignore'
23
--- .bzrignore	2013-04-23 20:42:10 +0000
24
+++ .bzrignore	1970-01-01 00:00:00 +0000
25
@@ -1,6 +0,0 @@
26
1
*.qmlproject.user
27
2
28
3
debian/files
29
4
debian/ubuntu-terminal-app/
30
5
debian/*.debhelper.log
31
6
debian/*.substvars
32
7
0
33
=== modified file 'CMakeLists.txt'
34
--- CMakeLists.txt	2014-04-15 18:00:53 +0000
35
+++ CMakeLists.txt	2014-05-06 21:50:22 +0000
36
@@ -1,6 +1,9 @@
38
1
project(com.ubuntu.terminal)
1
project(com.ubuntu.terminal C CXX)
39
2
cmake_minimum_required(VERSION 2.8.9)
2
cmake_minimum_required(VERSION 2.8.9)
40
3
3
41
4
set(CMAKE_AUTOMOC ON)
42
5
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-permissive -pedantic -Wall -Wextra -fPIC")
43
6
44
4
# Standard install paths
7
# Standard install paths
45
5
include(GNUInstallDirs)
8
include(GNUInstallDirs)
46
6
9
47
@@ -8,49 +11,61 @@
48
8
option(CLICK_MODE "Installs to a contained location" off)
11
option(CLICK_MODE "Installs to a contained location" off)
49
9
12
50
10
set(APP_NAME terminal)
13
set(APP_NAME terminal)
53
11
set(DESKTOP_FILE "${PROJECT_NAME}_${APP_NAME}.desktop")
14
set(DESKTOP_FILE "${PROJECT_NAME}.desktop")
54
12
set(URLS_FILE "${PROJECT_NAME}_${APP_NAME}.url-dispatcher")
15
set(URLS_FILE "${PROJECT_NAME}.url-dispatcher")
55
13
set(APP_HARDCODE ubuntu-terminal-app)
16
set(APP_HARDCODE ubuntu-terminal-app)
56
14
set(MAIN_QML ubuntu-terminal-app.qml)
17
set(MAIN_QML ubuntu-terminal-app.qml)
57
15
set(ICON_FILE terminal64.png)
18
set(ICON_FILE terminal64.png)
58
16
set(AUTOPILOT_DIR ubuntu_terminal_app)
19
set(AUTOPILOT_DIR ubuntu_terminal_app)
59
20
set(EXEC "${APP_NAME}")
60
17
21
61
18
if(CLICK_MODE)
22
if(CLICK_MODE)
62
19
    if(NOT DEFINED BZR_SOURCE)
23
    if(NOT DEFINED BZR_SOURCE)
63
20
        set(BZR_SOURCE "lp:${APP_HARDCODE}")
24
        set(BZR_SOURCE "lp:${APP_HARDCODE}")
64
21
        message("-- Setting BZR_SOURCE to ${BZR_SOURCE}")
25
        message("-- Setting BZR_SOURCE to ${BZR_SOURCE}")
65
22
    endif(NOT DEFINED BZR_SOURCE)
26
    endif(NOT DEFINED BZR_SOURCE)
66
27
    # Find out the architecture for package building
67
28
    # to determine the plugin's installation path
68
29
    execute_process(
69
30
        COMMAND dpkg-architecture -qDEB_HOST_MULTIARCH
70
31
        OUTPUT_VARIABLE ARCH_TRIPLET
71
32
        OUTPUT_STRIP_TRAILING_WHITESPACE
72
33
    )
73
23
    set(CMAKE_INSTALL_PREFIX /)
34
    set(CMAKE_INSTALL_PREFIX /)
74
24
    set(CMAKE_INSTALL_BINDIR /)
35
    set(CMAKE_INSTALL_BINDIR /)
75
25
    set(DATA_DIR /)
36
    set(DATA_DIR /)
76
26
    set(EXEC "qmlscene ${MAIN_QML}")
77
27
    set(DESKTOP_DIR ${DATA_DIR})
37
    set(DESKTOP_DIR ${DATA_DIR})
78
28
    set(URLS_DIR ${DATA_DIR})
38
    set(URLS_DIR ${DATA_DIR})
80
29
	set(ICON ${ICON_FILE})
39
    set(ICON ${ICON_FILE})
81
40
    set(QT_IMPORTS_DIR "/lib/${ARCH_TRIPLET}")
82
41
    set(BIN_DIR /lib/${ARCH_TRIPLET}/bin)
83
42
    if(NOT BZR_REVNO)
84
43
        set(BZR_REVNO "latest")
85
44
    endif(NOT BZR_REVNO)
86
45
    configure_file(manifest.json ${CMAKE_CURRENT_BINARY_DIR}/manifest.json)
87
46
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/manifest.json apparmor.json DESTINATION ${CMAKE_INSTALL_PREFIX})
88
30
else(CLICK_MODE)
47
else(CLICK_MODE)
96
31
    set(DATA_DIR ${CMAKE_INSTALL_DATADIR}/${APP_HARDCODE})
48
    execute_process(
97
32
    set(EXEC ${APP_HARDCODE})
49
        COMMAND qmake -query QT_INSTALL_QML
98
33
	set(ICON ${CMAKE_INSTALL_PREFIX}/${DATA_DIR}/${ICON_FILE})
50
        OUTPUT_VARIABLE QT_IMPORTS_DIR
99
34
    configure_file(${APP_HARDCODE}.in
51
        OUTPUT_STRIP_TRAILING_WHITESPACE
100
35
        ${CMAKE_CURRENT_BINARY_DIR}/${APP_HARDCODE})
52
    )
101
36
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${APP_HARDCODE}
53
    set(DATA_DIR ${CMAKE_INSTALL_DATADIR}/${APP_NAME})
102
37
        DESTINATION ${CMAKE_INSTALL_BINDIR})
54
    set(ICON ${CMAKE_INSTALL_PREFIX}/${DATA_DIR}/${ICON_FILE})
103
38
    set(DESKTOP_DIR ${CMAKE_INSTALL_DATADIR}/applications)
55
    set(DESKTOP_DIR ${CMAKE_INSTALL_DATADIR}/applications)
104
39
    set(URLS_DIR ${CMAKE_INSTALL_DATADIR}/url-dispatcher/urls)
56
    set(URLS_DIR ${CMAKE_INSTALL_DATADIR}/url-dispatcher/urls)
105
40
endif(CLICK_MODE)
57
endif(CLICK_MODE)
106
41
58
107
42
file(GLOB_RECURSE I18N_SRC_FILES
59
file(GLOB_RECURSE I18N_SRC_FILES
108
43
     RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
60
     RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
110
44
     rc/**.qml desktop/**.desktop.in)
61
     src/app/**.qml *.desktop.in)
111
45
list(SORT I18N_SRC_FILES)
62
list(SORT I18N_SRC_FILES)
112
46
63
113
47
114
48
file(GLOB SRC_FILES
64
file(GLOB SRC_FILES
115
49
     RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
65
     RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
116
50
     *.qml *.js *.png *.js)
66
     *.qml *.js *.png *.js)
120
51
install(DIRECTORY config extraPanel DESTINATION ${DATA_DIR})
67
install(FILES ${SRC_FILES}
121
52
install(FILES Terminal.qml Configs.qml settings.png avatar@8.png
68
    DESTINATION ${DATA_DIR})
119
53
    ${MAIN_QML} ${ICON_FILE} DESTINATION ${DATA_DIR})
122
54
69
123
55
configure_file(${DESKTOP_FILE}.in ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE})
70
configure_file(${DESKTOP_FILE}.in ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE})
124
56
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE}
71
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE}
125
@@ -61,6 +76,6 @@
126
61
# Tests
76
# Tests
127
62
enable_testing()
77
enable_testing()
128
63
78
129
64
add_subdirectory(click)
130
65
add_subdirectory(po)
79
add_subdirectory(po)
131
66
add_subdirectory(tests)
80
add_subdirectory(tests)
132
81
add_subdirectory(src)
133
67
82
134
=== removed file 'README'
135
--- README	2013-02-12 16:18:48 +0000
136
+++ README	1970-01-01 00:00:00 +0000
137
@@ -1,1 +0,0 @@
138
1
this is an example README file.
139
2
0
140
=== added file 'README.md'
141
--- README.md	1970-01-01 00:00:00 +0000
142
+++ README.md	2014-05-06 21:50:22 +0000
143
@@ -0,0 +1,152 @@
144
1
# Ubuntu Terminal
145
2
146
3
A terminal app for desktop and mobile devices. It provides access to terminal
147
4
sessions and is based on KDE's Konsole plugin.
148
5
149
6
The current plugin consists of:
150
7
- KTerminal: offers access to terminal session from qml
151
8
- KSessions: offers access to pty(s) from C++ layer
152
9
153
10
## Building the app
154
11
155
12
### For the desktop
156
13
157
14
Install the following build dependencies:
158
15
159
16
(none required at the moment) 
160
17
161
18
Then open the CMakeLists.txt file in Qt Creator, and ensure that the kit
162
19
selected on the left sidebar (just above the green "Run" button) is "Desktop"
163
20
164
21
### For a device
165
22
166
23
If you don't have one already, you'll need to create an armhf chroot to
167
24
cross-compile the app. Here's how:
168
25
169
26
1. In Qt Creator, open the CMakeLists.txt file
170
27
2. Go to Tools > Options > Ubuntu > Click
171
28
2. Click on Create Click Target
172
29
3. Follow the prompts to generate the chroot. You will be asked for your sudo
173
30
   password
174
31
4. Once created, you'll need to add the build dependencies for the app:
175
32
  - At this time, none are required, but the steps are shown for the sake of
176
33
    completion
177
34
  - Click on the Maintain button on your chroot
178
35
  - On the terminal prompt that is started, type 
179
36
    apt-get install $DEPENDENCY_NAME:armhf'
180
37
  - Close the terminal when the installation finishes
181
38
5. Now you can either do a clean checkout and wait to be prompted by Qt Creator
182
39
   to add the armhf kit, or alternatively:
183
40
6. Go to the Projects tab > Add kit and then select the UbuntuSDK armhf kit
184
41
185
42
Additionally, you'll have to tell Qt Creator that you are doing a build for a
186
43
device to ultimately create a click package for installation:
187
44
188
45
1. In Qt Creator, go to the Projects tab on the sidebar
189
46
2. Click on the "Build" subtab of the "UbuntuSDK for armhf..." tab
190
47
3. Then go to the "CMake arguments" text field and add "-DCLICK_MODE=on"
191
48
   without the quotes
192
49
193
50
Before starting the build make sure to select the "UbuntuSDK" kit on Qt
194
51
Creator's left sidebar (just above the green "Run" button).
195
52
196
53
### Doing the build
197
54
198
55
Ensure you've selected the kit you want for your build and press the build
199
56
button on Qt Creator's left sidebar (or alternatively Ctrl+B).
200
57
201
58
## Running the app
202
59
203
60
### On the desktop
204
61
205
62
No additional steps are required before running the app on the desktop.
206
63
207
64
### On a device
208
65
209
66
Due to Qt Creator's bug #1312094 in launchpad.net, there needs to be a manual
210
67
workaround done before the app can run on the device:
211
68
 
212
69
1. Modify the desktop.in file: change the Exec line to read:
213
70
   Exec=lib/arm-linux-gnueabihf/bin/@EXEC@
214
71
215
72
Remember to revert this temporary change if you are building a click package or
216
73
if you're making other changes to be committed to the code!
217
74
218
75
### Starting the app
219
76
220
77
Ensure you've selected the kit you want for your build and press the run
221
78
button on Qt Creator's left sidebar (or alternatively Ctrl+R).
222
79
223
80
If the app hasn't been built yet, or if there are pending changes that require
224
81
a build, the app will automatically be built first before running.
225
82
226
83
If you're starting the app on a device, the build will be copied over and the
227
84
code will run unconfined.
228
85
229
86
## Building a click package
230
87
231
88
There are two alternative ways of building a click package.
232
89
233
90
### Using Qt Creator
234
91
235
92
1. Ensure you've selected the UbuntuSDK for armhf kit on Qt Creator's sidebar
236
93
2. Click on Publish on the sidebar
237
94
3. Click on "Create package"
238
95
4. If all goes well, you'll find the final click package in the build directory
239
96
240
97
Notes:
241
98
- You can see the output of the click build if you click on Edit on the sidebar
242
99
  and then "Application Output" at the bottom. This is useful to identify any
243
100
  failures during the build
244
101
- Run `sudo apt-get install click-reviewers-tools` to enable click package
245
102
  validation in Qt Creator. You might need to restart Qt Creator after you've
246
103
  installed them for it to detect them
247
104
248
105
### Using click-buddy
249
106
250
107
1. Install phablet-tools: `sudo apt-get install phablet-tools`
251
108
2. Run click-buddy in your source tree:
252
109
   click-buddy --dir . --arch armhf --framework ubuntu-sdk-14.04
253
110
3. Once finished, click-buddy will tell you the location of your source package
254
111
255
112
## Installing a click package
256
113
257
114
First of all, ensure you've got a working Ubuntu device attached over USB to
258
115
your host computer
259
116
260
117
### Manually
261
118
262
119
Run the following commands to manually install the click package (replace 0.1
263
120
with the version of your package):
264
121
265
122
    adb push /home/phablet com.ubuntu.terminal_0.1_armhf.click
266
123
    adb shell
267
124
    sudo -H -u phablet pkcon install-local /home/phablet/com.ubuntu.terminal_0.1_armhf.click
268
125
269
126
### Using click-buddy
270
127
271
128
You can add the --provision argument to the previous command to install the
272
129
click package on the device.
273
130
274
131
### Starting the app
275
132
276
133
1. Either kill unity8 with `pkill unity8` or restart the system for the Apps
277
134
   (click) scope to pick up your newly installed click package
278
135
2. Search for Reminders in the Apps scope and tap on its icon to start it
279
136
3. You'll find the runtime logs at ~/.cache/upstart/application-click/
280
137
281
138
## Uninstalling a click package
282
139
283
140
Run the following commands, replacing the version of the click package you want
284
141
to uninstall:
285
142
286
143
    adb shell
287
144
    sudo -iu phablet
288
145
    sudo click unregister com.ubuntu.terminal 0.1
289
146
290
147
## Run the autopilot tests
291
148
292
149
Once the app has been built, you can go to the build directory and run:
293
150
294
151
    cd tests/autopilot
295
152
    autopilot run ubuntu_terminal_app
296
0
153
297
=== renamed file 'click/apparmor.json' => 'apparmor.json'
298
--- click/apparmor.json	2014-03-14 18:33:50 +0000
299
+++ apparmor.json	2014-05-06 21:50:22 +0000
300
@@ -1,4 +1,5 @@
301
1
{
1
{
303
2
    "policy_version": 1.1, 
2
    "policy_groups": [],
304
3
    "policy_version": 1.1,
305
3
    "template": "unconfined"
4
    "template": "unconfined"
307
4
}
5
}
308
5
\ No newline at end of file
6
\ No newline at end of file
309
6
7
310
=== removed directory 'click'
311
=== removed file 'click/CMakeLists.txt'
312
--- click/CMakeLists.txt	2014-01-31 21:52:08 +0000
313
+++ click/CMakeLists.txt	1970-01-01 00:00:00 +0000
314
@@ -1,8 +0,0 @@
315
1
if(CLICK_MODE)
316
2
    if(NOT BZR_REVNO)
317
3
        set(BZR_REVNO "latest")
318
4
    endif(NOT BZR_REVNO)
319
5
    configure_file(manifest.json.in ${CMAKE_CURRENT_BINARY_DIR}/manifest.json)
320
6
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/manifest.json apparmor.json
321
7
            DESTINATION ${CMAKE_INSTALL_PREFIX})
322
8
endif(CLICK_MODE)
323
9
0
324
=== renamed file 'com.ubuntu.terminal_terminal.desktop.in' => 'com.ubuntu.terminal.desktop.in'
325
=== renamed file 'com.ubuntu.terminal_terminal.url-dispatcher' => 'com.ubuntu.terminal.url-dispatcher'
326
=== modified file 'debian/changelog'
327
--- debian/changelog	2014-03-10 10:19:53 +0000
328
+++ debian/changelog	2014-05-06 21:50:22 +0000
329
@@ -1,8 +1,12 @@
331
1
ubuntu-terminal-app (0.5ubuntu1) UNRELEASED; urgency=medium
1
ubuntu-terminal-app (0.5ubuntu2) trusty; urgency=medium
332
2
2
333
3
  [ Alan Pope ]
334
3
  * Add -qt5 command line option (LP: #1288885)  
4
  * Add -qt5 command line option (LP: #1288885)  
335
4
5
337
5
 -- Alan Pope <popey@ubuntu.com>  Mon, 10 Mar 2014 10:19:27 +0000
6
  [ David Planella ]
338
7
  * Merge konsole plugin into the app's repo. 
339
8
340
9
 -- David Planella <david.planella@ubuntu.com>  Sun, 27 Apr 2014 12:08:04 +0200
341
6
10
342
7
ubuntu-terminal-app (0.5) raring; urgency=low
11
ubuntu-terminal-app (0.5) raring; urgency=low
343
8
12
344
9
13
345
=== modified file 'debian/control'
346
--- debian/control	2014-03-07 21:06:44 +0000
347
+++ debian/control	2014-05-06 21:50:22 +0000
348
@@ -3,29 +3,50 @@
349
3
Maintainer: Ubuntu App Cats <ubuntu-touch-coreapps@lists.launchpad.net>
3
Maintainer: Ubuntu App Cats <ubuntu-touch-coreapps@lists.launchpad.net>
350
4
Build-Depends: cmake,
4
Build-Depends: cmake,
351
5
               debhelper (>= 9),
5
               debhelper (>= 9),
354
6
               python,
6
               python3-all,
355
7
Standards-Version: 3.9.4
7
               gettext,
356
8
               qtbase5-dev,
357
9
               qtdeclarative5-dev,
358
10
               qt5-default,
359
11
Standards-Version: 3.9.5
360
8
Section: misc
12
Section: misc
361
9
Homepage: https://launchpad.net/ubuntu-terminal-app
13
Homepage: https://launchpad.net/ubuntu-terminal-app
362
10
Vcs-Bzr: https://code.launchpad.net/~ubuntu-terminal-dev/ubuntu-terminal-app/trunk
14
Vcs-Bzr: https://code.launchpad.net/~ubuntu-terminal-dev/ubuntu-terminal-app/trunk
363
11
15
364
12
Package: ubuntu-terminal-app
16
Package: ubuntu-terminal-app
365
13
Section: misc
17
Section: misc
368
14
Architecture: all
18
Architecture: any
369
15
Depends: qmlscene,
19
Depends: ${misc:Depends},
370
20
         ${shlibs:Depends},
371
16
         qtdeclarative5-konsole-qml-plugin (>= 0.1.1),
21
         qtdeclarative5-konsole-qml-plugin (>= 0.1.1),
372
17
         qtdeclarative5-localstorage-plugin,
22
         qtdeclarative5-localstorage-plugin,
373
18
         qtdeclarative5-qtquick2-plugin,
23
         qtdeclarative5-qtquick2-plugin,
376
19
         qtdeclarative5-ubuntu-ui-toolkit-plugin | qt-components-ubuntu,
24
         qtdeclarative5-ubuntu-ui-toolkit-plugin,
375
20
         ${misc:Depends},
377
21
Description: Terminal application
25
Description: Terminal application
378
22
 Core Terminal application
26
 Core Terminal application
379
23
27
380
28
Package: qtdeclarative5-konsole-qml-plugin
381
29
Architecture: any
382
30
Multi-Arch: same
383
31
Depends: ${misc:Depends},
384
32
         ${shlibs:Depends},
385
33
         ${misc:Pre-Depends},
386
34
Description: KDE Konsole QML plugin - qml terminal plugin
387
35
 Konsole is a terminal emulator from KDE. This is a ported
388
36
 version for the Ubuntu Terminal app and does not require KDE.
389
37
 .
390
38
 This package contains the Konsole terminal emulator plugin
391
39
 for Qt Qml, which offers access to terminal by KTerminal and
392
40
 KSession elements. KTerminal is used for displaying information
393
41
 given by KSession.
394
42
395
24
Package: ubuntu-terminal-app-autopilot
43
Package: ubuntu-terminal-app-autopilot
396
25
Architecture: all
44
Architecture: all
398
26
Depends: libautopilot-qt,
45
Depends: ${misc:Depends},
399
46
         libautopilot-qt,
400
27
         libqt5test5,
47
         libqt5test5,
402
28
         ubuntu-terminal-app (= ${source:Version}),
48
         python3-autopilot,
403
49
         ubuntu-terminal-app (>= ${source:Version}),
404
29
         ubuntu-ui-toolkit-autopilot,
50
         ubuntu-ui-toolkit-autopilot,
405
30
Description: Autopilot tests for Terminal Application
51
Description: Autopilot tests for Terminal Application
406
31
 This package contains the autopilot tests for the Terminal
52
 This package contains the autopilot tests for the Terminal
407
32
53
408
=== added file 'debian/qtdeclarative5-konsole-qml-plugin.install'
409
--- debian/qtdeclarative5-konsole-qml-plugin.install	1970-01-01 00:00:00 +0000
410
+++ debian/qtdeclarative5-konsole-qml-plugin.install	2014-05-06 21:50:22 +0000
411
@@ -0,0 +1,1 @@
412
1
usr/lib/*/qt5/qml/org/kde/konsole/
413
0
2
414
=== renamed file 'click/manifest.json.in' => 'manifest.json'
415
--- click/manifest.json.in	2014-04-11 22:59:46 +0000
416
+++ manifest.json	2014-05-06 21:50:22 +0000
417
@@ -3,15 +3,15 @@
418
3
    "framework": "ubuntu-sdk-14.04-dev1",
3
    "framework": "ubuntu-sdk-14.04-dev1",
419
4
    "architecture": "armhf",
4
    "architecture": "armhf",
420
5
    "hooks": {
5
    "hooks": {
422
6
        "@APP_NAME@": {
6
        "terminal": {
423
7
            "apparmor": "apparmor.json",
7
            "apparmor": "apparmor.json",
426
8
            "desktop": "@DESKTOP_FILE@",
8
            "desktop": "com.ubuntu.terminal.desktop",
427
9
            "urls": "@URLS_FILE@"
9
            "urls": "com.ubuntu.terminal.url-dispatcher"
428
10
        }
10
        }
429
11
    },
11
    },
431
12
    "icon": "@ICON@",
12
    "icon": "terminal64.png",
432
13
    "maintainer": "Ubuntu App Cats <ubuntu-touch-coreapps@lists.launchpad.net>",
13
    "maintainer": "Ubuntu App Cats <ubuntu-touch-coreapps@lists.launchpad.net>",
434
14
    "name": "@PROJECT_NAME@",
14
    "name": "com.ubuntu.terminal",
435
15
    "title": "Terminal",
15
    "title": "Terminal",
436
16
    "version": "0.5.@BZR_REVNO@",
16
    "version": "0.5.@BZR_REVNO@",
437
17
    "x-source": {
17
    "x-source": {
438
@@ -21,4 +21,4 @@
439
21
    "x-test": {
21
    "x-test": {
440
22
        "autopilot": "@AUTOPILOT_DIR@"
22
        "autopilot": "@AUTOPILOT_DIR@"
441
23
    }
23
    }
443
24
}
24
}
444
25
\ No newline at end of file
25
\ No newline at end of file
445
26
26
446
=== removed file 'plugins.json'
447
--- plugins.json	2013-10-11 14:30:09 +0000
448
+++ plugins.json	1970-01-01 00:00:00 +0000
449
@@ -1,6 +0,0 @@
450
1
[
451
2
{
452
3
    "package": "qtdeclarative5-konsole-qml-plugin",
453
4
    "ppa": "ppa:ubuntu-touch-coreapps-drivers/daily"
454
5
}
455
6
]
456
7
0
457
=== added directory 'src'
458
=== added file 'src/CMakeLists.txt'
459
--- src/CMakeLists.txt	1970-01-01 00:00:00 +0000
460
+++ src/CMakeLists.txt	2014-05-06 21:50:22 +0000
461
@@ -0,0 +1,2 @@
462
1
add_subdirectory(plugin)
463
2
add_subdirectory(app)
464
0
3
465
=== added directory 'src/app'
466
=== added file 'src/app/CMakeLists.txt'
467
--- src/app/CMakeLists.txt	1970-01-01 00:00:00 +0000
468
+++ src/app/CMakeLists.txt	2014-05-06 21:50:22 +0000
469
@@ -0,0 +1,24 @@
470
1
file(GLOB_RECURSE QML_SRCS *.qml *.js)
471
2
472
3
set(terminal_SRCS
473
4
    main.cpp
474
5
    ${QML_SRCS}
475
6
)
476
7
477
8
add_executable(terminal ${terminal_SRCS})
478
9
479
10
qt5_use_modules(terminal Gui Qml Quick)
480
11
481
12
if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
482
13
add_custom_target(terminal-qmlfiles ALL
483
14
    COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/qml ${CMAKE_CURRENT_BINARY_DIR}
484
15
    DEPENDS ${QMLFILES}
485
16
)
486
17
endif(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
487
18
488
19
install(DIRECTORY qml DESTINATION ${DATA_DIR})
489
20
if(CLICK_MODE)
490
21
  install(TARGETS terminal DESTINATION ${BIN_DIR})
491
22
else()
492
23
  install(TARGETS terminal RUNTIME DESTINATION bin)
493
24
endif()
494
0
25
495
=== added file 'src/app/main.cpp'
496
--- src/app/main.cpp	1970-01-01 00:00:00 +0000
497
+++ src/app/main.cpp	2014-05-06 21:50:22 +0000
498
@@ -0,0 +1,120 @@
499
1
/*
500
2
 * Copyright: 2013 - 2014 Canonical, Ltd
501
3
 *
502
4
 * This file is part of ubuntu-terminal-app
503
5
 *
504
6
 * ubuntu-terminal-app is free software: you can redistribute it and/or modify
505
7
 * it under the terms of the GNU General Public License as published by
506
8
 * the Free Software Foundation, either version 3 of the License, or
507
9
 * (at your option) any later version.
508
10
 *
509
11
 * ubuntu-terminal-app is distributed in the hope that it will be useful,
510
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
511
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
512
14
 * GNU General Public License for more details.
513
15
 *
514
16
 * You should have received a copy of the GNU General Public License
515
17
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
516
18
 *
517
19
 * Authors: Michael Zanetti <michael.zanetti@canonical.com>
518
20
 *          Riccardo Padovani <rpadovani@ubuntu.com>
519
21
 *          David Planella <david.planella@ubuntu.com>
520
22
 */
521
23
522
24
#include <QtGui/QGuiApplication>
523
25
#include <QtQuick/QQuickView>
524
26
#include <QtQml/QtQml>
525
27
#include <QLibrary>
526
28
#include <QDir>
527
29
528
30
#include <QDebug>
529
31
530
32
int main(int argc, char *argv[])
531
33
{
532
34
    QGuiApplication a(argc, argv);
533
35
    QQuickView view;
534
36
    view.setResizeMode(QQuickView::SizeRootObjectToView);
535
37
536
38
    // Set up import paths
537
39
    QStringList importPathList = view.engine()->importPathList();
538
40
    // Prepend the location of the plugin in the build dir,
539
41
    // so that Qt Creator finds it there, thus overriding the one installed
540
42
    // in the sistem if there is one
541
43
    importPathList.prepend(QCoreApplication::applicationDirPath() + "/../plugin/");
542
44
543
45
    QStringList args = a.arguments();
544
46
    if (args.contains("-h") || args.contains("--help")) {
545
47
        qDebug() << "usage: " + args.at(0) + " [-p|--phone] [-t|--tablet] [-h|--help] [-I <path>]";
546
48
        qDebug() << "    -p|--phone    If running on Desktop, start in a phone sized window.";
547
49
        qDebug() << "    -t|--tablet   If running on Desktop, start in a tablet sized window.";
548
50
        qDebug() << "    -h|--help     Print this help.";
549
51
        qDebug() << "    -I <path>     Give a path for an additional QML import directory. May be used multiple times.";
550
52
        qDebug() << "    -q <qmlfile>  Give an alternative location for the main qml file.";
551
53
        return 0;
552
54
    }
553
55
554
56
    QString qmlfile;
555
57
    for (int i = 0; i < args.count(); i++) {
556
58
        if (args.at(i) == "-I" && args.count() > i + 1) {
557
59
            QString addedPath = args.at(i+1);
558
60
            if (addedPath.startsWith('.')) {
559
61
                addedPath = addedPath.right(addedPath.length() - 1);
560
62
                addedPath.prepend(QDir::currentPath());
561
63
            }
562
64
            importPathList.append(addedPath);
563
65
        } else if (args.at(i) == "-q" && args.count() > i + 1) {
564
66
            qmlfile = args.at(i+1);
565
67
        }
566
68
    }
567
69
568
70
    if (args.contains(QLatin1String("-testability")) || getenv("QT_LOAD_TESTABILITY")) {
569
71
        QLibrary testLib(QLatin1String("qttestability"));
570
72
        if (testLib.load()) {
571
73
            typedef void (*TasInitialize)(void);
572
74
            TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
573
75
            if (initFunction) {
574
76
                initFunction();
575
77
            } else {
576
78
                qCritical("Library qttestability resolve failed!");
577
79
            }
578
80
        } else {
579
81
            qCritical("Library qttestability load failed!");
580
82
        }
581
83
    }
582
84
583
85
    view.engine()->rootContext()->setContextProperty("tablet", QVariant(false));
584
86
    view.engine()->rootContext()->setContextProperty("phone", QVariant(false));
585
87
    if (args.contains("-t") || args.contains("--tablet")) {
586
88
        qDebug() << "running in tablet mode";
587
89
        view.engine()->rootContext()->setContextProperty("tablet", QVariant(true));
588
90
    } else if (args.contains("-p") || args.contains("--phone")){
589
91
        qDebug() << "running in phone mode";
590
92
        view.engine()->rootContext()->setContextProperty("phone", QVariant(true));
591
93
    } else if (qgetenv("QT_QPA_PLATFORM") != "ubuntumirclient") {
592
94
        // Default to tablet size on X11
593
95
        view.engine()->rootContext()->setContextProperty("tablet", QVariant(true));
594
96
    }
595
97
596
98
    view.engine()->setImportPathList(importPathList);
597
99
598
100
    // load the qml file
599
101
    if (qmlfile.isEmpty()) {
600
102
        QStringList paths = QStandardPaths::standardLocations(QStandardPaths::DataLocation);
601
103
        paths.prepend(QDir::currentPath());
602
104
        paths.prepend(QCoreApplication::applicationDirPath());
603
105
604
106
        foreach (const QString &path, paths) {
605
107
            QFileInfo fi(path + "/qml/ubuntu-terminal-app.qml");
606
108
            qDebug() << "Trying to load QML from:" << path + "/qml/ubuntu-terminal-app.qml";
607
109
            if (fi.exists()) {
608
110
                qmlfile = path +  "/qml/ubuntu-terminal-app.qml";
609
111
                break;
610
112
            }
611
113
        }
612
114
    }
613
115
    qDebug() << "using main qml file from:" << qmlfile;
614
116
    view.setSource(QUrl::fromLocalFile(qmlfile));
615
117
    view.show();
616
118
617
119
    return a.exec();
618
120
}
619
0
121
620
=== added directory 'src/app/qml'
621
=== renamed file 'Configs.qml' => 'src/app/qml/Configs.qml'
622
=== renamed file 'Terminal.qml' => 'src/app/qml/Terminal.qml'
623
=== renamed file 'avatar@8.png' => 'src/app/qml/avatar@8.png'
624
=== renamed directory 'config' => 'src/app/qml/config'
625
=== renamed directory 'extraPanel' => 'src/app/qml/extraPanel'
626
=== renamed file 'settings.png' => 'src/app/qml/settings.png'
627
=== renamed file 'terminal.qmlproject' => 'src/app/qml/terminal.qmlproject'
628
=== renamed file 'ubuntu-terminal-app.qml' => 'src/app/qml/ubuntu-terminal-app.qml'
629
=== added directory 'src/plugin'
630
=== added file 'src/plugin/CMakeLists.txt'
631
--- src/plugin/CMakeLists.txt	1970-01-01 00:00:00 +0000
632
+++ src/plugin/CMakeLists.txt	2014-05-06 21:50:22 +0000
633
@@ -0,0 +1,7 @@
634
1
include(FindPkgConfig)
635
2
find_package(Qt5Core)
636
3
find_package(Qt5Qml)
637
4
find_package(Qt5Quick)
638
5
find_package(Qt5Widgets)
639
6
640
7
add_subdirectory(konsole)
641
0
8
642
=== added directory 'src/plugin/konsole'
643
=== added file 'src/plugin/konsole/BlockArray.cpp'
644
--- src/plugin/konsole/BlockArray.cpp	1970-01-01 00:00:00 +0000
645
+++ src/plugin/konsole/BlockArray.cpp	2014-05-06 21:50:22 +0000
646
@@ -0,0 +1,377 @@
647
1
/*
648
2
    This file is part of Konsole, an X terminal.
649
3
    Copyright (C) 2000 by Stephan Kulow <coolo@kde.org>
650
4
651
5
    Rewritten for QT4 by e_k <e_k at users.sourceforge.net>, Copyright (C)2008
652
6
653
7
    This program is free software; you can redistribute it and/or modify
654
8
    it under the terms of the GNU General Public License as published by
655
9
    the Free Software Foundation; either version 2 of the License, or
656
10
    (at your option) any later version.
657
11
658
12
    This program is distributed in the hope that it will be useful,
659
13
    but WITHOUT ANY WARRANTY; without even the implied warranty of
660
14
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
661
15
    GNU General Public License for more details.
662
16
663
17
    You should have received a copy of the GNU General Public License
664
18
    along with this program; if not, write to the Free Software
665
19
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
666
20
    02110-1301  USA.
667
21
668
22
*/
669
23
670
24
// Own
671
25
#include "BlockArray.h"
672
26
673
27
#include <QtCore>
674
28
675
29
// System
676
30
#include <assert.h>
677
31
#include <sys/mman.h>
678
32
#include <sys/param.h>
679
33
#include <unistd.h>
680
34
#include <stdio.h>
681
35
682
36
683
37
static int blocksize = 0;
684
38
685
39
BlockArray::BlockArray()
686
40
        : size(0),
687
41
        current(size_t(-1)),
688
42
        index(size_t(-1)),
689
43
        lastmap(0),
690
44
        lastmap_index(size_t(-1)),
691
45
        lastblock(0), ion(-1),
692
46
        length(0)
693
47
{
694
48
    // lastmap_index = index = current = size_t(-1);
695
49
    if (blocksize == 0) {
696
50
        blocksize = ((sizeof(Block) / getpagesize()) + 1) * getpagesize();
697
51
    }
698
52
699
53
}
700
54
701
55
BlockArray::~BlockArray()
702
56
{
703
57
    setHistorySize(0);
704
58
    assert(!lastblock);
705
59
}
706
60
707
61
size_t BlockArray::append(Block * block)
708
62
{
709
63
    if (!size) {
710
64
        return size_t(-1);
711
65
    }
712
66
713
67
    ++current;
714
68
    if (current >= size) {
715
69
        current = 0;
716
70
    }
717
71
718
72
    int rc;
719
73
    rc = lseek(ion, current * blocksize, SEEK_SET);
720
74
    if (rc < 0) {
721
75
        perror("HistoryBuffer::add.seek");
722
76
        setHistorySize(0);
723
77
        return size_t(-1);
724
78
    }
725
79
    rc = write(ion, block, blocksize);
726
80
    if (rc < 0) {
727
81
        perror("HistoryBuffer::add.write");
728
82
        setHistorySize(0);
729
83
        return size_t(-1);
730
84
    }
731
85
732
86
    length++;
733
87
    if (length > size) {
734
88
        length = size;
735
89
    }
736
90
737
91
    ++index;
738
92
739
93
    delete block;
740
94
    return current;
741
95
}
742
96
743
97
size_t BlockArray::newBlock()
744
98
{
745
99
    if (!size) {
746
100
        return size_t(-1);
747
101
    }
748
102
    append(lastblock);
749
103
750
104
    lastblock = new Block();
751
105
    return index + 1;
752
106
}
753
107
754
108
Block * BlockArray::lastBlock() const
755
109
{
756
110
    return lastblock;
757
111
}
758
112
759
113
bool BlockArray::has(size_t i) const
760
114
{
761
115
    if (i == index + 1) {
762
116
        return true;
763
117
    }
764
118
765
119
    if (i > index) {
766
120
        return false;
767
121
    }
768
122
    if (index - i >= length) {
769
123
        return false;
770
124
    }
771
125
    return true;
772
126
}
773
127
774
128
const Block * BlockArray::at(size_t i)
775
129
{
776
130
    if (i == index + 1) {
777
131
        return lastblock;
778
132
    }
779
133
780
134
    if (i == lastmap_index) {
781
135
        return lastmap;
782
136
    }
783
137
784
138
    if (i > index) {
785
139
        qDebug() << "BlockArray::at() i > index\n";
786
140
        return 0;
787
141
    }
788
142
789
143
//     if (index - i >= length) {
790
144
//         kDebug(1211) << "BlockArray::at() index - i >= length\n";
791
145
//         return 0;
792
146
//     }
793
147
794
148
    size_t j = i; // (current - (index - i) + (index/size+1)*size) % size ;
795
149
796
150
    assert(j < size);
797
151
    unmap();
798
152
799
153
    Block * block = (Block *)mmap(0, blocksize, PROT_READ, MAP_PRIVATE, ion, j * blocksize);
800
154
801
155
    if (block == (Block *)-1) {
802
156
        perror("mmap");
803
157
        return 0;
804
158
    }
805
159
806
160
    lastmap = block;
807
161
    lastmap_index = i;
808
162
809
163
    return block;
810
164
}
811
165
812
166
void BlockArray::unmap()
813
167
{
814
168
    if (lastmap) {
815
169
        int res = munmap((char *)lastmap, blocksize);
816
170
        if (res < 0) {
817
171
            perror("munmap");
818
172
        }
819
173
    }
820
174
    lastmap = 0;
821
175
    lastmap_index = size_t(-1);
822
176
}
823
177
824
178
bool BlockArray::setSize(size_t newsize)
825
179
{
826
180
    return setHistorySize(newsize * 1024 / blocksize);
827
181
}
828
182
829
183
bool BlockArray::setHistorySize(size_t newsize)
830
184
{
831
185
//    kDebug(1211) << "setHistorySize " << size << " " << newsize;
832
186
833
187
    if (size == newsize) {
834
188
        return false;
835
189
    }
836
190
837
191
    unmap();
838
192
839
193
    if (!newsize) {
840
194
        delete lastblock;
841
195
        lastblock = 0;
842
196
        if (ion >= 0) {
843
197
            close(ion);
844
198
        }
845
199
        ion = -1;
846
200
        current = size_t(-1);
847
201
        return true;
848
202
    }
849
203
850
204
    if (!size) {
851
205
        FILE * tmp = tmpfile();
852
206
        if (!tmp) {
853
207
            perror("konsole: cannot open temp file.\n");
854
208
        } else {
855
209
            ion = dup(fileno(tmp));
856
210
            if (ion<0) {
857
211
                perror("konsole: cannot dup temp file.\n");
858
212
                fclose(tmp);
859
213
            }
860
214
        }
861
215
        if (ion < 0) {
862
216
            return false;
863
217
        }
864
218
865
219
        assert(!lastblock);
866
220
867
221
        lastblock = new Block();
868
222
        size = newsize;
869
223
        return false;
870
224
    }
871
225
872
226
    if (newsize > size) {
873
227
        increaseBuffer();
874
228
        size = newsize;
875
229
        return false;
876
230
    } else {
877
231
        decreaseBuffer(newsize);
878
232
        ftruncate(ion, length*blocksize);
879
233
        size = newsize;
880
234
881
235
        return true;
882
236
    }
883
237
}
884
238
885
239
void moveBlock(FILE * fion, int cursor, int newpos, char * buffer2)
886
240
{
887
241
    int res = fseek(fion, cursor * blocksize, SEEK_SET);
888
242
    if (res) {
889
243
        perror("fseek");
890
244
    }
891
245
    res = fread(buffer2, blocksize, 1, fion);
892
246
    if (res != 1) {
893
247
        perror("fread");
894
248
    }
895
249
896
250
    res = fseek(fion, newpos * blocksize, SEEK_SET);
897
251
    if (res) {
898
252
        perror("fseek");
899
253
    }
900
254
    res = fwrite(buffer2, blocksize, 1, fion);
901
255
    if (res != 1) {
902
256
        perror("fwrite");
903
257
    }
904
258
    //    printf("moving block %d to %d\n", cursor, newpos);
905
259
}
906
260
907
261
void BlockArray::decreaseBuffer(size_t newsize)
908
262
{
909
263
    if (index < newsize) { // still fits in whole
910
264
        return;
911
265
    }
912
266
913
267
    int offset = (current - (newsize - 1) + size) % size;
914
268
915
269
    if (!offset) {
916
270
        return;
917
271
    }
918
272
919
273
    // The Block constructor could do somthing in future...
920
274
    char * buffer1 = new char[blocksize];
921
275
922
276
    FILE * fion = fdopen(dup(ion), "w+b");
923
277
    if (!fion) {
924
278
        delete [] buffer1;
925
279
        perror("fdopen/dup");
926
280
        return;
927
281
    }
928
282
929
283
    int firstblock;
930
284
    if (current <= newsize) {
931
285
        firstblock = current + 1;
932
286
    } else {
933
287
        firstblock = 0;
934
288
    }
935
289
936
290
    size_t oldpos;
937
291
    for (size_t i = 0, cursor=firstblock; i < newsize; i++) {
938
292
        oldpos = (size + cursor + offset) % size;
939
293
        moveBlock(fion, oldpos, cursor, buffer1);
940
294
        if (oldpos < newsize) {
941
295
            cursor = oldpos;
942
296
        } else {
943
297
            cursor++;
944
298
        }
945
299
    }
946
300
947
301
    current = newsize - 1;
948
302
    length = newsize;
949
303
950
304
    delete [] buffer1;
951
305
952
306
    fclose(fion);
953
307
954
308
}
955
309
956
310
void BlockArray::increaseBuffer()
957
311
{
958
312
    if (index < size) { // not even wrapped once
959
313
        return;
960
314
    }
961
315
962
316
    int offset = (current + size + 1) % size;
963
317
    if (!offset) { // no moving needed
964
318
        return;
965
319
    }
966
320
967
321
    // The Block constructor could do somthing in future...
968
322
    char * buffer1 = new char[blocksize];
969
323
    char * buffer2 = new char[blocksize];
970
324
971
325
    int runs = 1;
972
326
    int bpr = size; // blocks per run
973
327
974
328
    if (size % offset == 0) {
975
329
        bpr = size / offset;
976
330
        runs = offset;
977
331
    }
978
332
979
333
    FILE * fion = fdopen(dup(ion), "w+b");
980
334
    if (!fion) {
981
335
        perror("fdopen/dup");
982
336
        delete [] buffer1;
983
337
        delete [] buffer2;
984
338
        return;
985
339
    }
986
340
987
341
    int res;
988
342
    for (int i = 0; i < runs; i++) {
989
343
        // free one block in chain
990
344
        int firstblock = (offset + i) % size;
991
345
        res = fseek(fion, firstblock * blocksize, SEEK_SET);
992
346
        if (res) {
993
347
            perror("fseek");
994
348
        }
995
349
        res = fread(buffer1, blocksize, 1, fion);
996
350
        if (res != 1) {
997
351
            perror("fread");
998
352
        }
999
353
        int newpos = 0;
1000
354
        for (int j = 1, cursor=firstblock; j < bpr; j++) {
1001
355
            cursor = (cursor + offset) % size;
1002
356
            newpos = (cursor - offset + size) % size;
1003
357
            moveBlock(fion, cursor, newpos, buffer2);
1004
358
        }
1005
359
        res = fseek(fion, i * blocksize, SEEK_SET);
1006
360
        if (res) {
1007
361
            perror("fseek");
1008
362
        }
1009
363
        res = fwrite(buffer1, blocksize, 1, fion);
1010
364
        if (res != 1) {
1011
365
            perror("fwrite");
1012
366
        }
1013
367
    }
1014
368
    current = size - 1;
1015
369
    length = size;
1016
370
1017
371
    delete [] buffer1;
1018
372
    delete [] buffer2;
1019
373
1020
374
    fclose(fion);
1021
375
1022
376
}
1023
377
1024
0
378
1025
=== added file 'src/plugin/konsole/BlockArray.h'
1026
--- src/plugin/konsole/BlockArray.h	1970-01-01 00:00:00 +0000
1027
+++ src/plugin/konsole/BlockArray.h	2014-05-06 21:50:22 +0000
1028
@@ -0,0 +1,126 @@
1029
1
/*
1030
2
    This file is part of Konsole, an X terminal.
1031
3
    Copyright (C) 2000 by Stephan Kulow <coolo@kde.org>
1032
4
1033
5
    Rewritten for QT4 by e_k <e_k at users.sourceforge.net>, Copyright (C)2008
1034
6
1035
7
    This program is free software; you can redistribute it and/or modify
1036
8
    it under the terms of the GNU General Public License as published by
1037
9
    the Free Software Foundation; either version 2 of the License, or
1038
10
    (at your option) any later version.
1039
11
1040
12
    This program is distributed in the hope that it will be useful,
1041
13
    but WITHOUT ANY WARRANTY; without even the implied warranty of
1042
14
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1043
15
    GNU General Public License for more details.
1044
16
1045
17
    You should have received a copy of the GNU General Public License
1046
18
    along with this program; if not, write to the Free Software
1047
19
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
1048
20
    02110-1301  USA.
1049
21
*/
1050
22
1051
23
#ifndef BLOCKARRAY_H
1052
24
#define BLOCKARRAY_H
1053
25
1054
26
#include <unistd.h>
1055
27
1056
28
//#error Do not use in KDE 2.1
1057
29
1058
30
#define BlockSize (1 << 12)
1059
31
#define ENTRIES   ((BlockSize - sizeof(size_t) ) / sizeof(unsigned char))
1060
32
1061
33
struct Block {
1062
34
    Block() {
1063
35
        size = 0;
1064
36
    }
1065
37
    unsigned char data[ENTRIES];
1066
38
    size_t size;
1067
39
};
1068
40
1069
41
// ///////////////////////////////////////////////////////
1070
42
1071
43
class BlockArray {
1072
44
public:
1073
45
    /**
1074
46
    * Creates a history file for holding
1075
47
    * maximal size blocks. If more blocks
1076
48
    * are requested, then it drops earlier
1077
49
    * added ones.
1078
50
    */
1079
51
    BlockArray();
1080
52
1081
53
    /// destructor
1082
54
    ~BlockArray();
1083
55
1084
56
    /**
1085
57
    * adds the Block at the end of history.
1086
58
    * This may drop other blocks.
1087
59
    *
1088
60
    * The ownership on the block is transfered.
1089
61
    * An unique index number is returned for accessing
1090
62
    * it later (if not yet dropped then)
1091
63
    *
1092
64
    * Note, that the block may be dropped completely
1093
65
    * if history is turned off.
1094
66
    */
1095
67
    size_t append(Block * block);
1096
68
1097
69
    /**
1098
70
    * gets the block at the index. Function may return
1099
71
    * 0 if the block isn't available any more.
1100
72
    *
1101
73
    * The returned block is strictly readonly as only
1102
74
    * maped in memory - and will be invalid on the next
1103
75
    * operation on this class.
1104
76
    */
1105
77
    const Block * at(size_t index);
1106
78
1107
79
    /**
1108
80
    * reorders blocks as needed. If newsize is null,
1109
81
    * the history is emptied completely. The indices
1110
82
    * returned on append won't change their semantic,
1111
83
    * but they may not be valid after this call.
1112
84
    */
1113
85
    bool setHistorySize(size_t newsize);
1114
86
1115
87
    size_t newBlock();
1116
88
1117
89
    Block * lastBlock() const;
1118
90
1119
91
    /**
1120
92
    * Convenient function to set the size in KBytes
1121
93
    * instead of blocks
1122
94
    */
1123
95
    bool setSize(size_t newsize);
1124
96
1125
97
    size_t len() const {
1126
98
        return length;
1127
99
    }
1128
100
1129
101
    bool has(size_t index) const;
1130
102
1131
103
    size_t getCurrent() const {
1132
104
        return current;
1133
105
    }
1134
106
1135
107
private:
1136
108
    void unmap();
1137
109
    void increaseBuffer();
1138
110
    void decreaseBuffer(size_t newsize);
1139
111
1140
112
    size_t size;
1141
113
    // current always shows to the last inserted block
1142
114
    size_t current;
1143
115
    size_t index;
1144
116
1145
117
    Block * lastmap;
1146
118
    size_t lastmap_index;
1147
119
    Block * lastblock;
1148
120
1149
121
    int ion;
1150
122
    size_t length;
1151
123
1152
124
};
1153
125
1154
126
#endif
1155
0
127
1156
=== added file 'src/plugin/konsole/CMakeLists.txt'
1157
--- src/plugin/konsole/CMakeLists.txt	1970-01-01 00:00:00 +0000
1158
+++ src/plugin/konsole/CMakeLists.txt	2014-05-06 21:50:22 +0000
1159
@@ -0,0 +1,93 @@
1160
1
include_directories(
1161
2
    ${CMAKE_CURRENT_SOURCE_DIR}
1162
3
)
1163
4
1164
5
set(PLUGIN_DIR org/kde/konsole)
1165
6
add_definitions(-DHAVE_POSIX_OPENPT -DHAVE_SYS_TIME_H -DHAVE_UPDWTMPX)
1166
7
add_definitions(-DQ_WS_UBUNTU)
1167
8
1168
9
set(konsole_SRCS
1169
10
    BlockArray.cpp
1170
11
    BlockArray.h
1171
12
    CharacterColor.h
1172
13
    Character.h
1173
14
    ColorScheme.cpp
1174
15
    ColorScheme.h
1175
16
    ColorTables.h
1176
17
    DefaultTranslatorText.h
1177
18
    Emulation.cpp
1178
19
    Emulation.h
1179
20
    ExtendedDefaultTranslator.h
1180
21
    Filter.cpp
1181
22
    Filter.h
1182
23
    History.cpp
1183
24
    History.h
1184
25
    KeyboardTranslator.cpp
1185
26
    KeyboardTranslator.h
1186
27
    konsole_wcwidth.cpp
1187
28
    konsole_wcwidth.h
1188
29
    kprocess.cpp
1189
30
    kprocess.h
1190
31
    kpty.cpp
1191
32
    kptydevice.cpp
1192
33
    kptydevice.h
1193
34
    kpty.h
1194
35
    kpty_p.h
1195
36
    kptyprocess.cpp
1196
37
    kptyprocess.h
1197
38
    ksession.cpp
1198
39
    ksession.h
1199
40
    LineFont.h
1200
41
    plugin.cpp
1201
42
    plugin.h
1202
43
    Pty.cpp
1203
44
    Pty.h
1204
45
    Screen.cpp
1205
46
    Screen.h
1206
47
    ScreenWindow.cpp
1207
48
    ScreenWindow.h
1208
49
    Session.cpp
1209
50
    Session.h
1210
51
    ShellCommand.cpp
1211
52
    ShellCommand.h
1212
53
    TerminalCharacterDecoder.cpp
1213
54
    TerminalCharacterDecoder.h
1214
55
    TerminalDisplay.cpp
1215
56
    TerminalDisplay.h
1216
57
    tools.cpp
1217
58
    tools.h
1218
59
    Vt102Emulation.cpp
1219
60
    Vt102Emulation.h
1220
61
)
1221
62
1222
63
add_library(kdekonsole MODULE
1223
64
    ${konsole_SRCS}
1224
65
)
1225
66
1226
67
qt5_use_modules(kdekonsole Gui Qml Quick Widgets)
1227
68
1228
69
# Copy the plugin, the qmldir file and other assets to the build dir for running in QtCreator
1229
70
if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
1230
71
    add_custom_target(konsole-qmldir ALL
1231
72
        COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/qmldir ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
1232
73
        DEPENDS ${QMLFILES}
1233
74
    )
1234
75
    add_custom_target(konsole-layouts-schemes ALL
1235
76
        COMMAND cp -a ${CMAKE_CURRENT_SOURCE_DIR}/assets/color-schemes ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
1236
77
        COMMAND cp -a ${CMAKE_CURRENT_SOURCE_DIR}/assets/kb-layouts ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
1237
78
        DEPENDS ${QMLFILES}
1238
79
    )
1239
80
    add_custom_command(TARGET kdekonsole POST_BUILD
1240
81
        COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
1241
82
        COMMENT "Creating plugin directory layout in the build dir"
1242
83
        COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:kdekonsole> ${CMAKE_CURRENT_BINARY_DIR}/../${PLUGIN_DIR}
1243
84
        COMMENT "Copying to output directory"
1244
85
    )
1245
86
endif(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
1246
87
1247
88
1248
89
install(TARGETS kdekonsole DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN_DIR})
1249
90
install(FILES qmldir DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN_DIR})
1250
91
install(DIRECTORY assets/color-schemes DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN_DIR})
1251
92
install(DIRECTORY assets/kb-layouts DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN_DIR})
1252
93
1253
0
94
1254
=== added file 'src/plugin/konsole/Character.h'
1255
--- src/plugin/konsole/Character.h	1970-01-01 00:00:00 +0000
1256
+++ src/plugin/konsole/Character.h	2014-05-06 21:50:22 +0000
1257
@@ -0,0 +1,221 @@
1258
1
/*
1259
2
    This file is part of Konsole, KDE's terminal.
1260
3
    
1261
4
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
1262
5
    Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
1263
6
1264
7
    This program is free software; you can redistribute it and/or modify
1265
8
    it under the terms of the GNU General Public License as published by
1266
9
    the Free Software Foundation; either version 2 of the License, or
1267
10
    (at your option) any later version.
1268
11
1269
12
    This program is distributed in the hope that it will be useful,
1270
13
    but WITHOUT ANY WARRANTY; without even the implied warranty of
1271
14
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1272
15
    GNU General Public License for more details.
1273
16
1274
17
    You should have received a copy of the GNU General Public License
1275
18
    along with this program; if not, write to the Free Software
1276
19
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
1277
20
    02110-1301  USA.
1278
21
*/
1279
22
1280
23
#ifndef CHARACTER_H
1281
24
#define CHARACTER_H
1282
25
1283
26
// Qt
1284
27
#include <QtCore/QHash>
1285
28
1286
29
// Local
1287
30
#include "CharacterColor.h"
1288
31
1289
32
typedef unsigned char LineProperty;
1290
33
1291
34
static const int LINE_DEFAULT        = 0;
1292
35
static const int LINE_WRAPPED          = (1 << 0);
1293
36
static const int LINE_DOUBLEWIDTH      = (1 << 1);
1294
37
static const int LINE_DOUBLEHEIGHT    = (1 << 2);
1295
38
1296
39
#define DEFAULT_RENDITION  0
1297
40
#define RE_BOLD            (1 << 0)
1298
41
#define RE_BLINK           (1 << 1)
1299
42
#define RE_UNDERLINE       (1 << 2)
1300
43
#define RE_REVERSE         (1 << 3) // Screen only
1301
44
#define RE_INTENSIVE       (1 << 3) // Widget only
1302
45
#define RE_CURSOR          (1 << 4)
1303
46
#define RE_EXTENDED_CHAR   (1 << 5)
1304
47
1305
48
/**
1306
49
 * A single character in the terminal which consists of a unicode character
1307
50
 * value, foreground and background colors and a set of rendition attributes
1308
51
 * which specify how it should be drawn.
1309
52
 */
1310
53
class Character
1311
54
{
1312
55
public:
1313
56
  /** 
1314
57
   * Constructs a new character.
1315
58
   *
1316
59
   * @param _c The unicode character value of this character.
1317
60
   * @param _f The foreground color used to draw the character.
1318
61
   * @param _b The color used to draw the character's background.
1319
62
   * @param _r A set of rendition flags which specify how this character is to be drawn.
1320
63
   */
1321
64
  inline Character(quint16 _c = ' ',
1322
65
            CharacterColor  _f = CharacterColor(COLOR_SPACE_DEFAULT,DEFAULT_FORE_COLOR),
1323
66
            CharacterColor  _b = CharacterColor(COLOR_SPACE_DEFAULT,DEFAULT_BACK_COLOR),
1324
67
            quint8  _r = DEFAULT_RENDITION)
1325
68
       : character(_c), rendition(_r), foregroundColor(_f), backgroundColor(_b) {}
1326
69
1327
70
  union
1328
71
  {
1329
72
    /** The unicode character value for this character. */
1330
73
    quint16 character;
1331
74
    /** 
1332
75
     * Experimental addition which allows a single Character instance to contain more than
1333
76
     * one unicode character.
1334
77
     *
1335
78
     * charSequence is a hash code which can be used to look up the unicode
1336
79
     * character sequence in the ExtendedCharTable used to create the sequence.
1337
80
     */
1338
81
    quint16 charSequence; 
1339
82
  };
1340
83
1341
84
  /** A combination of RENDITION flags which specify options for drawing the character. */
1342
85
  quint8  rendition;
1343
86
1344
87
  /** The foreground color used to draw this character. */
1345
88
  CharacterColor  foregroundColor; 
1346
89
  /** The color used to draw this character's background. */
1347
90
  CharacterColor  backgroundColor;
1348
91
1349
92
  /** 
1350
93
   * Returns true if this character has a transparent background when
1351
94
   * it is drawn with the specified @p palette.
1352
95
   */
1353
96
  bool   isTransparent(const ColorEntry* palette) const;
1354
97
  /**
1355
98
   * Returns true if this character should always be drawn in bold when
1356
99
   * it is drawn with the specified @p palette, independent of whether
1357
100
   * or not the character has the RE_BOLD rendition flag. 
1358
101
   */
1359
102
  ColorEntry::FontWeight fontWeight(const ColorEntry* base) const;
1360
103
  
1361
104
  /** 
1362
105
   * returns true if the format (color, rendition flag) of the compared characters is equal
1363
106
   */
1364
107
  bool equalsFormat(const Character &other) const;
1365
108
1366
109
  /** 
1367
110
   * Compares two characters and returns true if they have the same unicode character value,
1368
111
   * rendition and colors.
1369
112
   */
1370
113
  friend bool operator == (const Character& a, const Character& b);
1371
114
  /**
1372
115
   * Compares two characters and returns true if they have different unicode character values,
1373
116
   * renditions or colors.
1374
117
   */
1375
118
  friend bool operator != (const Character& a, const Character& b);
1376
119
};
1377
120
1378
121
inline bool operator == (const Character& a, const Character& b)
1379
122
{ 
1380
123
  return a.character == b.character && 
1381
124
         a.rendition == b.rendition && 
1382
125
         a.foregroundColor == b.foregroundColor && 
1383
126
         a.backgroundColor == b.backgroundColor;
1384
127
}
1385
128
1386
129
inline bool operator != (const Character& a, const Character& b)
1387
130
{
1388
131
  return    a.character != b.character || 
1389
132
            a.rendition != b.rendition || 
1390
133
            a.foregroundColor != b.foregroundColor || 
1391
134
            a.backgroundColor != b.backgroundColor;
1392
135
}
1393
136
1394
137
inline bool Character::isTransparent(const ColorEntry* base) const
1395
138
{
1396
139
  return ((backgroundColor._colorSpace == COLOR_SPACE_DEFAULT) && 
1397
140
          base[backgroundColor._u+0+(backgroundColor._v?BASE_COLORS:0)].transparent)
1398
141
      || ((backgroundColor._colorSpace == COLOR_SPACE_SYSTEM) && 
1399
142
          base[backgroundColor._u+2+(backgroundColor._v?BASE_COLORS:0)].transparent);
1400
143
}
1401
144
1402
145
inline bool Character::equalsFormat(const Character& other) const
1403
146
{
1404
147
  return 
1405
148
    backgroundColor==other.backgroundColor &&
1406
149
    foregroundColor==other.foregroundColor &&
1407
150
    rendition==other.rendition;
1408
151
}	
1409
152
1410
153
inline ColorEntry::FontWeight Character::fontWeight(const ColorEntry* base) const
1411
154
{
1412
155
    if (backgroundColor._colorSpace == COLOR_SPACE_DEFAULT)
1413
156
        return base[backgroundColor._u+0+(backgroundColor._v?BASE_COLORS:0)].fontWeight;
1414
157
    else if (backgroundColor._colorSpace == COLOR_SPACE_SYSTEM)
1415
158
        return base[backgroundColor._u+2+(backgroundColor._v?BASE_COLORS:0)].fontWeight;
1416
159
    else
1417
160
        return ColorEntry::UseCurrentFormat;
1418
161
}
1419
162
1420
163
extern unsigned short vt100_graphics[32];
1421
164
1422
165
1423
166
/**
1424
167
 * A table which stores sequences of unicode characters, referenced
1425
168
 * by hash keys.  The hash key itself is the same size as a unicode
1426
169
 * character ( ushort ) so that it can occupy the same space in
1427
170
 * a structure.
1428
171
 */
1429
172
class ExtendedCharTable
1430
173
{
1431
174
public:
1432
175
    /** Constructs a new character table. */
1433
176
    ExtendedCharTable();
1434
177
    ~ExtendedCharTable();
1435
178
1436
179
    /**
1437
180
     * Adds a sequences of unicode characters to the table and returns
1438
181
     * a hash code which can be used later to look up the sequence
1439
182
     * using lookupExtendedChar()
1440
183
     *
1441
184
     * If the same sequence already exists in the table, the hash
1442
185
     * of the existing sequence will be returned.
1443
186
     *
1444
187
     * @param unicodePoints An array of unicode character points
1445
188
     * @param length Length of @p unicodePoints
1446
189
     */
1447
190
    ushort createExtendedChar(ushort* unicodePoints , ushort length);
1448
191
    /**
1449
192
     * Looks up and returns a pointer to a sequence of unicode characters
1450
193
     * which was added to the table using createExtendedChar().
1451
194
     *
1452
195
     * @param hash The hash key returned by createExtendedChar()
1453
196
     * @param length This variable is set to the length of the 
1454
197
     * character sequence.
1455
198
     *
1456
199
     * @return A unicode character sequence of size @p length.
1457
200
     */
1458
201
    ushort* lookupExtendedChar(ushort hash , ushort& length) const;
1459
202
1460
203
    /** The global ExtendedCharTable instance. */
1461
204
    static ExtendedCharTable instance;
1462
205
private:
1463
206
    // calculates the hash key of a sequence of unicode points of size 'length'
1464
207
    ushort extendedCharHash(ushort* unicodePoints , ushort length) const;
1465
208
    // tests whether the entry in the table specified by 'hash' matches the 
1466
209
    // character sequence 'unicodePoints' of size 'length'
1467
210
    bool extendedCharMatch(ushort hash , ushort* unicodePoints , ushort length) const;
1468
211
    // internal, maps hash keys to character sequence buffers.  The first ushort
1469
212
    // in each value is the length of the buffer, followed by the ushorts in the buffer
1470
213
    // themselves.
1471
214
    QHash<ushort,ushort*> extendedCharTable;
1472
215
};
1473
216
1474
217
1475
218
Q_DECLARE_TYPEINFO(Character, Q_MOVABLE_TYPE);
1476
219
1477
220
#endif // CHARACTER_H
1478
221
1479
0
222
1480
=== added file 'src/plugin/konsole/CharacterColor.h'
1481
--- src/plugin/konsole/CharacterColor.h	1970-01-01 00:00:00 +0000
1482
+++ src/plugin/konsole/CharacterColor.h	2014-05-06 21:50:22 +0000
1483
@@ -0,0 +1,294 @@
1484
1
/*
1485
2
    This file is part of Konsole, KDE's terminal.
1486
3
    
1487
4
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
1488
5
    Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
1489
6
1490
7
    This program is free software; you can redistribute it and/or modify
1491
8
    it under the terms of the GNU General Public License as published by
1492
9
    the Free Software Foundation; either version 2 of the License, or
1493
10
    (at your option) any later version.
1494
11
1495
12
    This program is distributed in the hope that it will be useful,
1496
13
    but WITHOUT ANY WARRANTY; without even the implied warranty of
1497
14
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1498
15
    GNU General Public License for more details.
1499
16
1500
17
    You should have received a copy of the GNU General Public License
1501
18
    along with this program; if not, write to the Free Software
1502
19
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
1503
20
    02110-1301  USA.
1504
21
*/
1505
22
1506
23
#ifndef CHARACTERCOLOR_H
1507
24
#define CHARACTERCOLOR_H
1508
25
1509
26
// Qt
1510
27
#include <QtGui/QColor>
1511
28
1512
29
//#include <kdemacros.h>
1513
30
#define KDE_NO_EXPORT
1514
31
1515
32
/** 
1516
33
 * An entry in a terminal display's color palette. 
1517
34
 *
1518
35
 * A color palette is an array of 16 ColorEntry instances which map
1519
36
 * system color indexes (from 0 to 15) into actual colors.
1520
37
 *
1521
38
 * Each entry can be set as bold, in which case any text
1522
39
 * drawn using the color should be drawn in bold.  
1523
40
 *
1524
41
 * Each entry can also be transparent, in which case the terminal
1525
42
 * display should avoid drawing the background for any characters
1526
43
 * using the entry as a background.
1527
44
 */
1528
45
class ColorEntry
1529
46
{
1530
47
public:
1531
48
  /** Specifies the weight to use when drawing text with this color. */
1532
49
  enum FontWeight 
1533
50
  {
1534
51
    /** Always draw text in this color with a bold weight. */
1535
52
    Bold,
1536
53
    /** Always draw text in this color with a normal weight. */
1537
54
    Normal,
1538
55
    /** 
1539
56
     * Use the current font weight set by the terminal application.  
1540
57
     * This is the default behavior.
1541
58
     */
1542
59
    UseCurrentFormat
1543
60
  };
1544
61
1545
62
  /** 
1546
63
   * Constructs a new color palette entry.
1547
64
   *
1548
65
   * @param c The color value for this entry.
1549
66
   * @param tr Specifies that the color should be transparent when used as a background color.
1550
67
   * @param weight Specifies the font weight to use when drawing text with this color. 
1551
68
   */
1552
69
  ColorEntry(QColor c, bool tr, FontWeight weight = UseCurrentFormat) 
1553
70
          : color(c), transparent(tr), fontWeight(weight) {}
1554
71
1555
72
  /**
1556
73
   * Constructs a new color palette entry with an undefined color, and
1557
74
   * with the transparent and bold flags set to false.
1558
75
   */ 
1559
76
  ColorEntry() : transparent(false), fontWeight(UseCurrentFormat) {} 
1560
77
 
1561
78
  /**
1562
79
   * Sets the color, transparency and boldness of this color to those of @p rhs.
1563
80
   */ 
1564
81
  void operator=(const ColorEntry& rhs) 
1565
82
  { 
1566
83
       color = rhs.color; 
1567
84
       transparent = rhs.transparent; 
1568
85
       fontWeight = rhs.fontWeight; 
1569
86
  }
1570
87
1571
88
  /** The color value of this entry for display. */
1572
89
  QColor color;
1573
90
1574
91
  /** 
1575
92
   * If true character backgrounds using this color should be transparent. 
1576
93
   * This is not applicable when the color is used to render text.
1577
94
   */
1578
95
  bool   transparent;
1579
96
  /**
1580
97
   * Specifies the font weight to use when drawing text with this color. 
1581
98
   * This is not applicable when the color is used to draw a character's background.
1582
99
   */
1583
100
  FontWeight fontWeight;        
1584
101
};
1585
102
1586
103
1587
104
// Attributed Character Representations ///////////////////////////////
1588
105
1589
106
// Colors
1590
107
1591
108
#define BASE_COLORS   (2+8)
1592
109
#define INTENSITIES   2
1593
110
#define TABLE_COLORS  (INTENSITIES*BASE_COLORS)
1594
111
1595
112
#define DEFAULT_FORE_COLOR 0
1596
113
#define DEFAULT_BACK_COLOR 1
1597
114
1598
115
//a standard set of colors using black text on a white background.
1599
116
//defined in TerminalDisplay.cpp
1600
117
1601
118
extern const ColorEntry base_color_table[TABLE_COLORS] KDE_NO_EXPORT;
1602
119
1603
120
/* CharacterColor is a union of the various color spaces.
1604
121
1605
122
   Assignment is as follows:
1606
123
1607
124
   Type  - Space        - Values
1608
125
1609
126
   0     - Undefined   - u:  0,      v:0        w:0
1610
127
   1     - Default     - u:  0..1    v:intense  w:0
1611
128
   2     - System      - u:  0..7    v:intense  w:0
1612
129
   3     - Index(256)  - u: 16..255  v:0        w:0
1613
130
   4     - RGB         - u:  0..255  v:0..256   w:0..256
1614
131
1615
132
   Default colour space has two separate colours, namely
1616
133
   default foreground and default background colour.
1617
134
*/
1618
135
1619
136
#define COLOR_SPACE_UNDEFINED   0
1620
137
#define COLOR_SPACE_DEFAULT     1
1621
138
#define COLOR_SPACE_SYSTEM      2
1622
139
#define COLOR_SPACE_256         3
1623
140
#define COLOR_SPACE_RGB         4
1624
141
1625
142
/**
1626
143
 * Describes the color of a single character in the terminal.
1627
144
 */
1628
145
class CharacterColor
1629
146
{
1630
147
    friend class Character;
1631
148
1632
149
public:
1633
150
  /** Constructs a new CharacterColor whoose color and color space are undefined. */
1634
151
  CharacterColor() 
1635
152
      : _colorSpace(COLOR_SPACE_UNDEFINED), 
1636
153
        _u(0), 
1637
154
        _v(0), 
1638
155
        _w(0) 
1639
156
  {}
1640
157
1641
158
  /** 
1642
159
   * Constructs a new CharacterColor using the specified @p colorSpace and with 
1643
160
   * color value @p co
1644
161
   *
1645
162
   * The meaning of @p co depends on the @p colorSpace used.
1646
163
   *
1647
164
   * TODO : Document how @p co relates to @p colorSpace
1648
165
   *
1649
166
   * TODO : Add documentation about available color spaces.
1650
167
   */
1651
168
  CharacterColor(quint8 colorSpace, int co) 
1652
169
      : _colorSpace(colorSpace), 
1653
170
        _u(0), 
1654
171
        _v(0), 
1655
172
        _w(0)
1656
173
  {
1657
174
    switch (colorSpace)
1658
175
    {
1659
176
        case COLOR_SPACE_DEFAULT:
1660
177
            _u = co & 1;
1661
178
            break;
1662
179
        case COLOR_SPACE_SYSTEM:
1663
180
            _u = co & 7;
1664
181
            _v = (co >> 3) & 1;
1665
182
            break;
1666
183
        case COLOR_SPACE_256:  
1667
184
            _u = co & 255;
1668
185
            break;
1669
186
        case COLOR_SPACE_RGB:
1670
187
            _u = co >> 16;
1671
188
            _v = co >> 8;
1672
189
            _w = co;
1673
190
            break;
1674
191
        default:
1675
192
            _colorSpace = COLOR_SPACE_UNDEFINED;
1676
193
    }
1677
194
  }
1678
195
1679
196
  /** 
1680
197
   * Returns true if this character color entry is valid.
1681
198
   */
1682
199
  bool isValid() 
1683
200
  {
1684
201
        return _colorSpace != COLOR_SPACE_UNDEFINED;
1685
202
  }
1686
203
    
1687
204
  /** 
1688
205
   * Toggles the value of this color between a normal system color and the corresponding intensive
1689
206
   * system color.
1690
207
   * 
1691
208
   * This is only applicable if the color is using the COLOR_SPACE_DEFAULT or COLOR_SPACE_SYSTEM
1692
209
   * color spaces.
1693
210
   */
1694
211
  void toggleIntensive();
1695
212
1696
213
  /** 
1697
214
   * Returns the color within the specified color @p palette
1698
215
   *
1699
216
   * The @p palette is only used if this color is one of the 16 system colors, otherwise
1700
217
   * it is ignored.
1701
218
   */
1702
219
  QColor color(const ColorEntry* palette) const;
1703
220
 
1704
221
  /** 
1705
222
   * Compares two colors and returns true if they represent the same color value and
1706
223
   * use the same color space.
1707
224
   */
1708
225
  friend bool operator == (const CharacterColor& a, const CharacterColor& b);
1709
226
  /**
1710
227
   * Compares two colors and returns true if they represent different color values
1711
228
   * or use different color spaces.
1712
229
   */
1713
230
  friend bool operator != (const CharacterColor& a, const CharacterColor& b);
1714
231
1715
232
private:
1716
233
  quint8 _colorSpace;
1717
234
1718
235
  // bytes storing the character color 
1719
236
  quint8 _u; 
1720
237
  quint8 _v; 
1721
238
  quint8 _w; 
1722
239
};
1723
240
1724
241
inline bool operator == (const CharacterColor& a, const CharacterColor& b)
1725
242
{ 
1726
243
    return     a._colorSpace == b._colorSpace &&
1727
244
            a._u == b._u &&
1728
245
            a._v == b._v &&
1729
246
            a._w == b._w;
1730
247
}
1731
248
inline bool operator != (const CharacterColor& a, const CharacterColor& b)
1732
249
{
1733
250
    return !operator==(a,b);
1734
251
}
1735
252
1736
253
inline const QColor color256(quint8 u, const ColorEntry* base)
1737
254
{
1738
255
  //   0.. 16: system colors
1739
256
  if (u <   8) return base[u+2            ].color; u -= 8;
1740
257
  if (u <   8) return base[u+2+BASE_COLORS].color; u -= 8;
1741
258
1742
259
  //  16..231: 6x6x6 rgb color cube
1743
260
  if (u < 216) return QColor(((u/36)%6) ? (40*((u/36)%6)+55) : 0,
1744
261
                             ((u/ 6)%6) ? (40*((u/ 6)%6)+55) : 0,
1745
262
                             ((u/ 1)%6) ? (40*((u/ 1)%6)+55) : 0); u -= 216;
1746
263
  
1747
264
  // 232..255: gray, leaving out black and white
1748
265
  int gray = u*10+8; return QColor(gray,gray,gray);
1749
266
}
1750
267
1751
268
inline QColor CharacterColor::color(const ColorEntry* base) const
1752
269
{
1753
270
  switch (_colorSpace)
1754
271
  {
1755
272
    case COLOR_SPACE_DEFAULT: return base[_u+0+(_v?BASE_COLORS:0)].color;
1756
273
    case COLOR_SPACE_SYSTEM: return base[_u+2+(_v?BASE_COLORS:0)].color;
1757
274
    case COLOR_SPACE_256: return color256(_u,base);
1758
275
    case COLOR_SPACE_RGB: return QColor(_u,_v,_w);
1759
276
    case COLOR_SPACE_UNDEFINED: return QColor();
1760
277
  }
1761
278
1762
279
  Q_ASSERT(false); // invalid color space
1763
280
1764
281
  return QColor();
1765
282
}
1766
283
1767
284
inline void CharacterColor::toggleIntensive()
1768
285
{
1769
286
  if (_colorSpace == COLOR_SPACE_SYSTEM || _colorSpace == COLOR_SPACE_DEFAULT)
1770
287
  {
1771
288
    _v = !_v;
1772
289
  }
1773
290
}
1774
291
1775
292
1776
293
#endif // CHARACTERCOLOR_H
1777
294
1778
0
295
1779
=== added file 'src/plugin/konsole/ColorScheme.cpp'
1780
--- src/plugin/konsole/ColorScheme.cpp	1970-01-01 00:00:00 +0000
1781
+++ src/plugin/konsole/ColorScheme.cpp	2014-05-06 21:50:22 +0000
1782
@@ -0,0 +1,774 @@
1783
1
/*
1784
2
    This source file is part of Konsole, a terminal emulator.
1785
3
1786
4
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
1787
5
1788
6
    This program is free software; you can redistribute it and/or modify
1789
7
    it under the terms of the GNU General Public License as published by
1790
8
    the Free Software Foundation; either version 2 of the License, or
1791
9
    (at your option) any later version.
1792
10
1793
11
    This program is distributed in the hope that it will be useful,
1794
12
    but WITHOUT ANY WARRANTY; without even the implied warranty of
1795
13
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1796
14
    GNU General Public License for more details.
1797
15
1798
16
    You should have received a copy of the GNU General Public License
1799
17
    along with this program; if not, write to the Free Software
1800
18
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
1801
19
    02110-1301  USA.
1802
20
*/
1803
21
1804
22
// Own
1805
23
#include "ColorScheme.h"
1806
24
#include "tools.h"
1807
25
1808
26
// Qt
1809
27
#include <QtGui/QBrush>
1810
28
#include <QtCore/QFile>
1811
29
#include <QtCore/QFileInfo>
1812
30
#include <QtDebug>
1813
31
#include <QSettings>
1814
32
#include <QDir>
1815
33
1816
34
1817
35
// KDE
1818
36
//#include <KColorScheme>
1819
37
//#include <KConfig>
1820
38
//#include <KLocale>
1821
39
//#include <KDebug>
1822
40
//#include <KConfigGroup>
1823
41
//#include <KStandardDirs>
1824
42
1825
43
1826
44
const ColorEntry ColorScheme::defaultTable[TABLE_COLORS] =
1827
45
 // The following are almost IBM standard color codes, with some slight
1828
46
 // gamma correction for the dim colors to compensate for bright X screens.
1829
47
 // It contains the 8 ansiterm/xterm colors in 2 intensities.
1830
48
{
1831
49
    ColorEntry( QColor(0x00,0x00,0x00), 0), ColorEntry(
1832
50
QColor(0xFF,0xFF,0xFF), 1), // Dfore, Dback
1833
51
    ColorEntry( QColor(0x00,0x00,0x00), 0), ColorEntry(
1834
52
QColor(0xB2,0x18,0x18), 0), // Black, Red
1835
53
    ColorEntry( QColor(0x18,0xB2,0x18), 0), ColorEntry(
1836
54
QColor(0xB2,0x68,0x18), 0), // Green, Yellow
1837
55
    ColorEntry( QColor(0x18,0x18,0xB2), 0), ColorEntry(
1838
56
QColor(0xB2,0x18,0xB2), 0), // Blue, Magenta
1839
57
    ColorEntry( QColor(0x18,0xB2,0xB2), 0), ColorEntry(
1840
58
QColor(0xB2,0xB2,0xB2), 0), // Cyan, White
1841
59
    // intensive
1842
60
    ColorEntry( QColor(0x00,0x00,0x00), 0), ColorEntry(
1843
61
QColor(0xFF,0xFF,0xFF), 1),
1844
62
    ColorEntry( QColor(0x68,0x68,0x68), 0), ColorEntry(
1845
63
QColor(0xFF,0x54,0x54), 0),
1846
64
    ColorEntry( QColor(0x54,0xFF,0x54), 0), ColorEntry(
1847
65
QColor(0xFF,0xFF,0x54), 0),
1848
66
    ColorEntry( QColor(0x54,0x54,0xFF), 0), ColorEntry(
1849
67
QColor(0xFF,0x54,0xFF), 0),
1850
68
    ColorEntry( QColor(0x54,0xFF,0xFF), 0), ColorEntry(
1851
69
QColor(0xFF,0xFF,0xFF), 0)
1852
70
};
1853
71
1854
72
const char* const ColorScheme::colorNames[TABLE_COLORS] =
1855
73
{
1856
74
  "Foreground",
1857
75
  "Background",
1858
76
  "Color0",
1859
77
  "Color1",
1860
78
  "Color2",
1861
79
  "Color3",
1862
80
  "Color4",
1863
81
  "Color5",
1864
82
  "Color6",
1865
83
  "Color7",
1866
84
  "ForegroundIntense",
1867
85
  "BackgroundIntense",
1868
86
  "Color0Intense",
1869
87
  "Color1Intense",
1870
88
  "Color2Intense",
1871
89
  "Color3Intense",
1872
90
  "Color4Intense",
1873
91
  "Color5Intense",
1874
92
  "Color6Intense",
1875
93
  "Color7Intense"
1876
94
};
1877
95
// dummy silently comment out the tr_NOOP
1878
96
#define tr_NOOP
1879
97
const char* const ColorScheme::translatedColorNames[TABLE_COLORS] =
1880
98
{
1881
99
    tr_NOOP("Foreground"),
1882
100
    tr_NOOP("Background"),
1883
101
    tr_NOOP("Color 1"),
1884
102
    tr_NOOP("Color 2"),
1885
103
    tr_NOOP("Color 3"),
1886
104
    tr_NOOP("Color 4"),
1887
105
    tr_NOOP("Color 5"),
1888
106
    tr_NOOP("Color 6"),
1889
107
    tr_NOOP("Color 7"),
1890
108
    tr_NOOP("Color 8"),
1891
109
    tr_NOOP("Foreground (Intense)"),
1892
110
    tr_NOOP("Background (Intense)"),
1893
111
    tr_NOOP("Color 1 (Intense)"),
1894
112
    tr_NOOP("Color 2 (Intense)"),
1895
113
    tr_NOOP("Color 3 (Intense)"),
1896
114
    tr_NOOP("Color 4 (Intense)"),
1897
115
    tr_NOOP("Color 5 (Intense)"),
1898
116
    tr_NOOP("Color 6 (Intense)"),
1899
117
    tr_NOOP("Color 7 (Intense)"),
1900
118
    tr_NOOP("Color 8 (Intense)")
1901
119
};
1902
120
1903
121
ColorScheme::ColorScheme()
1904
122
{
1905
123
    _table = 0;
1906
124
    _randomTable = 0;
1907
125
    _opacity = 1.0;
1908
126
}
1909
127
ColorScheme::ColorScheme(const ColorScheme& other)
1910
128
      : _opacity(other._opacity)
1911
129
       ,_table(0)
1912
130
       ,_randomTable(0)
1913
131
{
1914
132
    setName(other.name());
1915
133
    setDescription(other.description());
1916
134
1917
135
    if ( other._table != 0 )
1918
136
    {
1919
137
        for ( int i = 0 ; i < TABLE_COLORS ; i++ )
1920
138
            setColorTableEntry(i,other._table[i]);
1921
139
    }
1922
140
1923
141
    if ( other._randomTable != 0 )
1924
142
    {
1925
143
        for ( int i = 0 ; i < TABLE_COLORS ; i++ )
1926
144
        {
1927
145
            const RandomizationRange& range = other._randomTable[i];
1928
146
            setRandomizationRange(i,range.hue,range.saturation,range.value);
1929
147
        }
1930
148
    }
1931
149
}
1932
150
ColorScheme::~ColorScheme()
1933
151
{
1934
152
    delete[] _table;
1935
153
    delete[] _randomTable;
1936
154
}
1937
155
1938
156
void ColorScheme::setDescription(const QString& description) { _description = description; }
1939
157
QString ColorScheme::description() const { return _description; }
1940
158
1941
159
void ColorScheme::setName(const QString& name) { _name = name; }
1942
160
QString ColorScheme::name() const { return _name; }
1943
161
1944
162
void ColorScheme::setColorTableEntry(int index , const ColorEntry& entry)
1945
163
{
1946
164
    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
1947
165
1948
166
    if ( !_table ) 
1949
167
    {
1950
168
        _table = new ColorEntry[TABLE_COLORS];
1951
169
1952
170
        for (int i=0;i<TABLE_COLORS;i++)
1953
171
            _table[i] = defaultTable[i];
1954
172
    }
1955
173
    
1956
174
    _table[index] = entry; 
1957
175
}
1958
176
ColorEntry ColorScheme::colorEntry(int index , uint randomSeed) const
1959
177
{
1960
178
    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
1961
179
1962
180
    if ( randomSeed != 0 )
1963
181
        qsrand(randomSeed);
1964
182
1965
183
    ColorEntry entry = colorTable()[index];
1966
184
1967
185
    if ( randomSeed != 0 && 
1968
186
        _randomTable != 0 && 
1969
187
        !_randomTable[index].isNull() )
1970
188
    {
1971
189
        const RandomizationRange& range = _randomTable[index];
1972
190
      
1973
191
1974
192
        int hueDifference = range.hue ? (qrand() % range.hue) - range.hue/2 : 0;
1975
193
        int saturationDifference = range.saturation ? (qrand() % range.saturation) - range.saturation/2 : 0;
1976
194
        int  valueDifference = range.value ? (qrand() % range.value) - range.value/2 : 0;
1977
195
1978
196
        QColor& color = entry.color;
1979
197
      
1980
198
        int newHue = qAbs( (color.hue() + hueDifference) % MAX_HUE );
1981
199
        int newValue = qMin( qAbs(color.value() + valueDifference) , 255 );
1982
200
        int newSaturation = qMin( qAbs(color.saturation() + saturationDifference) , 255 );
1983
201
1984
202
        color.setHsv(newHue,newSaturation,newValue);
1985
203
    }
1986
204
1987
205
    return entry;
1988
206
}
1989
207
void ColorScheme::getColorTable(ColorEntry* table , uint randomSeed) const
1990
208
{
1991
209
    for ( int i = 0 ; i < TABLE_COLORS ; i++ )
1992
210
        table[i] = colorEntry(i,randomSeed);
1993
211
}
1994
212
bool ColorScheme::randomizedBackgroundColor() const
1995
213
{
1996
214
    return _randomTable == 0 ? false : !_randomTable[1].isNull();
1997
215
}
1998
216
void ColorScheme::setRandomizedBackgroundColor(bool randomize)
1999
217
{
2000
218
    // the hue of the background colour is allowed to be randomly 
2001
219
    // adjusted as much as possible.
2002
220
    //
2003
221
    // the value and saturation are left alone to maintain read-ability
2004
222
    if ( randomize )
2005
223
    {
2006
224
        setRandomizationRange( 1 /* background color index */ , MAX_HUE , 255 , 0 ); 
2007
225
    }
2008
226
    else
2009
227
    {
2010
228
        if ( _randomTable )
2011
229
            setRandomizationRange( 1 /* background color index */ , 0 , 0 , 0 );
2012
230
    }
2013
231
}
2014
232
2015
233
void ColorScheme::setRandomizationRange( int index , quint16 hue , quint8 saturation ,
2016
234
                                         quint8 value )
2017
235
{
2018
236
    Q_ASSERT( hue <= MAX_HUE );
2019
237
    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
2020
238
2021
239
    if ( _randomTable == 0 )
2022
240
        _randomTable = new RandomizationRange[TABLE_COLORS];
2023
241
2024
242
    _randomTable[index].hue = hue;
2025
243
    _randomTable[index].value = value;
2026
244
    _randomTable[index].saturation = saturation;
2027
245
}
2028
246
2029
247
const ColorEntry* ColorScheme::colorTable() const
2030
248
{
2031
249
    if ( _table )
2032
250
        return _table;
2033
251
    else
2034
252
        return defaultTable;
2035
253
}
2036
254
QColor ColorScheme::foregroundColor() const
2037
255
{
2038
256
    return colorTable()[0].color;
2039
257
}
2040
258
QColor ColorScheme::backgroundColor() const
2041
259
{
2042
260
    return colorTable()[1].color;
2043
261
}
2044
262
bool ColorScheme::hasDarkBackground() const
2045
263
{
2046
264
    // value can range from 0 - 255, with larger values indicating higher brightness.
2047
265
    // so 127 is in the middle, anything less is deemed 'dark'
2048
266
    return backgroundColor().value() < 127;
2049
267
}
2050
268
void ColorScheme::setOpacity(qreal opacity) { _opacity = opacity; }
2051
269
qreal ColorScheme::opacity() const { return _opacity; }
2052
270
2053
271
void ColorScheme::read(const QString & fileName)
2054
272
{
2055
273
    QSettings s(fileName, QSettings::IniFormat);
2056
274
    s.beginGroup("General");
2057
275
2058
276
    _description = s.value("Description", QObject::tr("Un-named Color Scheme")).toString();
2059
277
    _opacity = s.value("Opacity",qreal(1.0)).toDouble();
2060
278
    s.endGroup();
2061
279
2062
280
    for (int i=0 ; i < TABLE_COLORS ; i++)
2063
281
    {
2064
282
        readColorEntry(&s, i);
2065
283
    }
2066
284
}
2067
285
#if 0
2068
286
// implemented upstream - user apps
2069
287
void ColorScheme::read(KConfig& config)
2070
288
{
2071
289
    KConfigGroup configGroup = config.group("General");
2072
290
2073
291
    QString description = configGroup.readEntry("Description", QObject::tr("Un-named Color Scheme"));
2074
292
2075
293
    _description = tr(description.toUtf8());
2076
294
    _opacity = configGroup.readEntry("Opacity",qreal(1.0));
2077
295
2078
296
    for (int i=0 ; i < TABLE_COLORS ; i++)
2079
297
    {
2080
298
        readColorEntry(config,i);
2081
299
    }
2082
300
}
2083
301
void ColorScheme::write(KConfig& config) const
2084
302
{
2085
303
    KConfigGroup configGroup = config.group("General");
2086
304
2087
305
    configGroup.writeEntry("Description",_description);
2088
306
    configGroup.writeEntry("Opacity",_opacity);
2089
307
    
2090
308
    for (int i=0 ; i < TABLE_COLORS ; i++)
2091
309
    {
2092
310
        RandomizationRange random = _randomTable != 0 ? _randomTable[i] : RandomizationRange();
2093
311
        writeColorEntry(config,colorNameForIndex(i),colorTable()[i],random);
2094
312
    }
2095
313
}
2096
314
#endif
2097
315
2098
316
QString ColorScheme::colorNameForIndex(int index) 
2099
317
{
2100
318
    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
2101
319
2102
320
    return QString(colorNames[index]);
2103
321
}
2104
322
QString ColorScheme::translatedColorNameForIndex(int index) 
2105
323
{
2106
324
    Q_ASSERT( index >= 0 && index < TABLE_COLORS );
2107
325
2108
326
    return translatedColorNames[index];
2109
327
}
2110
328
2111
329
void ColorScheme::readColorEntry(QSettings * s , int index)
2112
330
{
2113
331
    s->beginGroup(colorNameForIndex(index));
2114
332
    
2115
333
    ColorEntry entry;
2116
334
2117
335
    QStringList rgbList = s->value("Color", QStringList()).toStringList();
2118
336
    if (rgbList.count() != 3)
2119
337
    {
2120
338
        Q_ASSERT(0);
2121
339
    }
2122
340
    int r, g, b;
2123
341
    r = rgbList[0].toInt();
2124
342
    g = rgbList[1].toInt();
2125
343
    b = rgbList[2].toInt();
2126
344
    entry.color = QColor(r, g, b);
2127
345
    
2128
346
    entry.transparent = s->value("Transparent",false).toBool();
2129
347
2130
348
    // Deprecated key from KDE 4.0 which set 'Bold' to true to force
2131
349
    // a color to be bold or false to use the current format
2132
350
    //
2133
351
    // TODO - Add a new tri-state key which allows for bold, normal or
2134
352
    // current format
2135
353
    if (s->contains("Bold"))
2136
354
        entry.fontWeight = s->value("Bold",false).toBool() ? ColorEntry::Bold :
2137
355
                                                                 ColorEntry::UseCurrentFormat;
2138
356
2139
357
    quint16 hue = s->value("MaxRandomHue",0).toInt();
2140
358
    quint8 value = s->value("MaxRandomValue",0).toInt();
2141
359
    quint8 saturation = s->value("MaxRandomSaturation",0).toInt();
2142
360
2143
361
    setColorTableEntry( index , entry );
2144
362
2145
363
    if ( hue != 0 || value != 0 || saturation != 0 )
2146
364
       setRandomizationRange( index , hue , saturation , value ); 
2147
365
2148
366
    s->endGroup();
2149
367
}
2150
368
#if 0
2151
369
// implemented upstream - user apps
2152
370
void ColorScheme::writeColorEntry(KConfig& config , const QString& colorName, const ColorEntry& entry , const RandomizationRange& random) const
2153
371
{
2154
372
    KConfigGroup configGroup(&config,colorName);
2155
373
2156
374
    configGroup.writeEntry("Color",entry.color);
2157
375
    configGroup.writeEntry("Transparency",(bool)entry.transparent);
2158
376
    if (entry.fontWeight != ColorEntry::UseCurrentFormat)
2159
377
    {
2160
378
        configGroup.writeEntry("Bold",entry.fontWeight == ColorEntry::Bold);
2161
379
    }
2162
380
2163
381
    // record randomization if this color has randomization or 
2164
382
    // if one of the keys already exists 
2165
383
    if ( !random.isNull() || configGroup.hasKey("MaxRandomHue") )
2166
384
    {
2167
385
        configGroup.writeEntry("MaxRandomHue",(int)random.hue);
2168
386
        configGroup.writeEntry("MaxRandomValue",(int)random.value);
2169
387
        configGroup.writeEntry("MaxRandomSaturation",(int)random.saturation);
2170
388
    }
2171
389
}
2172
390
#endif
2173
391
2174
392
// 
2175
393
// Work In Progress - A color scheme for use on KDE setups for users
2176
394
// with visual disabilities which means that they may have trouble
2177
395
// reading text with the supplied color schemes.
2178
396
//
2179
397
// This color scheme uses only the 'safe' colors defined by the
2180
398
// KColorScheme class.  
2181
399
//
2182
400
// A complication this introduces is that each color provided by 
2183
401
// KColorScheme is defined as a 'background' or 'foreground' color.
2184
402
// Only foreground colors are allowed to be used to render text and 
2185
403
// only background colors are allowed to be used for backgrounds.
2186
404
//
2187
405
// The ColorEntry and TerminalDisplay classes do not currently
2188
406
// support this restriction.  
2189
407
//
2190
408
// Requirements:
2191
409
//  - A color scheme which uses only colors from the KColorScheme class
2192
410
//  - Ability to restrict which colors the TerminalDisplay widget 
2193
411
//    uses as foreground and background color
2194
412
//  - Make use of KGlobalSettings::allowDefaultBackgroundImages() as
2195
413
//    a hint to determine whether this accessible color scheme should 
2196
414
//    be used by default.
2197
415
//
2198
416
//
2199
417
// -- Robert Knight <robertknight@gmail.com> 21/07/2007
2200
418
//
2201
419
AccessibleColorScheme::AccessibleColorScheme()
2202
420
    : ColorScheme()
2203
421
{
2204
422
#if 0
2205
423
// It's not finished in konsole and it breaks Qt4 compilation as well
2206
424
    // basic attributes
2207
425
    setName("accessible");
2208
426
    setDescription(QObject::tr("Accessible Color Scheme"));
2209
427
2210
428
    // setup colors
2211
429
    const int ColorRoleCount = 8;
2212
430
2213
431
    const KColorScheme colorScheme(QPalette::Active);
2214
432
2215
433
    QBrush colors[ColorRoleCount] =
2216
434
    {
2217
435
        colorScheme.foreground( colorScheme.NormalText ),
2218
436
        colorScheme.background( colorScheme.NormalBackground ),
2219
437
2220
438
        colorScheme.foreground( colorScheme.InactiveText ),
2221
439
        colorScheme.foreground( colorScheme.ActiveText ),
2222
440
        colorScheme.foreground( colorScheme.LinkText ),
2223
441
        colorScheme.foreground( colorScheme.VisitedText ),
2224
442
        colorScheme.foreground( colorScheme.NegativeText ),
2225
443
        colorScheme.foreground( colorScheme.NeutralText )
2226
444
    };
2227
445
2228
446
    for ( int i = 0 ; i < TABLE_COLORS ; i++ ) 
2229
447
    {
2230
448
        ColorEntry entry;
2231
449
        entry.color = colors[ i % ColorRoleCount ].color();
2232
450
2233
451
        setColorTableEntry( i , entry ); 
2234
452
    }   
2235
453
#endif
2236
454
}
2237
455
2238
456
KDE3ColorSchemeReader::KDE3ColorSchemeReader( QIODevice* device ) :
2239
457
    _device(device)
2240
458
{
2241
459
}
2242
460
ColorScheme* KDE3ColorSchemeReader::read() 
2243
461
{
2244
462
    Q_ASSERT( _device->openMode() == QIODevice::ReadOnly ||
2245
463
              _device->openMode() == QIODevice::ReadWrite  );
2246
464
2247
465
    ColorScheme* scheme = new ColorScheme();
2248
466
2249
467
    QRegExp comment("#.*$");
2250
468
    while ( !_device->atEnd() )
2251
469
    {
2252
470
        QString line(_device->readLine());
2253
471
        line.remove(comment);
2254
472
        line = line.simplified();
2255
473
2256
474
        if ( line.isEmpty() )
2257
475
            continue;
2258
476
2259
477
        if ( line.startsWith(QLatin1String("color")) )
2260
478
        {
2261
479
            if (!readColorLine(line,scheme))
2262
480
                qDebug() << "Failed to read KDE 3 color scheme line" << line;
2263
481
        }
2264
482
        else if ( line.startsWith(QLatin1String("title")) )
2265
483
        {
2266
484
            if (!readTitleLine(line,scheme))
2267
485
                qDebug() << "Failed to read KDE 3 color scheme title line" << line;
2268
486
        }
2269
487
        else
2270
488
        {
2271
489
            qDebug() << "KDE 3 color scheme contains an unsupported feature, '" <<
2272
490
                line << "'";
2273
491
        } 
2274
492
    }
2275
493
2276
494
    return scheme;
2277
495
}
2278
496
bool KDE3ColorSchemeReader::readColorLine(const QString& line,ColorScheme* scheme)
2279
497
{
2280
498
    QStringList list = line.split(QChar(' '));
2281
499
2282
500
    if (list.count() != 7)
2283
501
        return false;
2284
502
    if (list.first() != "color")
2285
503
        return false;
2286
504
    
2287
505
    int index = list[1].toInt();
2288
506
    int red = list[2].toInt();
2289
507
    int green = list[3].toInt();
2290
508
    int blue = list[4].toInt();
2291
509
    int transparent = list[5].toInt();
2292
510
    int bold = list[6].toInt();
2293
511
2294
512
    const int MAX_COLOR_VALUE = 255;
2295
513
2296
514
    if(     (index < 0 || index >= TABLE_COLORS )
2297
515
        ||  (red < 0 || red > MAX_COLOR_VALUE )
2298
516
        ||  (blue < 0 || blue > MAX_COLOR_VALUE )
2299
517
        ||  (green < 0 || green > MAX_COLOR_VALUE )
2300
518
        ||  (transparent != 0 && transparent != 1 )
2301
519
        ||  (bold != 0 && bold != 1)    )
2302
520
        return false;
2303
521
2304
522
    ColorEntry entry;
2305
523
    entry.color = QColor(red,green,blue);
2306
524
    entry.transparent = ( transparent != 0 );
2307
525
    entry.fontWeight = ( bold != 0 ) ? ColorEntry::Bold : ColorEntry::UseCurrentFormat;
2308
526
2309
527
    scheme->setColorTableEntry(index,entry);
2310
528
    return true;
2311
529
}
2312
530
bool KDE3ColorSchemeReader::readTitleLine(const QString& line,ColorScheme* scheme)
2313
531
{
2314
532
    if( !line.startsWith(QLatin1String("title")) )
2315
533
        return false;
2316
534
2317
535
    int spacePos = line.indexOf(' ');
2318
536
    if( spacePos == -1 )
2319
537
        return false;
2320
538
2321
539
    QString description = line.mid(spacePos+1);
2322
540
2323
541
    scheme->setDescription(description.toUtf8());
2324
542
    return true;
2325
543
}
2326
544
ColorSchemeManager::ColorSchemeManager()
2327
545
    : _haveLoadedAll(false)
2328
546
{
2329
547
}
2330
548
ColorSchemeManager::~ColorSchemeManager()
2331
549
{
2332
550
    QHashIterator<QString,const ColorScheme*> iter(_colorSchemes);
2333
551
    while (iter.hasNext())
2334
552
    {
2335
553
        iter.next();
2336
554
        delete iter.value();
2337
555
    }
2338
556
}
2339
557
void ColorSchemeManager::loadAllColorSchemes()
2340
558
{
2341
559
    qDebug() << "loadAllColorSchemes";
2342
560
    int success = 0;
2343
561
    int failed = 0;
2344
562
2345
563
    QList<QString> nativeColorSchemes = listColorSchemes();
2346
564
2347
565
    QListIterator<QString> nativeIter(nativeColorSchemes);
2348
566
    while ( nativeIter.hasNext() )
2349
567
    {
2350
568
        if ( loadColorScheme( nativeIter.next() ) )
2351
569
            success++;
2352
570
        else
2353
571
            failed++;
2354
572
    }
2355
573
2356
574
    QList<QString> kde3ColorSchemes = listKDE3ColorSchemes();
2357
575
    QListIterator<QString> kde3Iter(kde3ColorSchemes);
2358
576
    while ( kde3Iter.hasNext() )
2359
577
    {
2360
578
        if ( loadKDE3ColorScheme( kde3Iter.next() ) )
2361
579
            success++;
2362
580
        else
2363
581
            failed++;
2364
582
    }
2365
583
2366
584
    if ( failed > 0 )
2367
585
        qDebug() << "failed to load " << failed << " color schemes.";
2368
586
2369
587
    _haveLoadedAll = true;
2370
588
}
2371
589
QList<const ColorScheme*> ColorSchemeManager::allColorSchemes()
2372
590
{
2373
591
    if ( !_haveLoadedAll )
2374
592
    {
2375
593
        loadAllColorSchemes();
2376
594
    }
2377
595
2378
596
    return _colorSchemes.values();
2379
597
}
2380
598
bool ColorSchemeManager::loadKDE3ColorScheme(const QString& filePath)
2381
599
{
2382
600
    QFile file(filePath);
2383
601
    if (!filePath.endsWith(QLatin1String(".schema")) || !file.open(QIODevice::ReadOnly))
2384
602
        return false;
2385
603
2386
604
    KDE3ColorSchemeReader reader(&file);
2387
605
    ColorScheme* scheme = reader.read();
2388
606
    scheme->setName(QFileInfo(file).baseName());
2389
607
    file.close();
2390
608
2391
609
    if (scheme->name().isEmpty())
2392
610
    {
2393
611
        qDebug() << "color scheme name is not valid.";
2394
612
        delete scheme;
2395
613
        return false;
2396
614
    }
2397
615
    
2398
616
    QFileInfo info(filePath);
2399
617
2400
618
    if ( !_colorSchemes.contains(info.baseName()) )
2401
619
        _colorSchemes.insert(scheme->name(),scheme);
2402
620
    else
2403
621
    {
2404
622
        qDebug() << "color scheme with name" << scheme->name() << "has already been" <<
2405
623
            "found, ignoring.";
2406
624
        delete scheme;
2407
625
    }
2408
626
2409
627
    return true;
2410
628
}
2411
629
#if 0
2412
630
void ColorSchemeManager::addColorScheme(ColorScheme* scheme) 
2413
631
{
2414
632
    _colorSchemes.insert(scheme->name(),scheme);
2415
633
2416
634
    // save changes to disk
2417
635
    QString path = KGlobal::dirs()->saveLocation("data","konsole/") + scheme->name() + ".colorscheme";
2418
636
    KConfig config(path , KConfig::NoGlobals);
2419
637
2420
638
    scheme->write(config);
2421
639
}
2422
640
#endif
2423
641
bool ColorSchemeManager::loadColorScheme(const QString& filePath)
2424
642
{
2425
643
    if ( !filePath.endsWith(QLatin1String(".colorscheme")) || !QFile::exists(filePath) )
2426
644
        return false;
2427
645
2428
646
    QFileInfo info(filePath);
2429
647
    
2430
648
    ColorScheme* scheme = new ColorScheme();
2431
649
    scheme->setName(info.baseName());
2432
650
    scheme->read(filePath);
2433
651
2434
652
    if (scheme->name().isEmpty()) 
2435
653
    {
2436
654
        qDebug() << "Color scheme in" << filePath << "does not have a valid name and was not loaded.";
2437
655
        delete scheme;
2438
656
        return false;
2439
657
    }    
2440
658
2441
659
    if ( !_colorSchemes.contains(info.baseName()) )
2442
660
    {
2443
661
        _colorSchemes.insert(scheme->name(),scheme);
2444
662
    }
2445
663
    else
2446
664
    {
2447
665
        qDebug() << "color scheme with name" << scheme->name() << "has already been" <<
2448
666
            "found, ignoring.";
2449
667
        
2450
668
        delete scheme;
2451
669
    }
2452
670
2453
671
    return true; 
2454
672
}
2455
673
QList<QString> ColorSchemeManager::listKDE3ColorSchemes()
2456
674
{
2457
675
    QString dname(get_color_schemes_dir());
2458
676
    QDir dir(dname);
2459
677
    QStringList filters;
2460
678
    filters << "*.schema";
2461
679
    dir.setNameFilters(filters);
2462
680
    QStringList list = dir.entryList(filters); 
2463
681
    QStringList ret;
2464
682
    foreach(QString i, list)
2465
683
        ret << dname + "/" + i;
2466
684
    return ret;
2467
685
    //return KGlobal::dirs()->findAllResources("data",
2468
686
    //                                         "konsole/*.schema",
2469
687
    //                                          KStandardDirs::NoDuplicates);
2470
688
    //
2471
689
}
2472
690
QList<QString> ColorSchemeManager::listColorSchemes()
2473
691
{
2474
692
    QString dname(get_color_schemes_dir());
2475
693
    QDir dir(dname);
2476
694
    QStringList filters;
2477
695
    filters << "*.colorscheme";
2478
696
    dir.setNameFilters(filters);
2479
697
    QStringList list = dir.entryList(filters);
2480
698
    QStringList ret;
2481
699
    foreach(QString i, list)
2482
700
        ret << dname + "/" + i;
2483
701
    return ret;
2484
702
//    return KGlobal::dirs()->findAllResources("data",
2485
703
//                                             "konsole/*.colorscheme",
2486
704
//                                             KStandardDirs::NoDuplicates);
2487
705
}
2488
706
const ColorScheme ColorSchemeManager::_defaultColorScheme;
2489
707
const ColorScheme* ColorSchemeManager::defaultColorScheme() const
2490
708
{
2491
709
    return &_defaultColorScheme;
2492
710
}
2493
711
bool ColorSchemeManager::deleteColorScheme(const QString& name)
2494
712
{
2495
713
    Q_ASSERT( _colorSchemes.contains(name) );
2496
714
2497
715
    // lookup the path and delete 
2498
716
    QString path = findColorSchemePath(name);
2499
717
    if ( QFile::remove(path) )
2500
718
    {
2501
719
        _colorSchemes.remove(name);
2502
720
        return true;
2503
721
    }
2504
722
    else
2505
723
    {
2506
724
        qDebug() << "Failed to remove color scheme -" << path;
2507
725
        return false;
2508
726
    }
2509
727
}
2510
728
QString ColorSchemeManager::findColorSchemePath(const QString& name) const
2511
729
{
2512
730
//    QString path = KStandardDirs::locate("data","konsole/"+name+".colorscheme");
2513
731
    QString path(get_color_schemes_dir() + "/"+ name + ".colorscheme");
2514
732
    if ( !path.isEmpty() )
2515
733
       return path; 
2516
734
2517
735
    //path = KStandardDirs::locate("data","konsole/"+name+".schema");
2518
736
    path = get_color_schemes_dir() + "/"+ name + ".schema";
2519
737
2520
738
    return path;
2521
739
}
2522
740
const ColorScheme* ColorSchemeManager::findColorScheme(const QString& name) 
2523
741
{
2524
742
    if ( name.isEmpty() )
2525
743
        return defaultColorScheme();
2526
744
2527
745
    if ( _colorSchemes.contains(name) )
2528
746
        return _colorSchemes[name];
2529
747
    else
2530
748
    {
2531
749
        // look for this color scheme
2532
750
        QString path = findColorSchemePath(name); 
2533
751
        if ( !path.isEmpty() && loadColorScheme(path) )
2534
752
        {
2535
753
            return findColorScheme(name); 
2536
754
        } 
2537
755
        else 
2538
756
        {
2539
757
            if (!path.isEmpty() && loadKDE3ColorScheme(path))
2540
758
                return findColorScheme(name);
2541
759
        }
2542
760
2543
761
        qDebug() << "Could not find color scheme - " << name;
2544
762
2545
763
        return 0; 
2546
764
    }
2547
765
}
2548
766
2549
767
ColorSchemeManager* ColorSchemeManager::theColorSchemeManager = 0;
2550
768
//K_GLOBAL_STATIC( ColorSchemeManager , theColorSchemeManager )
2551
769
ColorSchemeManager* ColorSchemeManager::instance()
2552
770
{
2553
771
    if (! theColorSchemeManager)
2554
772
        theColorSchemeManager = new ColorSchemeManager();
2555
773
    return theColorSchemeManager;
2556
774
}
2557
0
775
2558
=== added file 'src/plugin/konsole/ColorScheme.h'
2559
--- src/plugin/konsole/ColorScheme.h	1970-01-01 00:00:00 +0000
2560
+++ src/plugin/konsole/ColorScheme.h	2014-05-06 21:50:22 +0000
2561
@@ -0,0 +1,342 @@
2562
1
/*
2563
2
    This source file is part of Konsole, a terminal emulator.
2564
3
2565
4
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
2566
5
2567
6
    This program is free software; you can redistribute it and/or modify
2568
7
    it under the terms of the GNU General Public License as published by
2569
8
    the Free Software Foundation; either version 2 of the License, or
2570
9
    (at your option) any later version.
2571
10
2572
11
    This program is distributed in the hope that it will be useful,
2573
12
    but WITHOUT ANY WARRANTY; without even the implied warranty of
2574
13
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2575
14
    GNU General Public License for more details.
2576
15
2577
16
    You should have received a copy of the GNU General Public License
2578
17
    along with this program; if not, write to the Free Software
2579
18
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
2580
19
    02110-1301  USA.
2581
20
*/
2582
21
2583
22
#ifndef COLORSCHEME_H
2584
23
#define COLORSCHEME_H
2585
24
2586
25
// Qt
2587
26
#include <QtCore/QHash>
2588
27
#include <QtCore/QList>
2589
28
#include <QtCore/QMetaType>
2590
29
#include <QtCore/QIODevice>
2591
30
#include <QtCore/QSet>
2592
31
#include <QSettings>
2593
32
2594
33
// Konsole
2595
34
#include "CharacterColor.h"
2596
35
2597
36
class QIODevice;
2598
37
//class KConfig;
2599
38
2600
39
2601
40
/**
2602
41
 * Represents a color scheme for a terminal display.  
2603
42
 *
2604
43
 * The color scheme includes the palette of colors used to draw the text and character backgrounds
2605
44
 * in the display and the opacity level of the display background. 
2606
45
 */
2607
46
class ColorScheme
2608
47
{
2609
48
public:
2610
49
    /** 
2611
50
     * Constructs a new color scheme which is initialised to the default color set 
2612
51
     * for Konsole.
2613
52
     */
2614
53
    ColorScheme();
2615
54
    ColorScheme(const ColorScheme& other);
2616
55
    ~ColorScheme();
2617
56
2618
57
    /** Sets the descriptive name of the color scheme. */
2619
58
    void setDescription(const QString& description);
2620
59
    /** Returns the descriptive name of the color scheme. */
2621
60
    QString description() const;
2622
61
2623
62
    /** Sets the name of the color scheme */
2624
63
    void setName(const QString& name);
2625
64
    /** Returns the name of the color scheme */
2626
65
    QString name() const;
2627
66
2628
67
#if 0
2629
68
// Implemented upstream - in user apps
2630
69
    /** Reads the color scheme from the specified configuration source */
2631
70
    void read(KConfig& config);
2632
71
    /** Writes the color scheme to the specified configuration source */
2633
72
    void write(KConfig& config) const;
2634
73
#endif
2635
74
    void read(const QString & filename);
2636
75
2637
76
    /** Sets a single entry within the color palette. */
2638
77
    void setColorTableEntry(int index , const ColorEntry& entry);
2639
78
2640
79
    /** 
2641
80
     * Copies the color entries which form the palette for this color scheme
2642
81
     * into @p table.  @p table should be an array with TABLE_COLORS entries.
2643
82
     *
2644
83
     * @param table Array into which the color entries for this color scheme
2645
84
     * are copied.
2646
85
     * @param randomSeed Color schemes may allow certain colors in their
2647
86
     * palette to be randomized.  The seed is used to pick the random color.
2648
87
     */
2649
88
    void getColorTable(ColorEntry* table, uint randomSeed = 0) const;
2650
89
   
2651
90
    /**
2652
91
     * Retrieves a single color entry from the table.
2653
92
     *
2654
93
     * See getColorTable()
2655
94
     */
2656
95
    ColorEntry colorEntry(int index , uint randomSeed = 0) const;
2657
96
2658
97
    /** 
2659
98
     * Convenience method.  Returns the 
2660
99
     * foreground color for this scheme, 
2661
100
     * this is the primary color used to draw the 
2662
101
     * text in this scheme.
2663
102
     */
2664
103
    QColor foregroundColor() const;
2665
104
    /**
2666
105
     * Convenience method.  Returns the background color for 
2667
106
     * this scheme, this is the primary color used to 
2668
107
     * draw the terminal background in this scheme.
2669
108
     */
2670
109
    QColor backgroundColor() const;
2671
110
2672
111
    /** 
2673
112
     * Returns true if this color scheme has a dark background.
2674
113
     * The background color is said to be dark if it has a value of less than 127
2675
114
     * in the HSV color space.
2676
115
     */
2677
116
    bool hasDarkBackground() const;
2678
117
2679
118
    /** 
2680
119
     * Sets the opacity level of the display background. @p opacity ranges
2681
120
     * between 0 (completely transparent background) and 1 (completely
2682
121
     * opaque background).
2683
122
     *
2684
123
     * Defaults to 1.
2685
124
     *
2686
125
     * TODO: More documentation
2687
126
     */
2688
127
    void setOpacity(qreal opacity);
2689
128
    /** 
2690
129
     * Returns the opacity level for this color scheme, see setOpacity()
2691
130
     * TODO: More documentation
2692
131
     */
2693
132
    qreal opacity() const;
2694
133
2695
134
    /** 
2696
135
     * Enables randomization of the background color.  This will cause
2697
136
     * the palette returned by getColorTable() and colorEntry() to
2698
137
     * be adjusted depending on the value of the random seed argument
2699
138
     * to them.
2700
139
     */ 
2701
140
    void setRandomizedBackgroundColor(bool randomize);
2702
141
2703
142
    /** Returns true if the background color is randomized. */
2704
143
    bool randomizedBackgroundColor() const;
2705
144
2706
145
    static QString colorNameForIndex(int index);
2707
146
    static QString translatedColorNameForIndex(int index);
2708
147
2709
148
private:
2710
149
    // specifies how much a particular color can be randomized by
2711
150
    class RandomizationRange
2712
151
    {
2713
152
    public:
2714
153
        RandomizationRange() : hue(0) , saturation(0) , value(0) {}
2715
154
2716
155
        bool isNull() const 
2717
156
        {
2718
157
            return ( hue == 0 && saturation == 0 && value == 0 );
2719
158
        }
2720
159
2721
160
        quint16 hue;
2722
161
        quint8  saturation;
2723
162
        quint8  value;
2724
163
    };
2725
164
2726
165
    // returns the active color table.  if none has been set specifically,
2727
166
    // this is the default color table.
2728
167
    const ColorEntry* colorTable() const;
2729
168
2730
169
#if 0
2731
170
// implemented upstream - user apps
2732
171
    // reads a single colour entry from a KConfig source
2733
172
    // and sets the palette entry at 'index' to the entry read.
2734
173
    void readColorEntry(KConfig& config , int index); 
2735
174
    // writes a single colour entry to a KConfig source
2736
175
    void writeColorEntry(KConfig& config , const QString& colorName, const ColorEntry& entry,const RandomizationRange& range) const;
2737
176
#endif
2738
177
    void readColorEntry(QSettings *s, int index);
2739
178
2740
179
    // sets the amount of randomization allowed for a particular color 
2741
180
    // in the palette.  creates the randomization table if 
2742
181
    // it does not already exist
2743
182
    void setRandomizationRange( int index , quint16 hue , quint8 saturation , quint8 value );
2744
183
2745
184
    QString _description;
2746
185
    QString _name;
2747
186
    qreal _opacity;
2748
187
    ColorEntry* _table; // pointer to custom color table or 0 if the default
2749
188
                        // color scheme is being used
2750
189
2751
190
2752
191
    static const quint16 MAX_HUE = 340;
2753
192
2754
193
    RandomizationRange* _randomTable;   // pointer to randomization table or 0
2755
194
                                        // if no colors in the color scheme support
2756
195
                                        // randomization
2757
196
2758
197
    static const char* const colorNames[TABLE_COLORS];
2759
198
    static const char* const translatedColorNames[TABLE_COLORS];
2760
199
2761
200
    static const ColorEntry defaultTable[]; // table of default color entries
2762
201
};
2763
202
2764
203
/** 
2765
204
 * A color scheme which uses colors from the standard KDE color palette.
2766
205
 *
2767
206
 * This is designed primarily for the benefit of users who are using specially
2768
207
 * designed colors.
2769
208
 *
2770
209
 * TODO Implement and make it the default on systems with specialized KDE
2771
210
 * color schemes.
2772
211
 */
2773
212
class AccessibleColorScheme : public ColorScheme
2774
213
{
2775
214
public:
2776
215
    AccessibleColorScheme();
2777
216
};
2778
217
2779
218
/**
2780
219
 * Reads a color scheme stored in the .schema format used in the KDE 3 incarnation
2781
220
 * of Konsole
2782
221
 *
2783
222
 * Only the basic essentials ( title and color palette entries ) are currently
2784
223
 * supported.  Additional options such as background image and background
2785
224
 * blend colors are ignored.
2786
225
 */
2787
226
class KDE3ColorSchemeReader
2788
227
{
2789
228
public:
2790
229
    /** 
2791
230
     * Constructs a new reader which reads from the specified device. 
2792
231
     * The device should be open in read-only mode. 
2793
232
     */
2794
233
    KDE3ColorSchemeReader( QIODevice* device );
2795
234
2796
235
    /** 
2797
236
     * Reads and parses the contents of the .schema file from the input
2798
237
     * device and returns the ColorScheme defined within it.
2799
238
     *
2800
239
     * Returns a null pointer if an error occurs whilst parsing
2801
240
     * the contents of the file.
2802
241
     */
2803
242
    ColorScheme* read();
2804
243
2805
244
private:
2806
245
    // reads a line from the file specifying a colour palette entry
2807
246
    // format is: color [index] [red] [green] [blue] [transparent] [bold]
2808
247
    bool readColorLine(const QString& line , ColorScheme* scheme);
2809
248
    bool readTitleLine(const QString& line , ColorScheme* scheme);
2810
249
2811
250
    QIODevice* _device;
2812
251
};
2813
252
2814
253
/**
2815
254
 * Manages the color schemes available for use by terminal displays.
2816
255
 * See ColorScheme
2817
256
 */
2818
257
class ColorSchemeManager
2819
258
{
2820
259
public:
2821
260
2822
261
    /**
2823
262
     * Constructs a new ColorSchemeManager and loads the list
2824
263
     * of available color schemes.
2825
264
     *
2826
265
     * The color schemes themselves are not loaded until they are first
2827
266
     * requested via a call to findColorScheme()
2828
267
     */
2829
268
    ColorSchemeManager();
2830
269
    /**
2831
270
     * Destroys the ColorSchemeManager and saves any modified color schemes to disk.
2832
271
     */
2833
272
    ~ColorSchemeManager();
2834
273
2835
274
    /**
2836
275
     * Returns the default color scheme for Konsole
2837
276
     */
2838
277
    const ColorScheme* defaultColorScheme() const;
2839
278
 
2840
279
    /**
2841
280
     * Returns the color scheme with the given name or 0 if no
2842
281
     * scheme with that name exists.  If @p name is empty, the
2843
282
     * default color scheme is returned.
2844
283
     *
2845
284
     * The first time that a color scheme with a particular name is
2846
285
     * requested, the configuration information is loaded from disk.
2847
286
     */
2848
287
    const ColorScheme* findColorScheme(const QString& name);
2849
288
2850
289
#if 0
2851
290
    /**
2852
291
     * Adds a new color scheme to the manager.  If @p scheme has the same name as
2853
292
     * an existing color scheme, it replaces the existing scheme.
2854
293
     *
2855
294
     * TODO - Ensure the old color scheme gets deleted
2856
295
     */
2857
296
    void addColorScheme(ColorScheme* scheme);
2858
297
#endif
2859
298
    /**
2860
299
     * Deletes a color scheme.  Returns true on successful deletion or false otherwise. 
2861
300
     */
2862
301
    bool deleteColorScheme(const QString& name);
2863
302
2864
303
    /** 
2865
304
     * Returns a list of the all the available color schemes. 
2866
305
     * This may be slow when first called because all of the color
2867
306
     * scheme resources on disk must be located, read and parsed.
2868
307
     *
2869
308
     * Subsequent calls will be inexpensive. 
2870
309
     */
2871
310
    QList<const ColorScheme*> allColorSchemes();    
2872
311
2873
312
    /** Returns the global color scheme manager instance. */
2874
313
    static ColorSchemeManager* instance();
2875
314
2876
315
private:
2877
316
    // loads a color scheme from a KDE 4+ .colorscheme file
2878
317
    bool loadColorScheme(const QString& path);
2879
318
    // loads a color scheme from a KDE 3 .schema file
2880
319
    bool loadKDE3ColorScheme(const QString& path);
2881
320
    // returns a list of paths of color schemes in the KDE 4+ .colorscheme file format
2882
321
    QList<QString> listColorSchemes();
2883
322
    // returns a list of paths of color schemes in the .schema file format
2884
323
    // used in KDE 3
2885
324
    QList<QString> listKDE3ColorSchemes();
2886
325
    // loads all of the color schemes
2887
326
    void loadAllColorSchemes();
2888
327
    // finds the path of a color scheme
2889
328
    QString findColorSchemePath(const QString& name) const;
2890
329
2891
330
    QHash<QString,const ColorScheme*> _colorSchemes;
2892
331
    QSet<ColorScheme*> _modifiedSchemes;
2893
332
2894
333
    bool _haveLoadedAll;
2895
334
2896
335
    static const ColorScheme _defaultColorScheme;
2897
336
2898
337
    static ColorSchemeManager * theColorSchemeManager;
2899
338
};
2900
339
2901
340
Q_DECLARE_METATYPE(const ColorScheme*)
2902
341
2903
342
#endif //COLORSCHEME_H
2904
0
343
2905
=== added file 'src/plugin/konsole/ColorTables.h'
2906
--- src/plugin/konsole/ColorTables.h	1970-01-01 00:00:00 +0000
2907
+++ src/plugin/konsole/ColorTables.h	2014-05-06 21:50:22 +0000
2908
@@ -0,0 +1,55 @@
2909
1
#ifndef _COLOR_TABLE_H
2910
2
#define _COLOR_TABLE_H
2911
3
2912
4
#include "CharacterColor.h"
2913
5
2914
6
//using namespace Konsole;
2915
7
#if 0
2916
8
static const ColorEntry whiteonblack_color_table[TABLE_COLORS] = {
2917
9
    // normal
2918
10
    ColorEntry(QColor(0xFF,0xFF,0xFF), false ), ColorEntry( QColor(0x00,0x00,0x00), true ), // Dfore, Dback
2919
11
    ColorEntry(QColor(0x00,0x00,0x00), false ), ColorEntry( QColor(0xB2,0x18,0x18), false ), // Black, Red
2920
12
    ColorEntry(QColor(0x18,0xB2,0x18), false ), ColorEntry( QColor(0xB2,0x68,0x18), false ), // Green, Yellow
2921
13
    ColorEntry(QColor(0x18,0x18,0xB2), false ), ColorEntry( QColor(0xB2,0x18,0xB2), false ), // Blue, Magenta
2922
14
    ColorEntry(QColor(0x18,0xB2,0xB2), false ), ColorEntry( QColor(0xB2,0xB2,0xB2), false ), // Cyan, White
2923
15
    // intensiv
2924
16
    ColorEntry(QColor(0x00,0x00,0x00), false ), ColorEntry( QColor(0xFF,0xFF,0xFF), true ),
2925
17
    ColorEntry(QColor(0x68,0x68,0x68), false ), ColorEntry( QColor(0xFF,0x54,0x54), false ),
2926
18
    ColorEntry(QColor(0x54,0xFF,0x54), false ), ColorEntry( QColor(0xFF,0xFF,0x54), false ),
2927
19
    ColorEntry(QColor(0x54,0x54,0xFF), false ), ColorEntry( QColor(0xFF,0x54,0xFF), false ),
2928
20
    ColorEntry(QColor(0x54,0xFF,0xFF), false ), ColorEntry( QColor(0xFF,0xFF,0xFF), false )
2929
21
};
2930
22
2931
23
static const ColorEntry greenonblack_color_table[TABLE_COLORS] = {
2932
24
    ColorEntry(QColor(    24, 240,  24),  false), ColorEntry(QColor(     0,   0,   0),  true),
2933
25
    ColorEntry(QColor(     0,   0,   0),  false), ColorEntry(QColor(   178,  24,  24),  false),
2934
26
    ColorEntry(QColor(    24, 178,  24),  false), ColorEntry(QColor(   178, 104,  24),  false),
2935
27
    ColorEntry(QColor(    24,  24, 178),  false), ColorEntry(QColor(   178,  24, 178),  false),
2936
28
    ColorEntry(QColor(    24, 178, 178),  false), ColorEntry(QColor(   178, 178, 178),  false),
2937
29
    // intensive colors
2938
30
    ColorEntry(QColor(   24, 240,  24),  false ), ColorEntry(QColor(    0,   0,   0),  true ),
2939
31
    ColorEntry(QColor(  104, 104, 104),  false ), ColorEntry(QColor(  255,  84,  84),  false ),
2940
32
    ColorEntry(QColor(   84, 255,  84),  false ), ColorEntry(QColor(  255, 255,  84),  false ),
2941
33
    ColorEntry(QColor(   84,  84, 255),  false ), ColorEntry(QColor(  255,  84, 255),  false ),
2942
34
    ColorEntry(QColor(   84, 255, 255),  false ), ColorEntry(QColor(  255, 255, 255),  false )
2943
35
};
2944
36
2945
37
static const ColorEntry blackonlightyellow_color_table[TABLE_COLORS] = {
2946
38
    ColorEntry(QColor(  0,   0,   0),  false),  ColorEntry(QColor( 255, 255, 221),  true),
2947
39
    ColorEntry(QColor(  0,   0,   0),  false),  ColorEntry(QColor( 178,  24,  24),  false),
2948
40
    ColorEntry(QColor( 24, 178,  24),  false),  ColorEntry(QColor( 178, 104,  24),  false),
2949
41
    ColorEntry(QColor( 24,  24, 178),  false),  ColorEntry(QColor( 178,  24, 178),  false),
2950
42
    ColorEntry(QColor( 24, 178, 178),  false),  ColorEntry(QColor( 178, 178, 178),  false),
2951
43
    ColorEntry(QColor(  0,   0,   0),  false),  ColorEntry(QColor( 255, 255, 221),  true),
2952
44
    ColorEntry(QColor(104, 104, 104),  false),  ColorEntry(QColor( 255,  84,  84),  false),
2953
45
    ColorEntry(QColor( 84, 255,  84),  false),  ColorEntry(QColor( 255, 255,  84),  false),
2954
46
    ColorEntry(QColor( 84,  84, 255),  false),  ColorEntry(QColor( 255,  84, 255),  false),
2955
47
    ColorEntry(QColor( 84, 255, 255),  false),  ColorEntry(QColor( 255, 255, 255),  false)
2956
48
};
2957
49
2958
50
2959
51
#endif
2960
52
2961
53
2962
54
#endif
2963
55
2964
0
56
2965
=== added file 'src/plugin/konsole/DefaultTranslatorText.h'
2966
--- src/plugin/konsole/DefaultTranslatorText.h	1970-01-01 00:00:00 +0000
2967
+++ src/plugin/konsole/DefaultTranslatorText.h	2014-05-06 21:50:22 +0000
2968
@@ -0,0 +1,2 @@
2969
1
"keyboard \"Fallback Key Translator\"\n"
2970
2
"key Tab : \"\\t\" \0"
2971
0
3
2972
=== added file 'src/plugin/konsole/Emulation.cpp'
2973
--- src/plugin/konsole/Emulation.cpp	1970-01-01 00:00:00 +0000
2974
+++ src/plugin/konsole/Emulation.cpp	2014-05-06 21:50:22 +0000
2975
@@ -0,0 +1,458 @@
2976
1
/*
2977
2
    Copyright 2007-2008 Robert Knight <robertknight@gmail.com> 
2978
3
    Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
2979
4
    Copyright 1996 by Matthias Ettrich <ettrich@kde.org>
2980
5
2981
6
    This program is free software; you can redistribute it and/or modify
2982
7
    it under the terms of the GNU General Public License as published by
2983
8
    the Free Software Foundation; either version 2 of the License, or
2984
9
    (at your option) any later version.
2985
10
2986
11
    This program is distributed in the hope that it will be useful,
2987
12
    but WITHOUT ANY WARRANTY; without even the implied warranty of
2988
13
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2989
14
    GNU General Public License for more details.
2990
15
2991
16
    You should have received a copy of the GNU General Public License
2992
17
    along with this program; if not, write to the Free Software
2993
18
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
2994
19
    02110-1301  USA.
2995
20
*/
2996
21
2997
22
// Own
2998
23
#include "Emulation.h"
2999
24
3000
25
// System
3001
26
#include <assert.h>
3002
27
#include <stdio.h>
3003
28
#include <stdlib.h>
3004
29
#include <unistd.h>
3005
30
3006
31
// Qt
3007
32
#include <QGuiApplication>
3008
33
#include <QtGui/QClipboard>
3009
34
#include <QtCore/QHash>
3010
35
#include <QtGui/QKeyEvent>
3011
36
#include <QtCore/QRegExp>
3012
37
#include <QtCore/QTextStream>
3013
38
#include <QtCore/QThread>
3014
39
3015
40
#include <QtCore/QTime>
3016
41
3017
42
// KDE
3018
43
//#include <kdebug.h>
3019
44
3020
45
// Konsole
3021
46
#include "KeyboardTranslator.h"
3022
47
#include "Screen.h"
3023
48
#include "TerminalCharacterDecoder.h"
3024
49
#include "ScreenWindow.h"
3025
50
3026
51
Emulation::Emulation() :
3027
52
  _currentScreen(0),
3028
53
  _codec(0),
3029
54
  _decoder(0),
3030
55
  _keyTranslator(0),
3031
56
  _usesMouse(false)
3032
57
{
3033
58
  // create screens with a default size
3034
59
  _screen[0] = new Screen(40,80);
3035
60
  _screen[1] = new Screen(40,80);
3036
61
  _currentScreen = _screen[0];
3037
62
3038
63
  QObject::connect(&_bulkTimer1, SIGNAL(timeout()), this, SLOT(showBulk()) );
3039
64
  QObject::connect(&_bulkTimer2, SIGNAL(timeout()), this, SLOT(showBulk()) );
3040
65
   
3041
66
  // listen for mouse status changes
3042
67
  connect( this , SIGNAL(programUsesMouseChanged(bool)) , 
3043
68
           SLOT(usesMouseChanged(bool)) );
3044
69
}
3045
70
3046
71
bool Emulation::programUsesMouse() const
3047
72
{
3048
73
    return _usesMouse;
3049
74
}
3050
75
3051
76
void Emulation::usesMouseChanged(bool usesMouse)
3052
77
{
3053
78
    _usesMouse = usesMouse;
3054
79
}
3055
80
3056
81
ScreenWindow* Emulation::createWindow()
3057
82
{
3058
83
    ScreenWindow* window = new ScreenWindow();
3059
84
    window->setScreen(_currentScreen);
3060
85
    _windows << window;
3061
86
3062
87
    connect(window , SIGNAL(selectionChanged()),
3063
88
            this , SLOT(bufferedUpdate()));
3064
89
3065
90
    connect(this , SIGNAL(outputChanged()),
3066
91
            window , SLOT(notifyOutputChanged()) );
3067
92
    return window;
3068
93
}
3069
94
3070
95
Emulation::~Emulation()
3071
96
{
3072
97
  QListIterator<ScreenWindow*> windowIter(_windows);
3073
98
3074
99
  while (windowIter.hasNext())
3075
100
  {
3076
101
    delete windowIter.next();
3077
102
  }
3078
103
3079
104
  delete _screen[0];
3080
105
  delete _screen[1];
3081
106
  delete _decoder;
3082
107
}
3083
108
3084
109
void Emulation::setScreen(int n)
3085
110
{
3086
111
  Screen *old = _currentScreen;
3087
112
  _currentScreen = _screen[n & 1];
3088
113
  if (_currentScreen != old) 
3089
114
  {
3090
115
     // tell all windows onto this emulation to switch to the newly active screen
3091
116
     foreach(ScreenWindow* window,_windows)
3092
117
         window->setScreen(_currentScreen);
3093
118
  }
3094
119
}
3095
120
3096
121
void Emulation::clearHistory()
3097
122
{
3098
123
    _screen[0]->setScroll( _screen[0]->getScroll() , false );
3099
124
}
3100
125
void Emulation::setHistory(const HistoryType& t)
3101
126
{
3102
127
  _screen[0]->setScroll(t);
3103
128
3104
129
  showBulk();
3105
130
}
3106
131
3107
132
const HistoryType& Emulation::history() const
3108
133
{
3109
134
  return _screen[0]->getScroll();
3110
135
}
3111
136
3112
137
void Emulation::setCodec(const QTextCodec * qtc)
3113
138
{
3114
139
  if (qtc)
3115
140
      _codec = qtc;
3116
141
  else
3117
142
     setCodec(LocaleCodec);
3118
143
3119
144
  delete _decoder;
3120
145
  _decoder = _codec->makeDecoder();
3121
146
3122
147
  emit useUtf8Request(utf8());
3123
148
}
3124
149
3125
150
void Emulation::setCodec(EmulationCodec codec)
3126
151
{
3127
152
    if ( codec == Utf8Codec )
3128
153
        setCodec( QTextCodec::codecForName("utf8") );
3129
154
    else if ( codec == LocaleCodec )
3130
155
        setCodec( QTextCodec::codecForLocale() );
3131
156
}
3132
157
3133
158
void Emulation::setKeyBindings(const QString& name)
3134
159
{
3135
160
  _keyTranslator = KeyboardTranslatorManager::instance()->findTranslator(name);
3136
161
  if (!_keyTranslator)
3137
162
  {
3138
163
      _keyTranslator = KeyboardTranslatorManager::instance()->defaultTranslator();
3139
164
  }
3140
165
}
3141
166
3142
167
QString Emulation::keyBindings() const
3143
168
{
3144
169
  return _keyTranslator->name();
3145
170
}
3146
171
3147
172
void Emulation::receiveChar(int c)
3148
173
// process application unicode input to terminal
3149
174
// this is a trivial scanner
3150
175
{
3151
176
  c &= 0xff;
3152
177
  switch (c)
3153
178
  {
3154
179
    case '\b'      : _currentScreen->backspace();                 break;
3155
180
    case '\t'      : _currentScreen->tab();                       break;
3156
181
    case '\n'      : _currentScreen->newLine();                   break;
3157
182
    case '\r'      : _currentScreen->toStartOfLine();             break;
3158
183
    case 0x07      : emit stateSet(NOTIFYBELL);
3159
184
                     break;
3160
185
    default        : _currentScreen->displayCharacter(c);         break;
3161
186
  };
3162
187
}
3163
188
3164
189
void Emulation::sendKeyEvent( QKeyEvent* ev )
3165
190
{
3166
191
  emit stateSet(NOTIFYNORMAL);
3167
192
  
3168
193
  if (!ev->text().isEmpty())
3169
194
  { // A block of text
3170
195
    // Note that the text is proper unicode.
3171
196
    // We should do a conversion here
3172
197
    emit sendData(ev->text().toUtf8(),ev->text().length());
3173
198
  }
3174
199
}
3175
200
3176
201
void Emulation::sendString(const char*,int)
3177
202
{
3178
203
    // default implementation does nothing
3179
204
}
3180
205
3181
206
void Emulation::sendMouseEvent(int /*buttons*/, int /*column*/, int /*row*/, int /*eventType*/)
3182
207
{
3183
208
    // default implementation does nothing
3184
209
}
3185
210
3186
211
/*
3187
212
   We are doing code conversion from locale to unicode first.
3188
213
TODO: Character composition from the old code.  See #96536
3189
214
*/
3190
215
3191
216
void Emulation::receiveData(const char* text, int length)
3192
217
{
3193
218
    emit stateSet(NOTIFYACTIVITY);
3194
219
3195
220
    bufferedUpdate();
3196
221
        
3197
222
    QString unicodeText = _decoder->toUnicode(text,length);
3198
223
3199
224
    //send characters to terminal emulator
3200
225
    for (int i=0;i<unicodeText.length();i++)
3201
226
        receiveChar(unicodeText[i].unicode());
3202
227
3203
228
    //look for z-modem indicator
3204
229
    //-- someone who understands more about z-modems that I do may be able to move
3205
230
    //this check into the above for loop?
3206
231
    for (int i=0;i<length;i++)
3207
232
    {
3208
233
        if (text[i] == '\030')
3209
234
        {
3210
235
            if ((length-i-1 > 3) && (strncmp(text+i+1, "B00", 3) == 0))
3211
236
                emit zmodemDetected();
3212
237
        }
3213
238
    }
3214
239
}
3215
240
3216
241
//OLDER VERSION
3217
242
//This version of onRcvBlock was commented out because
3218
243
//    a)  It decoded incoming characters one-by-one, which is slow in the current version of Qt (4.2 tech preview)
3219
244
//    b)  It messed up decoding of non-ASCII characters, with the result that (for example) chinese characters
3220
245
//        were not printed properly.
3221
246
//
3222
247
//There is something about stopping the _decoder if "we get a control code halfway a multi-byte sequence" (see below)
3223
248
//which hasn't been ported into the newer function (above).  Hopefully someone who understands this better
3224
249
//can find an alternative way of handling the check.  
3225
250
3226
251
3227
252
/*void Emulation::onRcvBlock(const char *s, int len)
3228
253
{
3229
254
  emit notifySessionState(NOTIFYACTIVITY);
3230
255
  
3231
256
  bufferedUpdate();
3232
257
  for (int i = 0; i < len; i++)
3233
258
  {
3234
259
3235
260
    QString result = _decoder->toUnicode(&s[i],1);
3236
261
    int reslen = result.length();
3237
262
3238
263
    // If we get a control code halfway a multi-byte sequence
3239
264
    // we flush the _decoder and continue with the control code.
3240
265
    if ((s[i] < 32) && (s[i] > 0))
3241
266
    {
3242
267
       // Flush _decoder
3243
268
       while(!result.length())
3244
269
          result = _decoder->toUnicode(&s[i],1);
3245
270
       reslen = 1;
3246
271
       result.resize(reslen);
3247
272
       result[0] = QChar(s[i]);
3248
273
    }
3249
274
3250
275
    for (int j = 0; j < reslen; j++)
3251
276
    {
3252
277
      if (result[j].characterategory() == QChar::Mark_NonSpacing)
3253
278
         _currentScreen->compose(result.mid(j,1));
3254
279
      else
3255
280
         onRcvChar(result[j].unicode());
3256
281
    }
3257
282
    if (s[i] == '\030')
3258
283
    {
3259
284
      if ((len-i-1 > 3) && (strncmp(s+i+1, "B00", 3) == 0))
3260
285
          emit zmodemDetected();
3261
286
    }
3262
287
  }
3263
288
}*/
3264
289
3265
290
void Emulation::writeToStream( TerminalCharacterDecoder* _decoder , 
3266
291
                               int startLine ,
3267
292
                               int endLine) 
3268
293
{
3269
294
  _currentScreen->writeLinesToStream(_decoder,startLine,endLine);
3270
295
}
3271
296
3272
297
int Emulation::lineCount() const
3273
298
{
3274
299
    // sum number of lines currently on _screen plus number of lines in history
3275
300
    return _currentScreen->getLines() + _currentScreen->getHistLines();
3276
301
}
3277
302
3278
303
#define BULK_TIMEOUT1 10
3279
304
#define BULK_TIMEOUT2 40
3280
305
3281
306
void Emulation::showBulk()
3282
307
{
3283
308
    _bulkTimer1.stop();
3284
309
    _bulkTimer2.stop();
3285
310
3286
311
    emit outputChanged();
3287
312
3288
313
    _currentScreen->resetScrolledLines();
3289
314
    _currentScreen->resetDroppedLines();
3290
315
}
3291
316
3292
317
void Emulation::bufferedUpdate()
3293
318
{
3294
319
   _bulkTimer1.setSingleShot(true);
3295
320
   _bulkTimer1.start(BULK_TIMEOUT1);
3296
321
   if (!_bulkTimer2.isActive())
3297
322
   {
3298
323
      _bulkTimer2.setSingleShot(true);
3299
324
      _bulkTimer2.start(BULK_TIMEOUT2);
3300
325
   }
3301
326
}
3302
327
3303
328
char Emulation::eraseChar() const
3304
329
{
3305
330
  return '\b';
3306
331
}
3307
332
3308
333
void Emulation::setImageSize(int lines, int columns)
3309
334
{
3310
335
  if ((lines < 1) || (columns < 1)) 
3311
336
    return;
3312
337
3313
338
  QSize screenSize[2] = { QSize(_screen[0]->getColumns(),
3314
339
                                _screen[0]->getLines()),
3315
340
                          QSize(_screen[1]->getColumns(),
3316
341
                                _screen[1]->getLines()) };
3317
342
  QSize newSize(columns,lines);
3318
343
3319
344
  if (newSize == screenSize[0] && newSize == screenSize[1])
3320
345
    return;    
3321
346
3322
347
  _screen[0]->resizeImage(lines,columns);
3323
348
  _screen[1]->resizeImage(lines,columns);
3324
349
3325
350
  emit imageSizeChanged(lines,columns);
3326
351
3327
352
  bufferedUpdate();
3328
353
}
3329
354
3330
355
QSize Emulation::imageSize() const
3331
356
{
3332
357
  return QSize(_currentScreen->getColumns(), _currentScreen->getLines());
3333
358
}
3334
359
3335
360
ushort ExtendedCharTable::extendedCharHash(ushort* unicodePoints , ushort length) const
3336
361
{
3337
362
    ushort hash = 0;
3338
363
    for ( ushort i = 0 ; i < length ; i++ )
3339
364
    {
3340
365
        hash = 31*hash + unicodePoints[i];
3341
366
    }
3342
367
    return hash;
3343
368
}
3344
369
bool ExtendedCharTable::extendedCharMatch(ushort hash , ushort* unicodePoints , ushort length) const
3345
370
{
3346
371
    ushort* entry = extendedCharTable[hash];
3347
372
3348
373
    // compare given length with stored sequence length ( given as the first ushort in the 
3349
374
    // stored buffer ) 
3350
375
    if ( entry == 0 || entry[0] != length ) 
3351
376
       return false;
3352
377
    // if the lengths match, each character must be checked.  the stored buffer starts at
3353
378
    // entry[1]
3354
379
    for ( int i = 0 ; i < length ; i++ )
3355
380
    {
3356
381
        if ( entry[i+1] != unicodePoints[i] )
3357
382
           return false; 
3358
383
    } 
3359
384
    return true;
3360
385
}
3361
386
ushort ExtendedCharTable::createExtendedChar(ushort* unicodePoints , ushort length)
3362
387
{
3363
388
    // look for this sequence of points in the table
3364
389
    ushort hash = extendedCharHash(unicodePoints,length);
3365
390
3366
391
    // check existing entry for match
3367
392
    while ( extendedCharTable.contains(hash) )
3368
393
    {
3369
394
        if ( extendedCharMatch(hash,unicodePoints,length) )
3370
395
        {
3371
396
            // this sequence already has an entry in the table, 
3372
397
            // return its hash
3373
398
            return hash;
3374
399
        }
3375
400
        else
3376
401
        {
3377
402
            // if hash is already used by another, different sequence of unicode character
3378
403
            // points then try next hash
3379
404
            hash++;
3380
405
        }
3381
406
    }    
3382
407
3383
408
    
3384
409
     // add the new sequence to the table and
3385
410
     // return that index
3386
411
    ushort* buffer = new ushort[length+1];
3387
412
    buffer[0] = length;
3388
413
    for ( int i = 0 ; i < length ; i++ )
3389
414
       buffer[i+1] = unicodePoints[i]; 
3390
415
    
3391
416
    extendedCharTable.insert(hash,buffer);
3392
417
3393
418
    return hash;
3394
419
}
3395
420
3396
421
ushort* ExtendedCharTable::lookupExtendedChar(ushort hash , ushort& length) const
3397
422
{
3398
423
    // lookup index in table and if found, set the length
3399
424
    // argument and return a pointer to the character sequence
3400
425
3401
426
    ushort* buffer = extendedCharTable[hash];
3402
427
    if ( buffer )
3403
428
    {
3404
429
        length = buffer[0];
3405
430
        return buffer+1;
3406
431
    }
3407
432
    else
3408
433
    {
3409
434
        length = 0;
3410
435
        return 0;
3411
436
    }
3412
437
}
3413
438
3414
439
ExtendedCharTable::ExtendedCharTable()
3415
440
{
3416
441
}
3417
442
ExtendedCharTable::~ExtendedCharTable()
3418
443
{
3419
444
    // free all allocated character buffers
3420
445
    QHashIterator<ushort,ushort*> iter(extendedCharTable);
3421
446
    while ( iter.hasNext() )
3422
447
    {
3423
448
        iter.next();
3424
449
        delete[] iter.value();
3425
450
    }
3426
451
}
3427
452
3428
453
// global instance
3429
454
ExtendedCharTable ExtendedCharTable::instance;
3430
455
3431
456
3432
457
//#include "Emulation.moc"
3433
458
3434
0
459
3435
=== added file 'src/plugin/konsole/Emulation.h'
3436
--- src/plugin/konsole/Emulation.h	1970-01-01 00:00:00 +0000
3437
+++ src/plugin/konsole/Emulation.h	2014-05-06 21:50:22 +0000
3438
@@ -0,0 +1,467 @@
3439
1
/*
3440
2
    This file is part of Konsole, an X terminal.
3441
3
    
3442
4
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
3443
5
    Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
3444
6
3445
7
    This program is free software; you can redistribute it and/or modify
3446
8
    it under the terms of the GNU General Public License as published by
3447
9
    the Free Software Foundation; either version 2 of the License, or
3448
10
    (at your option) any later version.
3449
11
3450
12
    This program is distributed in the hope that it will be useful,
3451
13
    but WITHOUT ANY WARRANTY; without even the implied warranty of
3452
14
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3453
15
    GNU General Public License for more details.
3454
16
3455
17
    You should have received a copy of the GNU General Public License
3456
18
    along with this program; if not, write to the Free Software
3457
19
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
3458
20
    02110-1301  USA.
3459
21
*/
3460
22
3461
23
#ifndef EMULATION_H
3462
24
#define EMULATION_H
3463
25
3464
26
// System
3465
27
#include <stdio.h>
3466
28
3467
29
// Qt 
3468
30
#include <QtGui/QKeyEvent>
3469
31
//#include <QPointer>
3470
32
#include <QtCore/QTextCodec>
3471
33
#include <QtCore/QTextStream>
3472
34
#include <QtCore/QTimer>
3473
35
3474
36
// Konsole
3475
37
//#include "konsole_export.h"
3476
38
#define KONSOLEPRIVATE_EXPORT
3477
39
3478
40
class KeyboardTranslator;
3479
41
class HistoryType;
3480
42
class Screen;
3481
43
class ScreenWindow;
3482
44
class TerminalCharacterDecoder;
3483
45
3484
46
/** 
3485
47
 * This enum describes the available states which 
3486
48
 * the terminal emulation may be set to.
3487
49
 *
3488
50
 * These are the values used by Emulation::stateChanged() 
3489
51
 */
3490
52
enum 
3491
53
{ 
3492
54
    /** The emulation is currently receiving user input. */
3493
55
    NOTIFYNORMAL=0, 
3494
56
    /** 
3495
57
     * The terminal program has triggered a bell event
3496
58
     * to get the user's attention.
3497
59
     */
3498
60
    NOTIFYBELL=1, 
3499
61
    /** 
3500
62
     * The emulation is currently receiving data from its 
3501
63
     * terminal input.
3502
64
     */
3503
65
    NOTIFYACTIVITY=2,
3504
66
3505
67
    // unused here? 
3506
68
    NOTIFYSILENCE=3 
3507
69
};
3508
70
3509
71
/**
3510
72
 * Base class for terminal emulation back-ends.
3511
73
 *
3512
74
 * The back-end is responsible for decoding an incoming character stream and 
3513
75
 * producing an output image of characters.
3514
76
 *
3515
77
 * When input from the terminal is received, the receiveData() slot should be called with
3516
78
 * the data which has arrived.  The emulation will process the data and update the 
3517
79
 * screen image accordingly.  The codec used to decode the incoming character stream
3518
80
 * into the unicode characters used internally can be specified using setCodec() 
3519
81
 *
3520
82
 * The size of the screen image can be specified by calling setImageSize() with the 
3521
83
 * desired number of lines and columns.  When new lines are added, old content
3522
84
 * is moved into a history store, which can be set by calling setHistory(). 
3523
85
 *
3524
86
 * The screen image can be accessed by creating a ScreenWindow onto this emulation 
3525
87
 * by calling createWindow().  Screen windows provide access to a section of the 
3526
88
 * output.  Each screen window covers the same number of lines and columns as the 
3527
89
 * image size returned by imageSize().  The screen window can be moved up and down
3528
90
 * and provides transparent access to both the current on-screen image and the 
3529
91
 * previous output.  The screen windows emit an outputChanged signal
3530
92
 * when the section of the image they are looking at changes.
3531
93
 * Graphical views can then render the contents of a screen window, listening for notifications
3532
94
 * of output changes from the screen window which they are associated with and updating 
3533
95
 * accordingly. 
3534
96
 *
3535
97
 * The emulation also is also responsible for converting input from the connected views such
3536
98
 * as keypresses and mouse activity into a character string which can be sent
3537
99
 * to the terminal program.  Key presses can be processed by calling the sendKeyEvent() slot,
3538
100
 * while mouse events can be processed using the sendMouseEvent() slot.  When the character
3539
101
 * stream has been produced, the emulation will emit a sendData() signal with a pointer
3540
102
 * to the character buffer.  This data should be fed to the standard input of the terminal
3541
103
 * process.  The translation of key presses into an output character stream is performed
3542
104
 * using a lookup in a set of key bindings which map key sequences to output
3543
105
 * character sequences.  The name of the key bindings set used can be specified using
3544
106
 * setKeyBindings()
3545
107
 *
3546
108
 * The emulation maintains certain state information which changes depending on the 
3547
109
 * input received.  The emulation can be reset back to its starting state by calling 
3548
110
 * reset().  
3549
111
 *
3550
112
 * The emulation also maintains an activity state, which specifies whether
3551
113
 * terminal is currently active ( when data is received ), normal
3552
114
 * ( when the terminal is idle or receiving user input ) or trying
3553
115
 * to alert the user ( also known as a "Bell" event ).  The stateSet() signal
3554
116
 * is emitted whenever the activity state is set.  This can be used to determine
3555
117
 * how long the emulation has been active/idle for and also respond to
3556
118
 * a 'bell' event in different ways.
3557
119
 */
3558
120
class KONSOLEPRIVATE_EXPORT Emulation : public QObject
3559
121
{ 
3560
122
Q_OBJECT
3561
123
3562
124
public:
3563
125
 
3564
126
   /** Constructs a new terminal emulation */ 
3565
127
   Emulation();
3566
128
  ~Emulation();
3567
129
3568
130
  /**
3569
131
   * Creates a new window onto the output from this emulation.  The contents
3570
132
   * of the window are then rendered by views which are set to use this window using the
3571
133
   * TerminalDisplay::setScreenWindow() method.
3572
134
   */
3573
135
  ScreenWindow* createWindow();
3574
136
3575
137
  /** Returns the size of the screen image which the emulation produces */
3576
138
  QSize imageSize() const;
3577
139
3578
140
  /**
3579
141
   * Returns the total number of lines, including those stored in the history.
3580
142
   */ 
3581
143
  int lineCount() const;
3582
144
3583
145
  /** 
3584
146
   * Sets the history store used by this emulation.  When new lines
3585
147
   * are added to the output, older lines at the top of the screen are transferred to a history
3586
148
   * store.   
3587
149
   *
3588
150
   * The number of lines which are kept and the storage location depend on the 
3589
151
   * type of store.
3590
152
   */
3591
153
  void setHistory(const HistoryType&);
3592
154
  /** Returns the history store used by this emulation.  See setHistory() */
3593
155
  const HistoryType& history() const;
3594
156
  /** Clears the history scroll. */
3595
157
  void clearHistory();
3596
158
3597
159
  /** 
3598
160
   * Copies the output history from @p startLine to @p endLine 
3599
161
   * into @p stream, using @p decoder to convert the terminal
3600
162
   * characters into text. 
3601
163
   *
3602
164
   * @param decoder A decoder which converts lines of terminal characters with 
3603
165
   * appearance attributes into output text.  PlainTextDecoder is the most commonly
3604
166
   * used decoder.
3605
167
   * @param startLine Index of first line to copy
3606
168
   * @param endLine Index of last line to copy
3607
169
   */
3608
170
  virtual void writeToStream(TerminalCharacterDecoder* decoder,int startLine,int endLine);
3609
171
  
3610
172
  /** Returns the codec used to decode incoming characters.  See setCodec() */
3611
173
  const QTextCodec* codec() const { return _codec; }
3612
174
  /** Sets the codec used to decode incoming characters.  */
3613
175
  void setCodec(const QTextCodec*);
3614
176
3615
177
  /** 
3616
178
   * Convenience method.  
3617
179
   * Returns true if the current codec used to decode incoming
3618
180
   * characters is UTF-8
3619
181
   */
3620
182
  bool utf8() const
3621
183
  { Q_ASSERT(_codec); return _codec->mibEnum() == 106; }
3622
184
  
3623
185
3624
186
  /** TODO Document me */
3625
187
  virtual char eraseChar() const;
3626
188
3627
189
  /** 
3628
190
   * Sets the key bindings used to key events
3629
191
   * ( received through sendKeyEvent() ) into character
3630
192
   * streams to send to the terminal.
3631
193
   */
3632
194
  void setKeyBindings(const QString& name);
3633
195
  /** 
3634
196
   * Returns the name of the emulation's current key bindings.
3635
197
   * See setKeyBindings()
3636
198
   */
3637
199
  QString keyBindings() const;
3638
200
3639
201
  /** 
3640
202
   * Copies the current image into the history and clears the screen.
3641
203
   */
3642
204
  virtual void clearEntireScreen() =0;
3643
205
3644
206
  /** Resets the state of the terminal. */
3645
207
  virtual void reset() =0;
3646
208
3647
209
  /** 
3648
210
   * Returns true if the active terminal program wants
3649
211
   * mouse input events.
3650
212
   *
3651
213
   * The programUsesMouseChanged() signal is emitted when this
3652
214
   * changes.
3653
215
   */
3654
216
  bool programUsesMouse() const;
3655
217
3656
218
public slots: 
3657
219
3658
220
  /** Change the size of the emulation's image */
3659
221
  virtual void setImageSize(int lines, int columns);
3660
222
  
3661
223
  /** 
3662
224
   * Interprets a sequence of characters and sends the result to the terminal.
3663
225
   * This is equivalent to calling sendKeyEvent() for each character in @p text in succession.
3664
226
   */
3665
227
  virtual void sendText(const QString& text) = 0;
3666
228
3667
229
  /** 
3668
230
   * Interprets a key press event and emits the sendData() signal with
3669
231
   * the resulting character stream. 
3670
232
   */
3671
233
  virtual void sendKeyEvent(QKeyEvent*);
3672
234
 
3673
235
  /** 
3674
236
   * Converts information about a mouse event into an xterm-compatible escape
3675
237
   * sequence and emits the character sequence via sendData()
3676
238
   */
3677
239
  virtual void sendMouseEvent(int buttons, int column, int line, int eventType);
3678
240
  
3679
241
  /**
3680
242
   * Sends a string of characters to the foreground terminal process. 
3681
243
   *
3682
244
   * @param string The characters to send.  
3683
245
   * @param length Length of @p string or if set to a negative value, @p string will
3684
246
   * be treated as a null-terminated string and its length will be determined automatically.
3685
247
   */
3686
248
  virtual void sendString(const char* string, int length = -1) = 0;
3687
249
3688
250
  /** 
3689
251
   * Processes an incoming stream of characters.  receiveData() decodes the incoming
3690
252
   * character buffer using the current codec(), and then calls receiveChar() for
3691
253
   * each unicode character in the resulting buffer.  
3692
254
   *
3693
255
   * receiveData() also starts a timer which causes the outputChanged() signal
3694
256
   * to be emitted when it expires.  The timer allows multiple updates in quick
3695
257
   * succession to be buffered into a single outputChanged() signal emission.
3696
258
   *
3697
259
   * @param buffer A string of characters received from the terminal program.
3698
260
   * @param len The length of @p buffer
3699
261
   */
3700
262
  void receiveData(const char* buffer,int len);
3701
263
3702
264
signals:
3703
265
3704
266
  /** 
3705
267
   * Emitted when a buffer of data is ready to send to the 
3706
268
   * standard input of the terminal.
3707
269
   *
3708
270
   * @param data The buffer of data ready to be sent
3709
271
   * @param len The length of @p data in bytes
3710
272
   */
3711
273
  void sendData(const char* data,int len);
3712
274
3713
275
  /** 
3714
276
   * Requests that sending of input to the emulation
3715
277
   * from the terminal process be suspended or resumed.
3716
278
   *
3717
279
   * @param suspend If true, requests that sending of 
3718
280
   * input from the terminal process' stdout be 
3719
281
   * suspended.  Otherwise requests that sending of
3720
282
   * input be resumed. 
3721
283
   */
3722
284
  void lockPtyRequest(bool suspend);
3723
285
3724
286
  /**
3725
287
   * Requests that the pty used by the terminal process
3726
288
   * be set to UTF 8 mode.  
3727
289
   *
3728
290
   * TODO: More documentation
3729
291
   */
3730
292
  void useUtf8Request(bool);
3731
293
3732
294
  /**
3733
295
   * Emitted when the activity state of the emulation is set.
3734
296
   *
3735
297
   * @param state The new activity state, one of NOTIFYNORMAL, NOTIFYACTIVITY
3736
298
   * or NOTIFYBELL
3737
299
   */
3738
300
  void stateSet(int state);
3739
301
3740
302
  /** TODO Document me */
3741
303
  void zmodemDetected();
3742
304
3743
305
3744
306
  /**
3745
307
   * Requests that the color of the text used
3746
308
   * to represent the tabs associated with this
3747
309
   * emulation be changed.  This is a Konsole-specific
3748
310
   * extension from pre-KDE 4 times.
3749
311
   *
3750
312
   * TODO: Document how the parameter works.
3751
313
   */
3752
314
  void changeTabTextColorRequest(int color);
3753
315
3754
316
  /** 
3755
317
   * This is emitted when the program running in the shell indicates whether or
3756
318
   * not it is interested in mouse events.
3757
319
   *
3758
320
   * @param usesMouse This will be true if the program wants to be informed about
3759
321
   * mouse events or false otherwise.
3760
322
   */
3761
323
  void programUsesMouseChanged(bool usesMouse);
3762
324
3763
325
  /** 
3764
326
   * Emitted when the contents of the screen image change.
3765
327
   * The emulation buffers the updates from successive image changes,
3766
328
   * and only emits outputChanged() at sensible intervals when
3767
329
   * there is a lot of terminal activity.
3768
330
   *
3769
331
   * Normally there is no need for objects other than the screen windows
3770
332
   * created with createWindow() to listen for this signal.
3771
333
   *
3772
334
   * ScreenWindow objects created using createWindow() will emit their
3773
335
   * own outputChanged() signal in response to this signal. 
3774
336
   */
3775
337
  void outputChanged();
3776
338
3777
339
  /**
3778
340
   * Emitted when the program running in the terminal wishes to update the 
3779
341
   * session's title.  This also allows terminal programs to customize other
3780
342
   * aspects of the terminal emulation display. 
3781
343
   *
3782
344
   * This signal is emitted when the escape sequence "\033]ARG;VALUE\007"
3783
345
   * is received in the input string, where ARG is a number specifying what
3784
346
   * should change and VALUE is a string specifying the new value.
3785
347
   *
3786
348
   * TODO:  The name of this method is not very accurate since this method
3787
349
   * is used to perform a whole range of tasks besides just setting
3788
350
   * the user-title of the session.    
3789
351
   *
3790
352
   * @param title Specifies what to change.
3791
353
   * <ul>
3792
354
   * <li>0 - Set window icon text and session title to @p newTitle</li>
3793
355
   * <li>1 - Set window icon text to @p newTitle</li>
3794
356
   * <li>2 - Set session title to @p newTitle</li>
3795
357
   * <li>11 - Set the session's default background color to @p newTitle,
3796
358
   *         where @p newTitle can be an HTML-style string ("#RRGGBB") or a named
3797
359
   *         color (eg 'red', 'blue').  
3798
360
   *         See http://doc.trolltech.com/4.2/qcolor.html#setNamedColor for more
3799
361
   *         details.
3800
362
   * </li>
3801
363
   * <li>31 - Supposedly treats @p newTitle as a URL and opens it (NOT IMPLEMENTED)</li>
3802
364
   * <li>32 - Sets the icon associated with the session.  @p newTitle is the name 
3803
365
   *    of the icon to use, which can be the name of any icon in the current KDE icon
3804
366
   *    theme (eg: 'konsole', 'kate', 'folder_home')</li>
3805
367
   * </ul>
3806
368
   * @param newTitle Specifies the new title 
3807
369
   */
3808
370
3809
371
  void titleChanged(int title,const QString& newTitle);
3810
372
3811
373
  /**
3812
374
   * Emitted when the program running in the terminal changes the
3813
375
   * screen size.
3814
376
   */
3815
377
  void imageSizeChanged(int lineCount , int columnCount);
3816
378
3817
379
  /** 
3818
380
   * Emitted when the terminal program requests to change various properties
3819
381
   * of the terminal display.  
3820
382
   *
3821
383
   * A profile change command occurs when a special escape sequence, followed
3822
384
   * by a string containing a series of name and value pairs is received.
3823
385
   * This string can be parsed using a ProfileCommandParser instance.
3824
386
   *
3825
387
   * @param text A string expected to contain a series of key and value pairs in
3826
388
   * the form:  name=value;name2=value2 ...
3827
389
   */
3828
390
  void profileChangeCommandReceived(const QString& text);
3829
391
3830
392
  /** 
3831
393
   * Emitted when a flow control key combination ( Ctrl+S or Ctrl+Q ) is pressed.
3832
394
   * @param suspendKeyPressed True if Ctrl+S was pressed to suspend output or Ctrl+Q to
3833
395
   * resume output.
3834
396
   */
3835
397
  void flowControlKeyPressed(bool suspendKeyPressed);
3836
398
3837
399
protected:
3838
400
  virtual void setMode(int mode) = 0;
3839
401
  virtual void resetMode(int mode) = 0;
3840
402
   
3841
403
  /** 
3842
404
   * Processes an incoming character.  See receiveData()
3843
405
   * @p ch A unicode character code. 
3844
406
   */
3845
407
  virtual void receiveChar(int ch);
3846
408
3847
409
  /** 
3848
410
   * Sets the active screen.  The terminal has two screens, primary and alternate.
3849
411
   * The primary screen is used by default.  When certain interactive programs such
3850
412
   * as Vim are run, they trigger a switch to the alternate screen.
3851
413
   *
3852
414
   * @param index 0 to switch to the primary screen, or 1 to switch to the alternate screen
3853
415
   */
3854
416
  void setScreen(int index); 
3855
417
3856
418
  enum EmulationCodec
3857
419
  {
3858
420
      LocaleCodec = 0,
3859
421
      Utf8Codec   = 1
3860
422
  };
3861
423
  void setCodec(EmulationCodec codec); // codec number, 0 = locale, 1=utf8
3862
424
3863
425
3864
426
  QList<ScreenWindow*> _windows;
3865
427
  
3866
428
  Screen* _currentScreen;  // pointer to the screen which is currently active, 
3867
429
                            // this is one of the elements in the screen[] array
3868
430
3869
431
  Screen* _screen[2];      // 0 = primary screen ( used by most programs, including the shell
3870
432
                            //                      scrollbars are enabled in this mode )
3871
433
                            // 1 = alternate      ( used by vi , emacs etc.
3872
434
                            //                      scrollbars are not enabled in this mode )
3873
435
                            
3874
436
  
3875
437
  //decodes an incoming C-style character stream into a unicode QString using 
3876
438
  //the current text codec.  (this allows for rendering of non-ASCII characters in text files etc.)
3877
439
  const QTextCodec* _codec;
3878
440
  QTextDecoder* _decoder;
3879
441
  const KeyboardTranslator* _keyTranslator; // the keyboard layout
3880
442
3881
443
protected slots:
3882
444
  /** 
3883
445
   * Schedules an update of attached views.
3884
446
   * Repeated calls to bufferedUpdate() in close succession will result in only a single update,
3885
447
   * much like the Qt buffered update of widgets. 
3886
448
   */
3887
449
  void bufferedUpdate();
3888
450
3889
451
private slots: 
3890
452
3891
453
  // triggered by timer, causes the emulation to send an updated screen image to each
3892
454
  // view
3893
455
  void showBulk(); 
3894
456
3895
457
  void usesMouseChanged(bool usesMouse);
3896
458
3897
459
private:
3898
460
  bool _usesMouse;
3899
461
  QTimer _bulkTimer1;
3900
462
  QTimer _bulkTimer2;
3901
463
  
3902
464
};
3903
465
3904
466
3905
467
#endif // ifndef EMULATION_H
3906
0
468
3907
=== added file 'src/plugin/konsole/ExtendedDefaultTranslator.h'
3908
--- src/plugin/konsole/ExtendedDefaultTranslator.h	1970-01-01 00:00:00 +0000
3909
+++ src/plugin/konsole/ExtendedDefaultTranslator.h	2014-05-06 21:50:22 +0000
3910
@@ -0,0 +1,74 @@
3911
1
"keyboard \"Default (XFree 4)\""
3912
2
"key Escape             : \"\\E\""
3913
3
"key Tab   -Shift       : \"\\t\"\n"
3914
4
"key Tab   +Shift+Ansi  : \"\\E[Z\"\n"
3915
5
"key Tab   +Shift-Ansi  : \"\\t\"\n"
3916
6
"key Backtab     +Ansi  : \"\\E[Z\"\n"
3917
7
"key Backtab     -Ansi  : \"\\t\"\n"
3918
8
"key Return-Shift-NewLine : \"\\r\"\n"
3919
9
"key Return-Shift+NewLine : \"\\r\\n\"\n"
3920
10
"key Return+Shift         : \"\\EOM\"\n"
3921
11
"key Backspace      : \"\\x7f\"\n"
3922
12
"key Up   -Shift-Ansi : \"\\EA\"\n"
3923
13
"key Down -Shift-Ansi : \"\\EB\"\n"
3924
14
"key Right-Shift-Ansi : \"\\EC\"\n"
3925
15
"key Left -Shift-Ansi : \"\\ED\"\n"
3926
16
"key Up    -Shift-AnyMod+Ansi+AppCuKeys           : \"\\EOA\"\n"
3927
17
"key Down  -Shift-AnyMod+Ansi+AppCuKeys           : \"\\EOB\"\n"
3928
18
"key Right -Shift-AnyMod+Ansi+AppCuKeys           : \"\\EOC\"\n"
3929
19
"key Left  -Shift-AnyMod+Ansi+AppCuKeys           : \"\\EOD\"\n"
3930
20
"key Up    -Shift-AnyMod+Ansi-AppCuKeys           : \"\\E[A\"\n"
3931
21
"key Down  -Shift-AnyMod+Ansi-AppCuKeys           : \"\\E[B\"\n"
3932
22
"key Right -Shift-AnyMod+Ansi-AppCuKeys           : \"\\E[C\"\n"
3933
23
"key Left  -Shift-AnyMod+Ansi-AppCuKeys           : \"\\E[D\"\n"
3934
24
"key Up    -Shift+AnyMod+Ansi                     : \"\\E[1;*A\"\n"
3935
25
"key Down  -Shift+AnyMod+Ansi                     : \"\\E[1;*B\"\n"
3936
26
"key Right -Shift+AnyMod+Ansi                     : \"\\E[1;*C\"\n"
3937
27
"key Left  -Shift+AnyMod+Ansi                     : \"\\E[1;*D\"\n"
3938
28
"key Enter+NewLine : \"\\r\\n\"\n"
3939
29
"key Enter-NewLine : \"\\r\"\n"
3940
30
"key Home        -AnyMod     -AppCuKeys           : \"\\E[H\"  \n"
3941
31
"key End         -AnyMod     -AppCuKeys           : \"\\E[F\"  \n"
3942
32
"key Home        -AnyMod     +AppCuKeys           : \"\\EOH\"  \n"
3943
33
"key End         -AnyMod     +AppCuKeys           : \"\\EOF\"  \n"
3944
34
"key Home        +AnyMod                          : \"\\E[1;*H\"\n"
3945
35
"key End         +AnyMod                          : \"\\E[1;*F\"\n"
3946
36
"key Insert      -AnyMod                          : \"\\E[2~\"\n"
3947
37
"key Delete      -AnyMod                          : \"\\E[3~\"\n"
3948
38
"key Insert      +AnyMod                          : \"\\E[2;*~\"\n"
3949
39
"key Delete      +AnyMod                          : \"\\E[3;*~\"\n"
3950
40
"key Prior -Shift-AnyMod                          : \"\\E[5~\"\n"
3951
41
"key Next  -Shift-AnyMod                          : \"\\E[6~\"\n"
3952
42
"key Prior -Shift+AnyMod                          : \"\\E[5;*~\"\n"
3953
43
"key Next  -Shift+AnyMod                          : \"\\E[6;*~\"\n"
3954
44
"key F1          -AnyMod                          : \"\\EOP\"\n"
3955
45
"key F2          -AnyMod                          : \"\\EOQ\"\n"
3956
46
"key F3          -AnyMod                          : \"\\EOR\"\n"
3957
47
"key F4          -AnyMod                          : \"\\EOS\"\n"
3958
48
"key F5          -AnyMod                          : \"\\E[15~\"\n"
3959
49
"key F6          -AnyMod                          : \"\\E[17~\"\n"
3960
50
"key F7          -AnyMod                          : \"\\E[18~\"\n"
3961
51
"key F8          -AnyMod                          : \"\\E[19~\"\n"
3962
52
"key F9          -AnyMod                          : \"\\E[20~\"\n"
3963
53
"key F10         -AnyMod                          : \"\\E[21~\"\n"
3964
54
"key F11         -AnyMod                          : \"\\E[23~\"\n"
3965
55
"key F12         -AnyMod                          : \"\\E[24~\"\n"
3966
56
"key F1          +AnyMod                          : \"\\EO*P\"\n"
3967
57
"key F2          +AnyMod                          : \"\\EO*Q\"\n"
3968
58
"key F3          +AnyMod                          : \"\\EO*R\"\n"
3969
59
"key F4          +AnyMod                          : \"\\EO*S\"\n"
3970
60
"key F5          +AnyMod                          : \"\\E[15;*~\"\n"
3971
61
"key F6          +AnyMod                          : \"\\E[17;*~\"\n"
3972
62
"key F7          +AnyMod                          : \"\\E[18;*~\"\n"
3973
63
"key F8          +AnyMod                          : \"\\E[19;*~\"\n"
3974
64
"key F9          +AnyMod                          : \"\\E[20;*~\"\n"
3975
65
"key F10         +AnyMod                          : \"\\E[21;*~\"\n"
3976
66
"key F11         +AnyMod                          : \"\\E[23;*~\"\n"
3977
67
"key F12         +AnyMod                          : \"\\E[24;*~\"\n"
3978
68
"key Space +Control : \"\\x00\"\n"
3979
69
"key Up    +Shift-AppScreen  : scrollLineUp\n"
3980
70
"key Prior +Shift-AppScreen  : scrollPageUp\n"
3981
71
"key Down  +Shift-AppScreen  : scrollLineDown\n"
3982
72
"key Next  +Shift-AppScreen  : scrollPageDown\n"
3983
73
"key ScrollLock     : scrollLock\n"
3984
74
"\0"
3985
0
75
3986
=== added file 'src/plugin/konsole/Filter.cpp'
3987
--- src/plugin/konsole/Filter.cpp	1970-01-01 00:00:00 +0000
3988
+++ src/plugin/konsole/Filter.cpp	2014-05-06 21:50:22 +0000
3989
@@ -0,0 +1,542 @@
3990
1
/*
3991
2
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
3992
3
3993
4
    This program is free software; you can redistribute it and/or modify
3994
5
    it under the terms of the GNU General Public License as published by
3995
6
    the Free Software Foundation; either version 2 of the License, or
3996
7
    (at your option) any later version.
3997
8
3998
9
    This program is distributed in the hope that it will be useful,
3999
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
4000
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4001
12
    GNU General Public License for more details.
4002
13
4003
14
    You should have received a copy of the GNU General Public License
4004
15
    along with this program; if not, write to the Free Software
4005
16
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
4006
17
    02110-1301  USA.
4007
18
*/
4008
19
4009
20
// Own
4010
21
#include "Filter.h"
4011
22
4012
23
// System
4013
24
#include <iostream>
4014
25
4015
26
// Qt
4016
27
#include <QtWidgets/QAction>
4017
28
#include <QtWidgets/QApplication>
4018
29
#include <QtGui/QClipboard>
4019
30
#include <QtCore/QString>
4020
31
#include <QtCore/QTextStream>
4021
32
#include <QtCore/QSharedData>
4022
33
#include <QtCore/QFile>
4023
34
#include <QDesktopServices>
4024
35
#include <QUrl>
4025
36
4026
37
// KDE
4027
38
//#include <KLocale>
4028
39
//#include <KRun>
4029
40
4030
41
// Konsole
4031
42
#include "TerminalCharacterDecoder.h"
4032
43
#include "konsole_wcwidth.h"
4033
44
4034
45
4035
46
FilterChain::~FilterChain()
4036
47
{
4037
48
    QMutableListIterator<Filter*> iter(*this);
4038
49
    
4039
50
    while ( iter.hasNext() )
4040
51
    {
4041
52
        Filter* filter = iter.next();
4042
53
        iter.remove();
4043
54
        delete filter;
4044
55
    }
4045
56
}
4046
57
4047
58
void FilterChain::addFilter(Filter* filter)
4048
59
{
4049
60
    append(filter);
4050
61
}
4051
62
void FilterChain::removeFilter(Filter* filter)
4052
63
{
4053
64
    removeAll(filter);
4054
65
}
4055
66
bool FilterChain::containsFilter(Filter* filter)
4056
67
{
4057
68
    return contains(filter);
4058
69
}
4059
70
void FilterChain::reset()
4060
71
{
4061
72
    QListIterator<Filter*> iter(*this);
4062
73
    while (iter.hasNext())
4063
74
        iter.next()->reset();
4064
75
}
4065
76
void FilterChain::setBuffer(const QString* buffer , const QList<int>* linePositions)
4066
77
{
4067
78
    QListIterator<Filter*> iter(*this);
4068
79
    while (iter.hasNext())
4069
80
        iter.next()->setBuffer(buffer,linePositions);
4070
81
}
4071
82
void FilterChain::process()
4072
83
{
4073
84
    QListIterator<Filter*> iter(*this);
4074
85
    while (iter.hasNext())
4075
86
        iter.next()->process();
4076
87
}
4077
88
void FilterChain::clear()
4078
89
{
4079
90
    QList<Filter*>::clear();
4080
91
}
4081
92
Filter::HotSpot* FilterChain::hotSpotAt(int line , int column) const
4082
93
{
4083
94
    QListIterator<Filter*> iter(*this);
4084
95
    while (iter.hasNext())
4085
96
    {
4086
97
        Filter* filter = iter.next();
4087
98
        Filter::HotSpot* spot = filter->hotSpotAt(line,column);
4088
99
        if ( spot != 0 )
4089
100
        {
4090
101
            return spot;
4091
102
        }
4092
103
    }
4093
104
4094
105
    return 0;
4095
106
}
4096
107
4097
108
QList<Filter::HotSpot*> FilterChain::hotSpots() const
4098
109
{
4099
110
    QList<Filter::HotSpot*> list;
4100
111
    QListIterator<Filter*> iter(*this);
4101
112
    while (iter.hasNext())
4102
113
    {
4103
114
        Filter* filter = iter.next();
4104
115
        list << filter->hotSpots();
4105
116
    }
4106
117
    return list;
4107
118
}
4108
119
//QList<Filter::HotSpot*> FilterChain::hotSpotsAtLine(int line) const;
4109
120
4110
121
TerminalImageFilterChain::TerminalImageFilterChain()
4111
122
: _buffer(0)
4112
123
, _linePositions(0)
4113
124
{
4114
125
}
4115
126
4116
127
TerminalImageFilterChain::~TerminalImageFilterChain()
4117
128
{
4118
129
    delete _buffer;
4119
130
    delete _linePositions;
4120
131
}
4121
132
4122
133
void TerminalImageFilterChain::setImage(const Character* const image , int lines , int columns, const QVector<LineProperty>& lineProperties)
4123
134
{
4124
135
    if (empty())
4125
136
        return;
4126
137
4127
138
    // reset all filters and hotspots
4128
139
    reset();
4129
140
4130
141
    PlainTextDecoder decoder;
4131
142
    decoder.setTrailingWhitespace(false);
4132
143
    
4133
144
    // setup new shared buffers for the filters to process on
4134
145
    QString* newBuffer = new QString();
4135
146
    QList<int>* newLinePositions = new QList<int>();
4136
147
    setBuffer( newBuffer , newLinePositions );
4137
148
4138
149
    // free the old buffers
4139
150
    delete _buffer;
4140
151
    delete _linePositions;
4141
152
4142
153
    _buffer = newBuffer;
4143
154
    _linePositions = newLinePositions;
4144
155
4145
156
    QTextStream lineStream(_buffer);
4146
157
    decoder.begin(&lineStream);
4147
158
4148
159
    for (int i=0 ; i < lines ; i++)
4149
160
    {
4150
161
        _linePositions->append(_buffer->length());
4151
162
        decoder.decodeLine(image + i*columns,columns,LINE_DEFAULT);
4152
163
4153
164
        // pretend that each line ends with a newline character.
4154
165
        // this prevents a link that occurs at the end of one line
4155
166
        // being treated as part of a link that occurs at the start of the next line
4156
167
        //
4157
168
        // the downside is that links which are spread over more than one line are not
4158
169
        // highlighted.  
4159
170
        //
4160
171
        // TODO - Use the "line wrapped" attribute associated with lines in a
4161
172
        // terminal image to avoid adding this imaginary character for wrapped
4162
173
        // lines
4163
174
        if ( !(lineProperties.value(i,LINE_DEFAULT) & LINE_WRAPPED) )
4164
175
            lineStream << QChar('\n');
4165
176
    }
4166
177
    decoder.end();
4167
178
}
4168
179
4169
180
Filter::Filter() :
4170
181
_linePositions(0),
4171
182
_buffer(0)
4172
183
{
4173
184
}
4174
185
4175
186
Filter::~Filter()
4176
187
{
4177
188
    QListIterator<HotSpot*> iter(_hotspotList);
4178
189
    while (iter.hasNext())
4179
190
    {
4180
191
        delete iter.next();
4181
192
    }
4182
193
}
4183
194
void Filter::reset()
4184
195
{
4185
196
    _hotspots.clear();
4186
197
    _hotspotList.clear();
4187
198
}
4188
199
4189
200
void Filter::setBuffer(const QString* buffer , const QList<int>* linePositions)
4190
201
{
4191
202
    _buffer = buffer;
4192
203
    _linePositions = linePositions;
4193
204
}
4194
205
4195
206
void Filter::getLineColumn(int position , int& startLine , int& startColumn)
4196
207
{
4197
208
    Q_ASSERT( _linePositions );
4198
209
    Q_ASSERT( _buffer );
4199
210
4200
211
4201
212
    for (int i = 0 ; i < _linePositions->count() ; i++)
4202
213
    {
4203
214
        int nextLine = 0;
4204
215
4205
216
        if ( i == _linePositions->count()-1 )
4206
217
            nextLine = _buffer->length() + 1;
4207
218
        else
4208
219
            nextLine = _linePositions->value(i+1);
4209
220
4210
221
        if ( _linePositions->value(i) <= position && position < nextLine ) 
4211
222
        {
4212
223
            startLine = i;
4213
224
            startColumn = string_width(buffer()->mid(_linePositions->value(i),position - _linePositions->value(i)));
4214
225
            return;
4215
226
        }
4216
227
    }
4217
228
}
4218
229
    
4219
230
4220
231
/*void Filter::addLine(const QString& text)
4221
232
{
4222
233
    _linePositions << _buffer.length();
4223
234
    _buffer.append(text);
4224
235
}*/
4225
236
4226
237
const QString* Filter::buffer()
4227
238
{
4228
239
    return _buffer;
4229
240
}
4230
241
Filter::HotSpot::~HotSpot()
4231
242
{
4232
243
}
4233
244
void Filter::addHotSpot(HotSpot* spot)
4234
245
{
4235
246
    _hotspotList << spot;
4236
247
4237
248
    for (int line = spot->startLine() ; line <= spot->endLine() ; line++)
4238
249
    {
4239
250
        _hotspots.insert(line,spot);
4240
251
    }    
4241
252
}
4242
253
QList<Filter::HotSpot*> Filter::hotSpots() const
4243
254
{
4244
255
    return _hotspotList;
4245
256
}
4246
257
QList<Filter::HotSpot*> Filter::hotSpotsAtLine(int line) const
4247
258
{
4248
259
    return _hotspots.values(line);
4249
260
}
4250
261
4251
262
Filter::HotSpot* Filter::hotSpotAt(int line , int column) const
4252
263
{
4253
264
    QListIterator<HotSpot*> spotIter(_hotspots.values(line));
4254
265
4255
266
    while (spotIter.hasNext())
4256
267
    {
4257
268
        HotSpot* spot = spotIter.next();
4258
269
        
4259
270
        if ( spot->startLine() == line && spot->startColumn() > column )
4260
271
            continue;
4261
272
        if ( spot->endLine() == line && spot->endColumn() < column )
4262
273
            continue;
4263
274
       
4264
275
        return spot;
4265
276
    }
4266
277
4267
278
    return 0;
4268
279
}
4269
280
4270
281
Filter::HotSpot::HotSpot(int startLine , int startColumn , int endLine , int endColumn)
4271
282
    : _startLine(startLine)
4272
283
    , _startColumn(startColumn)
4273
284
    , _endLine(endLine)
4274
285
    , _endColumn(endColumn)
4275
286
    , _type(NotSpecified)
4276
287
{
4277
288
}
4278
289
QString Filter::HotSpot::tooltip() const
4279
290
{
4280
291
    return QString();
4281
292
}
4282
293
QList<QAction*> Filter::HotSpot::actions()
4283
294
{
4284
295
    return QList<QAction*>();
4285
296
}
4286
297
int Filter::HotSpot::startLine() const
4287
298
{
4288
299
    return _startLine;
4289
300
}
4290
301
int Filter::HotSpot::endLine() const
4291
302
{
4292
303
    return _endLine;
4293
304
}
4294
305
int Filter::HotSpot::startColumn() const
4295
306
{
4296
307
    return _startColumn;
4297
308
}
4298
309
int Filter::HotSpot::endColumn() const
4299
310
{
4300
311
    return _endColumn;
4301
312
}
4302
313
Filter::HotSpot::Type Filter::HotSpot::type() const
4303
314
{
4304
315
    return _type;
4305
316
}
4306
317
void Filter::HotSpot::setType(Type type)
4307
318
{
4308
319
    _type = type;
4309
320
}
4310
321
4311
322
RegExpFilter::RegExpFilter()
4312
323
{
4313
324
}
4314
325
4315
326
RegExpFilter::HotSpot::HotSpot(int startLine,int startColumn,int endLine,int endColumn)
4316
327
    : Filter::HotSpot(startLine,startColumn,endLine,endColumn)
4317
328
{
4318
329
    setType(Marker);
4319
330
}
4320
331
4321
332
void RegExpFilter::HotSpot::activate(QObject*)
4322
333
{
4323
334
}
4324
335
4325
336
void RegExpFilter::HotSpot::setCapturedTexts(const QStringList& texts)
4326
337
{
4327
338
    _capturedTexts = texts;
4328
339
}
4329
340
QStringList RegExpFilter::HotSpot::capturedTexts() const
4330
341
{
4331
342
    return _capturedTexts;
4332
343
}
4333
344
4334
345
void RegExpFilter::setRegExp(const QRegExp& regExp) 
4335
346
{
4336
347
    _searchText = regExp;
4337
348
}
4338
349
QRegExp RegExpFilter::regExp() const
4339
350
{
4340
351
    return _searchText;
4341
352
}
4342
353
/*void RegExpFilter::reset(int)
4343
354
{
4344
355
    _buffer = QString();
4345
356
}*/
4346
357
void RegExpFilter::process()
4347
358
{
4348
359
    int pos = 0;
4349
360
    const QString* text = buffer();
4350
361
4351
362
    Q_ASSERT( text );
4352
363
4353
364
    // ignore any regular expressions which match an empty string.
4354
365
    // otherwise the while loop below will run indefinitely
4355
366
    static const QString emptyString("");
4356
367
    if ( _searchText.exactMatch(emptyString) )
4357
368
        return;
4358
369
4359
370
    while(pos >= 0)
4360
371
    {
4361
372
        pos = _searchText.indexIn(*text,pos);
4362
373
4363
374
        if ( pos >= 0 )
4364
375
        {
4365
376
            int startLine = 0;
4366
377
            int endLine = 0;
4367
378
            int startColumn = 0;
4368
379
            int endColumn = 0;
4369
380
4370
381
            getLineColumn(pos,startLine,startColumn);
4371
382
            getLineColumn(pos + _searchText.matchedLength(),endLine,endColumn);
4372
383
4373
384
            RegExpFilter::HotSpot* spot = newHotSpot(startLine,startColumn,
4374
385
                                           endLine,endColumn);
4375
386
            spot->setCapturedTexts(_searchText.capturedTexts());
4376
387
4377
388
            addHotSpot( spot );  
4378
389
            pos += _searchText.matchedLength();
4379
390
4380
391
            // if matchedLength == 0, the program will get stuck in an infinite loop
4381
392
            if ( _searchText.matchedLength() == 0 )
4382
393
                pos = -1;
4383
394
        }
4384
395
    }    
4385
396
}
4386
397
4387
398
RegExpFilter::HotSpot* RegExpFilter::newHotSpot(int startLine,int startColumn,
4388
399
                                                int endLine,int endColumn)
4389
400
{
4390
401
    return new RegExpFilter::HotSpot(startLine,startColumn,
4391
402
                                                  endLine,endColumn);
4392
403
}
4393
404
RegExpFilter::HotSpot* UrlFilter::newHotSpot(int startLine,int startColumn,int endLine,
4394
405
                                                    int endColumn)
4395
406
{
4396
407
    return new UrlFilter::HotSpot(startLine,startColumn,
4397
408
                                               endLine,endColumn);
4398
409
}
4399
410
UrlFilter::HotSpot::HotSpot(int startLine,int startColumn,int endLine,int endColumn)
4400
411
: RegExpFilter::HotSpot(startLine,startColumn,endLine,endColumn)
4401
412
, _urlObject(new FilterObject(this))
4402
413
{
4403
414
    setType(Link);
4404
415
}
4405
416
QString UrlFilter::HotSpot::tooltip() const
4406
417
{
4407
418
    QString url = capturedTexts().first();
4408
419
4409
420
    const UrlType kind = urlType();
4410
421
4411
422
    if ( kind == StandardUrl )
4412
423
        return QString(); 
4413
424
    else if ( kind == Email )
4414
425
        return QString(); 
4415
426
    else
4416
427
        return QString();
4417
428
}
4418
429
UrlFilter::HotSpot::UrlType UrlFilter::HotSpot::urlType() const
4419
430
{
4420
431
    QString url = capturedTexts().first();
4421
432
    
4422
433
    if ( FullUrlRegExp.exactMatch(url) )
4423
434
        return StandardUrl;
4424
435
    else if ( EmailAddressRegExp.exactMatch(url) )
4425
436
        return Email;
4426
437
    else
4427
438
        return Unknown;
4428
439
}
4429
440
4430
441
void UrlFilter::HotSpot::activate(QObject* object)
4431
442
{
4432
443
    QString url = capturedTexts().first();
4433
444
4434
445
    const UrlType kind = urlType();
4435
446
4436
447
    const QString& actionName = object ? object->objectName() : QString();
4437
448
4438
449
    if ( actionName == "copy-action" )
4439
450
    {
4440
451
        QApplication::clipboard()->setText(url);
4441
452
        return;
4442
453
    }
4443
454
4444
455
    if ( !object || actionName == "open-action" )
4445
456
    {
4446
457
        if ( kind == StandardUrl )
4447
458
        {
4448
459
            // if the URL path does not include the protocol ( eg. "www.kde.org" ) then
4449
460
            // prepend http:// ( eg. "www.kde.org" --> "http://www.kde.org" )
4450
461
            if (!url.contains("://"))
4451
462
            {
4452
463
                url.prepend("http://");
4453
464
            }
4454
465
        } 
4455
466
        else if ( kind == Email )
4456
467
        {
4457
468
            url.prepend("mailto:");
4458
469
        }
4459
470
    
4460
471
        QDesktopServices::openUrl(QUrl(url));
4461
472
        //new KRun(url,QApplication::activeWindow());
4462
473
    }
4463
474
}
4464
475
4465
476
// Note:  Altering these regular expressions can have a major effect on the performance of the filters 
4466
477
// used for finding URLs in the text, especially if they are very general and could match very long
4467
478
// pieces of text.
4468
479
// Please be careful when altering them.
4469
480
4470
481
//regexp matches:
4471
482
// full url:  
4472
483
// protocolname:// or www. followed by anything other than whitespaces, <, >, ' or ", and ends before whitespaces, <, >, ', ", ], !, comma and dot
4473
484
const QRegExp UrlFilter::FullUrlRegExp("(www\\.(?!\\.)|[a-z][a-z0-9+.-]*://)[^\\s<>'\"]+[^!,\\.\\s<>'\"\\]]");
4474
485
// email address:
4475
486
// [word chars, dots or dashes]@[word chars, dots or dashes].[word chars]
4476
487
const QRegExp UrlFilter::EmailAddressRegExp("\\b(\\w|\\.|-)+@(\\w|\\.|-)+\\.\\w+\\b");
4477
488
4478
489
// matches full url or email address
4479
490
const QRegExp UrlFilter::CompleteUrlRegExp('('+FullUrlRegExp.pattern()+'|'+
4480
491
                                            EmailAddressRegExp.pattern()+')');
4481
492
4482
493
UrlFilter::UrlFilter()
4483
494
{
4484
495
    setRegExp( CompleteUrlRegExp );
4485
496
}
4486
497
UrlFilter::HotSpot::~HotSpot()
4487
498
{
4488
499
    delete _urlObject;
4489
500
}
4490
501
void FilterObject::activated()
4491
502
{
4492
503
    _filter->activate(sender());
4493
504
}
4494
505
QList<QAction*> UrlFilter::HotSpot::actions()
4495
506
{
4496
507
    QList<QAction*> list;
4497
508
4498
509
    const UrlType kind = urlType();
4499
510
4500
511
    QAction* openAction = new QAction(_urlObject);
4501
512
    QAction* copyAction = new QAction(_urlObject);;
4502
513
4503
514
    Q_ASSERT( kind == StandardUrl || kind == Email );
4504
515
4505
516
    if ( kind == StandardUrl )
4506
517
    {
4507
518
        openAction->setText(QObject::tr("Open Link"));
4508
519
        copyAction->setText(QObject::tr("Copy Link Address"));
4509
520
    }
4510
521
    else if ( kind == Email )
4511
522
    {
4512
523
        openAction->setText(QObject::tr("Send Email To..."));
4513
524
        copyAction->setText(QObject::tr("Copy Email Address"));
4514
525
    }
4515
526
4516
527
    // object names are set here so that the hotspot performs the
4517
528
    // correct action when activated() is called with the triggered
4518
529
    // action passed as a parameter.
4519
530
    openAction->setObjectName( QLatin1String("open-action" ));
4520
531
    copyAction->setObjectName( QLatin1String("copy-action" ));
4521
532
4522
533
    QObject::connect( openAction , SIGNAL(triggered()) , _urlObject , SLOT(activated()) );
4523
534
    QObject::connect( copyAction , SIGNAL(triggered()) , _urlObject , SLOT(activated()) );
4524
535
4525
536
    list << openAction;
4526
537
    list << copyAction;
4527
538
4528
539
    return list; 
4529
540
}
4530
541
4531
542
//#include "Filter.moc"
4532
0
543
4533
=== added file 'src/plugin/konsole/Filter.h'
4534
--- src/plugin/konsole/Filter.h	1970-01-01 00:00:00 +0000
4535
+++ src/plugin/konsole/Filter.h	2014-05-06 21:50:22 +0000
4536
@@ -0,0 +1,380 @@
4537
1
/*
4538
2
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
4539
3
4540
4
    This program is free software; you can redistribute it and/or modify
4541
5
    it under the terms of the GNU General Public License as published by
4542
6
    the Free Software Foundation; either version 2 of the License, or
4543
7
    (at your option) any later version.
4544
8
4545
9
    This program is distributed in the hope that it will be useful,
4546
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
4547
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4548
12
    GNU General Public License for more details.
4549
13
4550
14
    You should have received a copy of the GNU General Public License
4551
15
    along with this program; if not, write to the Free Software
4552
16
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
4553
17
    02110-1301  USA.
4554
18
*/
4555
19
4556
20
#ifndef FILTER_H
4557
21
#define FILTER_H
4558
22
4559
23
// Qt
4560
24
#include <QtWidgets/QAction>
4561
25
#include <QtCore/QList>
4562
26
#include <QtCore/QObject>
4563
27
#include <QtCore/QStringList>
4564
28
#include <QtCore/QHash>
4565
29
#include <QtCore/QRegExp>
4566
30
4567
31
// Local
4568
32
#include "Character.h"
4569
33
4570
34
4571
35
/**
4572
36
 * A filter processes blocks of text looking for certain patterns (such as URLs or keywords from a list)
4573
37
 * and marks the areas which match the filter's patterns as 'hotspots'.
4574
38
 *
4575
39
 * Each hotspot has a type identifier associated with it ( such as a link or a highlighted section ),
4576
40
 * and an action.  When the user performs some activity such as a mouse-click in a hotspot area ( the exact
4577
41
 * action will depend on what is displaying the block of text which the filter is processing ), the hotspot's
4578
42
 * activate() method should be called.  Depending on the type of hotspot this will trigger a suitable response.
4579
43
 *
4580
44
 * For example, if a hotspot represents a URL then a suitable action would be opening that URL in a web browser.
4581
45
 * Hotspots may have more than one action, in which case the list of actions can be obtained using the 
4582
46
 * actions() method.
4583
47
 *
4584
48
 * Different subclasses of filter will return different types of hotspot.
4585
49
 * Subclasses must reimplement the process() method to examine a block of text and identify sections of interest.
4586
50
 * When processing the text they should create instances of Filter::HotSpot subclasses for sections of interest
4587
51
 * and add them to the filter's list of hotspots using addHotSpot()
4588
52
 */
4589
53
class Filter
4590
54
{
4591
55
public:
4592
56
    /**
4593
57
    * Represents an area of text which matched the pattern a particular filter has been looking for.
4594
58
    *
4595
59
    * Each hotspot has a type identifier associated with it ( such as a link or a highlighted section ),
4596
60
    * and an action.  When the user performs some activity such as a mouse-click in a hotspot area ( the exact
4597
61
    * action will depend on what is displaying the block of text which the filter is processing ), the hotspot's
4598
62
    * activate() method should be called.  Depending on the type of hotspot this will trigger a suitable response.
4599
63
    *
4600
64
    * For example, if a hotspot represents a URL then a suitable action would be opening that URL in a web browser.
4601
65
    * Hotspots may have more than one action, in which case the list of actions can be obtained using the 
4602
66
    * actions() method.  These actions may then be displayed in a popup menu or toolbar for example. 
4603
67
    */
4604
68
    class HotSpot
4605
69
    {
4606
70
    public:
4607
71
       /** 
4608
72
        * Constructs a new hotspot which covers the area from (@p startLine,@p startColumn) to (@p endLine,@p endColumn)
4609
73
        * in a block of text.
4610
74
        */
4611
75
       HotSpot(int startLine , int startColumn , int endLine , int endColumn);
4612
76
       virtual ~HotSpot();
4613
77
4614
78
       enum Type
4615
79
       {
4616
80
            // the type of the hotspot is not specified
4617
81
            NotSpecified,
4618
82
            // this hotspot represents a clickable link
4619
83
            Link,
4620
84
            // this hotspot represents a marker
4621
85
            Marker
4622
86
       }; 
4623
87
4624
88
       /** Returns the line when the hotspot area starts */
4625
89
       int startLine() const;
4626
90
       /** Returns the line where the hotspot area ends */
4627
91
       int endLine() const;
4628
92
       /** Returns the column on startLine() where the hotspot area starts */
4629
93
       int startColumn() const;
4630
94
       /** Returns the column on endLine() where the hotspot area ends */
4631
95
       int endColumn() const;
4632
96
       /** 
4633
97
        * Returns the type of the hotspot.  This is usually used as a hint for views on how to represent
4634
98
        * the hotspot graphically.  eg.  Link hotspots are typically underlined when the user mouses over them
4635
99
        */
4636
100
       Type type() const;
4637
101
       /** 
4638
102
        * Causes the an action associated with a hotspot to be triggered. 
4639
103
        *
4640
104
        * @param object The object which caused the hotspot to be triggered.  This is
4641
105
        * typically null ( in which case the default action should be performed ) or
4642
106
        * one of the objects from the actions() list.  In which case the associated
4643
107
        * action should be performed. 
4644
108
        */
4645
109
       virtual void activate(QObject* object = 0) = 0; 
4646
110
       /** 
4647
111
        * Returns a list of actions associated with the hotspot which can be used in a 
4648
112
        * menu or toolbar 
4649
113
        */
4650
114
       virtual QList<QAction*> actions();
4651
115
4652
116
       /** 
4653
117
        * Returns the text of a tooltip to be shown when the mouse moves over the hotspot, or
4654
118
        * an empty string if there is no tooltip associated with this hotspot.
4655
119
        *
4656
120
        * The default implementation returns an empty string. 
4657
121
        */
4658
122
       virtual QString tooltip() const;
4659
123
4660
124
    protected:
4661
125
       /** Sets the type of a hotspot.  This should only be set once */
4662
126
       void setType(Type type);
4663
127
4664
128
    private:
4665
129
       int    _startLine;
4666
130
       int    _startColumn;
4667
131
       int    _endLine;
4668
132
       int    _endColumn;
4669
133
       Type _type;
4670
134
    
4671
135
    };
4672
136
4673
137
    /** Constructs a new filter. */
4674
138
    Filter();
4675
139
    virtual ~Filter();
4676
140
4677
141
    /** Causes the filter to process the block of text currently in its internal buffer */
4678
142
    virtual void process() = 0;
4679
143
4680
144
    /** 
4681
145
     * Empties the filters internal buffer and resets the line count back to 0.
4682
146
     * All hotspots are deleted. 
4683
147
     */
4684
148
    void reset();
4685
149
4686
150
    /** Adds a new line of text to the filter and increments the line count */
4687
151
    //void addLine(const QString& string);
4688
152
4689
153
    /** Returns the hotspot which covers the given @p line and @p column, or 0 if no hotspot covers that area */
4690
154
    HotSpot* hotSpotAt(int line , int column) const;
4691
155
4692
156
    /** Returns the list of hotspots identified by the filter */
4693
157
    QList<HotSpot*> hotSpots() const;
4694
158
4695
159
    /** Returns the list of hotspots identified by the filter which occur on a given line */
4696
160
    QList<HotSpot*> hotSpotsAtLine(int line) const;
4697
161
4698
162
    /** 
4699
163
     * TODO: Document me
4700
164
     */
4701
165
    void setBuffer(const QString* buffer , const QList<int>* linePositions);
4702
166
4703
167
protected:
4704
168
    /** Adds a new hotspot to the list */
4705
169
    void addHotSpot(HotSpot*);
4706
170
    /** Returns the internal buffer */
4707
171
    const QString* buffer();
4708
172
    /** Converts a character position within buffer() to a line and column */
4709
173
    void getLineColumn(int position , int& startLine , int& startColumn);
4710
174
4711
175
private:
4712
176
    QMultiHash<int,HotSpot*> _hotspots;
4713
177
    QList<HotSpot*> _hotspotList;
4714
178
    
4715
179
    const QList<int>* _linePositions;
4716
180
    const QString* _buffer;
4717
181
};
4718
182
4719
183
/** 
4720
184
 * A filter which searches for sections of text matching a regular expression and creates a new RegExpFilter::HotSpot 
4721
185
 * instance for them.
4722
186
 *
4723
187
 * Subclasses can reimplement newHotSpot() to return custom hotspot types when matches for the regular expression
4724
188
 * are found. 
4725
189
 */
4726
190
class RegExpFilter : public Filter
4727
191
{
4728
192
public:
4729
193
    /** 
4730
194
     * Type of hotspot created by RegExpFilter.  The capturedTexts() method can be used to find the text
4731
195
     * matched by the filter's regular expression.
4732
196
     */
4733
197
    class HotSpot : public Filter::HotSpot
4734
198
    {
4735
199
    public:
4736
200
        HotSpot(int startLine, int startColumn, int endLine , int endColumn);
4737
201
        virtual void activate(QObject* object = 0);
4738
202
4739
203
        /** Sets the captured texts associated with this hotspot */
4740
204
        void setCapturedTexts(const QStringList& texts);
4741
205
        /** Returns the texts found by the filter when matching the filter's regular expression */
4742
206
        QStringList capturedTexts() const;
4743
207
    private:
4744
208
        QStringList _capturedTexts;
4745
209
    };
4746
210
4747
211
    /** Constructs a new regular expression filter */
4748
212
    RegExpFilter();
4749
213
4750
214
    /** 
4751
215
     * Sets the regular expression which the filter searches for in blocks of text. 
4752
216
     *
4753
217
     * Regular expressions which match the empty string are treated as not matching
4754
218
     * anything. 
4755
219
     */
4756
220
    void setRegExp(const QRegExp& text);
4757
221
    /** Returns the regular expression which the filter searches for in blocks of text */
4758
222
    QRegExp regExp() const;
4759
223
4760
224
    /** 
4761
225
     * Reimplemented to search the filter's text buffer for text matching regExp() 
4762
226
     *
4763
227
     * If regexp matches the empty string, then process() will return immediately
4764
228
     * without finding results. 
4765
229
     */
4766
230
    virtual void process();
4767
231
4768
232
protected:
4769
233
    /** 
4770
234
     * Called when a match for the regular expression is encountered.  Subclasses should reimplement this
4771
235
     * to return custom hotspot types
4772
236
     */
4773
237
    virtual RegExpFilter::HotSpot* newHotSpot(int startLine,int startColumn,
4774
238
                                    int endLine,int endColumn);
4775
239
4776
240
private:
4777
241
    QRegExp _searchText;
4778
242
};
4779
243
4780
244
class FilterObject;
4781
245
4782
246
/** A filter which matches URLs in blocks of text */
4783
247
class UrlFilter : public RegExpFilter 
4784
248
{
4785
249
public:
4786
250
    /** 
4787
251
     * Hotspot type created by UrlFilter instances.  The activate() method opens a web browser 
4788
252
     * at the given URL when called.
4789
253
     */
4790
254
    class HotSpot : public RegExpFilter::HotSpot 
4791
255
    {
4792
256
    public:
4793
257
        HotSpot(int startLine,int startColumn,int endLine,int endColumn);
4794
258
        virtual ~HotSpot();
4795
259
4796
260
        virtual QList<QAction*> actions();
4797
261
4798
262
        /** 
4799
263
         * Open a web browser at the current URL.  The url itself can be determined using
4800
264
         * the capturedTexts() method.
4801
265
         */
4802
266
        virtual void activate(QObject* object = 0);
4803
267
4804
268
        virtual QString tooltip() const;
4805
269
    private:
4806
270
        enum UrlType
4807
271
        {
4808
272
            StandardUrl,
4809
273
            Email,
4810
274
            Unknown
4811
275
        };
4812
276
        UrlType urlType() const;
4813
277
4814
278
        FilterObject* _urlObject;
4815
279
    };
4816
280
4817
281
    UrlFilter();
4818
282
4819
283
protected:
4820
284
    virtual RegExpFilter::HotSpot* newHotSpot(int,int,int,int);
4821
285
4822
286
private:
4823
287
    
4824
288
    static const QRegExp FullUrlRegExp;
4825
289
    static const QRegExp EmailAddressRegExp;
4826
290
4827
291
    // combined OR of FullUrlRegExp and EmailAddressRegExp
4828
292
    static const QRegExp CompleteUrlRegExp; 
4829
293
};
4830
294
4831
295
class FilterObject : public QObject
4832
296
{
4833
297
Q_OBJECT
4834
298
public:
4835
299
    FilterObject(Filter::HotSpot* filter) : _filter(filter) {}
4836
300
private slots:
4837
301
    void activated();
4838
302
private:
4839
303
    Filter::HotSpot* _filter;
4840
304
};
4841
305
4842
306
/** 
4843
307
 * A chain which allows a group of filters to be processed as one. 
4844
308
 * The chain owns the filters added to it and deletes them when the chain itself is destroyed.
4845
309
 *
4846
310
 * Use addFilter() to add a new filter to the chain.  
4847
311
 * When new text to be filtered arrives, use addLine() to add each additional
4848
312
 * line of text which needs to be processed and then after adding the last line, use
4849
313
 * process() to cause each filter in the chain to process the text.
4850
314
 *
4851
315
 * After processing a block of text, the reset() method can be used to set the filter chain's
4852
316
 * internal cursor back to the first line.
4853
317
 *
4854
318
 * The hotSpotAt() method will return the first hotspot which covers a given position.
4855
319
 *
4856
320
 * The hotSpots() and hotSpotsAtLine() method return all of the hotspots in the text and on
4857
321
 * a given line respectively.
4858
322
 */
4859
323
class FilterChain : protected QList<Filter*>
4860
324
{
4861
325
public:
4862
326
    virtual ~FilterChain();
4863
327
4864
328
    /** Adds a new filter to the chain.  The chain will delete this filter when it is destroyed */
4865
329
    void addFilter(Filter* filter);
4866
330
    /** Removes a filter from the chain.  The chain will no longer delete the filter when destroyed */
4867
331
    void removeFilter(Filter* filter);
4868
332
    /** Returns true if the chain contains @p filter */
4869
333
    bool containsFilter(Filter* filter);
4870
334
    /** Removes all filters from the chain */
4871
335
    void clear();
4872
336
4873
337
    /** Resets each filter in the chain */
4874
338
    void reset();
4875
339
    /**
4876
340
     * Processes each filter in the chain 
4877
341
     */
4878
342
    void process();
4879
343
4880
344
    /** Sets the buffer for each filter in the chain to process. */
4881
345
    void setBuffer(const QString* buffer , const QList<int>* linePositions); 
4882
346
4883
347
    /** Returns the first hotspot which occurs at @p line, @p column or 0 if no hotspot was found */
4884
348
    Filter::HotSpot* hotSpotAt(int line , int column) const;
4885
349
    /** Returns a list of all the hotspots in all the chain's filters */
4886
350
    QList<Filter::HotSpot*> hotSpots() const;
4887
351
    /** Returns a list of all hotspots at the given line in all the chain's filters */
4888
352
    QList<Filter::HotSpot> hotSpotsAtLine(int line) const;
4889
353
4890
354
};
4891
355
4892
356
/** A filter chain which processes character images from terminal displays */
4893
357
class TerminalImageFilterChain : public FilterChain
4894
358
{
4895
359
public:
4896
360
    TerminalImageFilterChain();
4897
361
    virtual ~TerminalImageFilterChain();
4898
362
4899
363
    /**
4900
364
     * Set the current terminal image to @p image.
4901
365
     *
4902
366
     * @param image The terminal image
4903
367
     * @param lines The number of lines in the terminal image
4904
368
     * @param columns The number of columns in the terminal image
4905
369
     * @param lineProperties The line properties to set for image
4906
370
     */
4907
371
    void setImage(const Character* const image , int lines , int columns,
4908
372
                  const QVector<LineProperty>& lineProperties);  
4909
373
4910
374
private:
4911
375
    QString* _buffer;
4912
376
    QList<int>* _linePositions;
4913
377
};
4914
378
4915
379
4916
380
#endif //FILTER_H
4917
0
381
4918
=== added file 'src/plugin/konsole/History.cpp'
4919
--- src/plugin/konsole/History.cpp	1970-01-01 00:00:00 +0000
4920
+++ src/plugin/konsole/History.cpp	2014-05-06 21:50:22 +0000
4921
@@ -0,0 +1,986 @@
4922
1
/*
4923
2
    This file is part of Konsole, an X terminal.
4924
3
    Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
4925
4
4926
5
    This program is free software; you can redistribute it and/or modify
4927
6
    it under the terms of the GNU General Public License as published by
4928
7
    the Free Software Foundation; either version 2 of the License, or
4929
8
    (at your option) any later version.
4930
9
4931
10
    This program is distributed in the hope that it will be useful,
4932
11
    but WITHOUT ANY WARRANTY; without even the implied warranty of
4933
12
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4934
13
    GNU General Public License for more details.
4935
14
4936
15
    You should have received a copy of the GNU General Public License
4937
16
    along with this program; if not, write to the Free Software
4938
17
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
4939
18
    02110-1301  USA.
4940
19
*/
4941
20
4942
21
// Own
4943
22
#include "History.h"
4944
23
4945
24
// System
4946
25
#include <iostream>
4947
26
#include <stdlib.h>
4948
27
#include <assert.h>
4949
28
#include <stdio.h>
4950
29
#include <sys/types.h>
4951
30
#include <sys/mman.h>
4952
31
#include <unistd.h>
4953
32
#include <errno.h>
4954
33
4955
34
#include <QtDebug>
4956
35
4957
36
// KDE
4958
37
//#include <kde_file.h>
4959
38
//#include <kdebug.h>
4960
39
4961
40
// Reasonable line size
4962
41
#define LINE_SIZE    1024
4963
42
#define KDE_lseek lseek
4964
43
4965
44
4966
45
/*
4967
46
   An arbitrary long scroll.
4968
47
4969
48
   One can modify the scroll only by adding either cells
4970
49
   or newlines, but access it randomly.
4971
50
4972
51
   The model is that of an arbitrary wide typewriter scroll
4973
52
   in that the scroll is a serie of lines and each line is
4974
53
   a serie of cells with no overwriting permitted.
4975
54
4976
55
   The implementation provides arbitrary length and numbers
4977
56
   of cells and line/column indexed read access to the scroll
4978
57
   at constant costs.
4979
58
4980
59
KDE4: Can we use QTemporaryFile here, instead of KTempFile?
4981
60
4982
61
FIXME: some complain about the history buffer comsuming the
4983
62
       memory of their machines. This problem is critical
4984
63
       since the history does not behave gracefully in cases
4985
64
       where the memory is used up completely.
4986
65
4987
66
       I put in a workaround that should handle it problem
4988
67
       now gracefully. I'm not satisfied with the solution.
4989
68
4990
69
FIXME: Terminating the history is not properly indicated
4991
70
       in the menu. We should throw a signal.
4992
71
4993
72
FIXME: There is noticeable decrease in speed, also. Perhaps,
4994
73
       there whole feature needs to be revisited therefore.
4995
74
       Disadvantage of a more elaborated, say block-oriented
4996
75
       scheme with wrap around would be it's complexity.
4997
76
*/
4998
77
4999
78
//FIXME: tempory replacement for tmpfile
5000
79
//       this is here one for debugging purpose.
Status:	Merged
Approved by:	Nicholas Skaggs on 2014-05-06
Approved revision:	75
Merged at revision:	57
Proposed branch:	lp:~dpm/ubuntu-terminal-app/merge-plugin
Merge into:	lp:ubuntu-terminal-app
Diff against target:	25271 lines (+24506/-71) 106 files modified .bzrignore (+0/-6) CMakeLists.txt (+33/-18) README (+0/-1) README.md (+152/-0) apparmor.json (+3/-2) click/CMakeLists.txt (+0/-8) debian/changelog (+6/-2) debian/control (+29/-8) debian/qtdeclarative5-konsole-qml-plugin.install (+1/-0) manifest.json (+6/-6) plugins.json (+0/-6) src/CMakeLists.txt (+2/-0) src/app/CMakeLists.txt (+24/-0) src/app/main.cpp (+120/-0) src/plugin/CMakeLists.txt (+7/-0) src/plugin/konsole/BlockArray.cpp (+377/-0) src/plugin/konsole/BlockArray.h (+126/-0) src/plugin/konsole/CMakeLists.txt (+93/-0) src/plugin/konsole/Character.h (+221/-0) src/plugin/konsole/CharacterColor.h (+294/-0) src/plugin/konsole/ColorScheme.cpp (+774/-0) src/plugin/konsole/ColorScheme.h (+342/-0) src/plugin/konsole/ColorTables.h (+55/-0) src/plugin/konsole/DefaultTranslatorText.h (+2/-0) src/plugin/konsole/Emulation.cpp (+458/-0) src/plugin/konsole/Emulation.h (+467/-0) src/plugin/konsole/ExtendedDefaultTranslator.h (+74/-0) src/plugin/konsole/Filter.cpp (+542/-0) src/plugin/konsole/Filter.h (+380/-0) src/plugin/konsole/History.cpp (+986/-0) src/plugin/konsole/History.h (+490/-0) src/plugin/konsole/KeyboardTranslator.cpp (+892/-0) src/plugin/konsole/KeyboardTranslator.h (+584/-0) src/plugin/konsole/LineFont.h (+21/-0) src/plugin/konsole/LineFont.src (+786/-0) src/plugin/konsole/Pty.cpp (+310/-0) src/plugin/konsole/Pty.h (+206/-0) src/plugin/konsole/Screen.cpp (+1360/-0) src/plugin/konsole/Screen.h (+672/-0) src/plugin/konsole/ScreenWindow.cpp (+292/-0) src/plugin/konsole/ScreenWindow.h (+257/-0) src/plugin/konsole/Session.cpp (+1064/-0) src/plugin/konsole/Session.h (+626/-0) src/plugin/konsole/ShellCommand.cpp (+167/-0) src/plugin/konsole/ShellCommand.h (+90/-0) src/plugin/konsole/TerminalCharacterDecoder.cpp (+251/-0) src/plugin/konsole/TerminalCharacterDecoder.h (+148/-0) src/plugin/konsole/TerminalDisplay.cpp (+2170/-0) src/plugin/konsole/TerminalDisplay.h (+715/-0) src/plugin/konsole/Vt102Emulation.cpp (+1221/-0) src/plugin/konsole/Vt102Emulation.h (+188/-0) src/plugin/konsole/assets/color-schemes/BlackOnLightYellow.schema (+42/-0) src/plugin/konsole/assets/color-schemes/BlackOnRandomLight.colorscheme (+104/-0) src/plugin/konsole/assets/color-schemes/BlackOnWhite.schema (+42/-0) src/plugin/konsole/assets/color-schemes/DarkPastels.colorscheme (+103/-0) src/plugin/konsole/assets/color-schemes/GreenOnBlack.colorscheme (+104/-0) src/plugin/konsole/assets/color-schemes/Linux.colorscheme (+100/-0) src/plugin/konsole/assets/color-schemes/WhiteOnBlack.schema (+42/-0) src/plugin/konsole/assets/color-schemes/historic/BlackOnLightColor.schema (+42/-0) src/plugin/konsole/assets/color-schemes/historic/DarkPicture.schema (+44/-0) src/plugin/konsole/assets/color-schemes/historic/Example.Schema (+47/-0) src/plugin/konsole/assets/color-schemes/historic/GreenOnBlack.schema (+42/-0) src/plugin/konsole/assets/color-schemes/historic/GreenTint.schema (+49/-0) src/plugin/konsole/assets/color-schemes/historic/GreenTint_MC.schema (+49/-0) src/plugin/konsole/assets/color-schemes/historic/LightPicture.schema (+44/-0) src/plugin/konsole/assets/color-schemes/historic/Linux.schema (+47/-0) src/plugin/konsole/assets/color-schemes/historic/README.Schema (+132/-0) src/plugin/konsole/assets/color-schemes/historic/README.default.Schema (+44/-0) src/plugin/konsole/assets/color-schemes/historic/Transparent.schema (+49/-0) src/plugin/konsole/assets/color-schemes/historic/Transparent_MC.schema (+51/-0) src/plugin/konsole/assets/color-schemes/historic/Transparent_darkbg.schema (+42/-0) src/plugin/konsole/assets/color-schemes/historic/Transparent_lightbg.schema (+51/-0) src/plugin/konsole/assets/color-schemes/historic/XTerm.schema (+46/-0) src/plugin/konsole/assets/color-schemes/historic/syscolor.schema (+44/-0) src/plugin/konsole/assets/color-schemes/historic/vim.schema (+40/-0) src/plugin/konsole/assets/kb-layouts/README (+72/-0) src/plugin/konsole/assets/kb-layouts/default.keytab (+169/-0) src/plugin/konsole/assets/kb-layouts/historic/vt100.keytab (+133/-0) src/plugin/konsole/assets/kb-layouts/historic/x11r5.keytab (+71/-0) src/plugin/konsole/assets/kb-layouts/linux.keytab (+164/-0) src/plugin/konsole/assets/kb-layouts/macbook.keytab (+175/-0) src/plugin/konsole/assets/kb-layouts/solaris.keytab (+108/-0) src/plugin/konsole/assets/kb-layouts/vt420pc.keytab (+168/-0) src/plugin/konsole/default.keytab (+128/-0) src/plugin/konsole/konsole_wcwidth.cpp (+224/-0) src/plugin/konsole/konsole_wcwidth.h (+24/-0) src/plugin/konsole/kprocess.cpp (+412/-0) src/plugin/konsole/kprocess.h (+372/-0) src/plugin/konsole/kpty.cpp (+701/-0) src/plugin/konsole/kpty.h (+191/-0) src/plugin/konsole/kpty_p.h (+50/-0) src/plugin/konsole/kptydevice.cpp (+422/-0) src/plugin/konsole/kptydevice.h (+360/-0) src/plugin/konsole/kptyprocess.cpp (+129/-0) src/plugin/konsole/kptyprocess.h (+178/-0) src/plugin/konsole/ksession.cpp (+242/-0) src/plugin/konsole/ksession.h (+132/-0) src/plugin/konsole/plugin.cpp (+63/-0) src/plugin/konsole/plugin.h (+46/-0) src/plugin/konsole/plugins.qmltypes (+169/-0) src/plugin/konsole/qmldir (+3/-0) src/plugin/konsole/tools.cpp (+80/-0) src/plugin/konsole/tools.h (+10/-0) tests/autopilot/CMakeLists.txt (+1/-1) tests/autopilot/ubuntu_terminal_app/tests/__init__.py (+25/-10) ubuntu-terminal-app.in (+0/-3)
To merge this branch:	bzr merge lp:~dpm/ubuntu-terminal-app/merge-plugin
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Ubuntu Phone Apps Jenkins Bot	continuous-integration		Approve on 2014-05-06
Nicholas Skaggs		2014-04-28	Pending
Review via email: mp+217380@code.launchpad.net