]>
Commit | Line | Data |
---|---|---|
4d3b6f6e AZ |
1 | /* |
2 | * QEMU curses/ncurses display driver | |
3 | * | |
4 | * Copyright (c) 2005 Andrzej Zaborowski <balrog@zabor.org> | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
4d3b6f6e AZ |
24 | #include <curses.h> |
25 | ||
26 | #ifndef _WIN32 | |
4d3b6f6e AZ |
27 | #include <sys/ioctl.h> |
28 | #include <termios.h> | |
29 | #endif | |
30 | ||
511d2b14 | 31 | #include "qemu-common.h" |
28ecbaee | 32 | #include "ui/console.h" |
9c17d615 | 33 | #include "sysemu/sysemu.h" |
511d2b14 | 34 | |
4d3b6f6e AZ |
35 | #define FONT_HEIGHT 16 |
36 | #define FONT_WIDTH 8 | |
37 | ||
7c20b4a3 | 38 | static DisplayChangeListener *dcl; |
c227f099 | 39 | static console_ch_t screen[160 * 100]; |
4d3b6f6e AZ |
40 | static WINDOW *screenpad = NULL; |
41 | static int width, height, gwidth, gheight, invalidate; | |
42 | static int px, py, sminx, sminy, smaxx, smaxy; | |
43 | ||
7c20b4a3 | 44 | static void curses_update(DisplayChangeListener *dcl, |
7c20b4a3 | 45 | int x, int y, int w, int h) |
4d3b6f6e AZ |
46 | { |
47 | chtype *line; | |
48 | ||
49 | line = ((chtype *) screen) + y * width; | |
50 | for (h += y; y < h; y ++, line += width) | |
51 | mvwaddchnstr(screenpad, y, 0, line, width); | |
52 | ||
53 | pnoutrefresh(screenpad, py, px, sminy, sminx, smaxy - 1, smaxx - 1); | |
54 | refresh(); | |
55 | } | |
56 | ||
57 | static void curses_calc_pad(void) | |
58 | { | |
81c0d5a6 | 59 | if (qemu_console_is_fixedsize(NULL)) { |
4d3b6f6e AZ |
60 | width = gwidth; |
61 | height = gheight; | |
62 | } else { | |
63 | width = COLS; | |
64 | height = LINES; | |
65 | } | |
66 | ||
67 | if (screenpad) | |
68 | delwin(screenpad); | |
69 | ||
70 | clear(); | |
71 | refresh(); | |
72 | ||
73 | screenpad = newpad(height, width); | |
74 | ||
75 | if (width > COLS) { | |
76 | px = (width - COLS) / 2; | |
77 | sminx = 0; | |
78 | smaxx = COLS; | |
79 | } else { | |
80 | px = 0; | |
81 | sminx = (COLS - width) / 2; | |
82 | smaxx = sminx + width; | |
83 | } | |
84 | ||
85 | if (height > LINES) { | |
86 | py = (height - LINES) / 2; | |
87 | sminy = 0; | |
88 | smaxy = LINES; | |
89 | } else { | |
90 | py = 0; | |
91 | sminy = (LINES - height) / 2; | |
92 | smaxy = sminy + height; | |
93 | } | |
94 | } | |
95 | ||
7c20b4a3 | 96 | static void curses_resize(DisplayChangeListener *dcl, |
7c20b4a3 | 97 | int width, int height) |
4d3b6f6e | 98 | { |
a93a4a22 | 99 | if (width == gwidth && height == gheight) { |
4d3b6f6e | 100 | return; |
a93a4a22 | 101 | } |
4d3b6f6e | 102 | |
a93a4a22 GH |
103 | gwidth = width; |
104 | gheight = height; | |
4d3b6f6e AZ |
105 | |
106 | curses_calc_pad(); | |
107 | } | |
108 | ||
032ac6f8 GH |
109 | #if !defined(_WIN32) && defined(SIGWINCH) && defined(KEY_RESIZE) |
110 | static volatile sig_atomic_t got_sigwinch; | |
111 | static void curses_winch_check(void) | |
4d3b6f6e AZ |
112 | { |
113 | struct winsize { | |
114 | unsigned short ws_row; | |
115 | unsigned short ws_col; | |
116 | unsigned short ws_xpixel; /* unused */ | |
117 | unsigned short ws_ypixel; /* unused */ | |
118 | } ws; | |
119 | ||
032ac6f8 GH |
120 | if (!got_sigwinch) { |
121 | return; | |
122 | } | |
123 | got_sigwinch = false; | |
124 | ||
125 | if (ioctl(1, TIOCGWINSZ, &ws) == -1) { | |
4d3b6f6e | 126 | return; |
032ac6f8 | 127 | } |
4d3b6f6e AZ |
128 | |
129 | resize_term(ws.ws_row, ws.ws_col); | |
4d3b6f6e | 130 | invalidate = 1; |
032ac6f8 | 131 | } |
4d3b6f6e | 132 | |
032ac6f8 GH |
133 | static void curses_winch_handler(int signum) |
134 | { | |
135 | got_sigwinch = true; | |
4d3b6f6e | 136 | } |
032ac6f8 GH |
137 | |
138 | static void curses_winch_init(void) | |
139 | { | |
140 | struct sigaction old, winch = { | |
141 | .sa_handler = curses_winch_handler, | |
142 | }; | |
143 | sigaction(SIGWINCH, &winch, &old); | |
144 | } | |
145 | #else | |
146 | static void curses_winch_check(void) {} | |
147 | static void curses_winch_init(void) {} | |
4d3b6f6e AZ |
148 | #endif |
149 | ||
7c20b4a3 | 150 | static void curses_cursor_position(DisplayChangeListener *dcl, |
7c20b4a3 | 151 | int x, int y) |
4d3b6f6e AZ |
152 | { |
153 | if (x >= 0) { | |
154 | x = sminx + x - px; | |
155 | y = sminy + y - py; | |
156 | ||
157 | if (x >= 0 && y >= 0 && x < COLS && y < LINES) { | |
158 | move(y, x); | |
159 | curs_set(1); | |
160 | /* it seems that curs_set(1) must always be called before | |
161 | * curs_set(2) for the latter to have effect */ | |
81c0d5a6 | 162 | if (!qemu_console_is_graphic(NULL)) { |
4d3b6f6e | 163 | curs_set(2); |
81c0d5a6 | 164 | } |
4d3b6f6e AZ |
165 | return; |
166 | } | |
167 | } | |
168 | ||
169 | curs_set(0); | |
170 | } | |
171 | ||
172 | /* generic keyboard conversion */ | |
173 | ||
174 | #include "curses_keys.h" | |
4d3b6f6e | 175 | |
c227f099 | 176 | static kbd_layout_t *kbd_layout = NULL; |
4d3b6f6e | 177 | |
bc2ed970 | 178 | static void curses_refresh(DisplayChangeListener *dcl) |
4d3b6f6e | 179 | { |
44bb61c8 | 180 | int chr, nextchr, keysym, keycode, keycode_alt; |
4d3b6f6e | 181 | |
032ac6f8 GH |
182 | curses_winch_check(); |
183 | ||
4d3b6f6e AZ |
184 | if (invalidate) { |
185 | clear(); | |
186 | refresh(); | |
187 | curses_calc_pad(); | |
1dbfa005 | 188 | graphic_hw_invalidate(NULL); |
4d3b6f6e AZ |
189 | invalidate = 0; |
190 | } | |
191 | ||
1dbfa005 | 192 | graphic_hw_text_update(NULL, screen); |
4d3b6f6e AZ |
193 | |
194 | nextchr = ERR; | |
195 | while (1) { | |
196 | /* while there are any pending key strokes to process */ | |
197 | if (nextchr == ERR) | |
198 | chr = getch(); | |
199 | else { | |
200 | chr = nextchr; | |
201 | nextchr = ERR; | |
202 | } | |
203 | ||
204 | if (chr == ERR) | |
205 | break; | |
206 | ||
b1314cf9 | 207 | #ifdef KEY_RESIZE |
4d3b6f6e AZ |
208 | /* this shouldn't occur when we use a custom SIGWINCH handler */ |
209 | if (chr == KEY_RESIZE) { | |
210 | clear(); | |
211 | refresh(); | |
212 | curses_calc_pad(); | |
bc2ed970 | 213 | curses_update(dcl, 0, 0, width, height); |
4d3b6f6e AZ |
214 | continue; |
215 | } | |
b1314cf9 | 216 | #endif |
4d3b6f6e AZ |
217 | |
218 | keycode = curses2keycode[chr]; | |
44bb61c8 | 219 | keycode_alt = 0; |
4d3b6f6e AZ |
220 | |
221 | /* alt key */ | |
222 | if (keycode == 1) { | |
223 | nextchr = getch(); | |
224 | ||
225 | if (nextchr != ERR) { | |
44bb61c8 ST |
226 | chr = nextchr; |
227 | keycode_alt = ALT; | |
4d3b6f6e AZ |
228 | keycode = curses2keycode[nextchr]; |
229 | nextchr = ERR; | |
4d3b6f6e | 230 | |
44bb61c8 ST |
231 | if (keycode != -1) { |
232 | keycode |= ALT; | |
4d3b6f6e | 233 | |
44bb61c8 ST |
234 | /* process keys reserved for qemu */ |
235 | if (keycode >= QEMU_KEY_CONSOLE0 && | |
236 | keycode < QEMU_KEY_CONSOLE0 + 9) { | |
237 | erase(); | |
238 | wnoutrefresh(stdscr); | |
239 | console_select(keycode - QEMU_KEY_CONSOLE0); | |
4d3b6f6e | 240 | |
44bb61c8 ST |
241 | invalidate = 1; |
242 | continue; | |
243 | } | |
4d3b6f6e AZ |
244 | } |
245 | } | |
246 | } | |
247 | ||
44bb61c8 ST |
248 | if (kbd_layout) { |
249 | keysym = -1; | |
250 | if (chr < CURSES_KEYS) | |
251 | keysym = curses2keysym[chr]; | |
252 | ||
253 | if (keysym == -1) { | |
d03703c8 ST |
254 | if (chr < ' ') { |
255 | keysym = chr + '@'; | |
256 | if (keysym >= 'A' && keysym <= 'Z') | |
257 | keysym += 'a' - 'A'; | |
258 | keysym |= KEYSYM_CNTRL; | |
259 | } else | |
44bb61c8 ST |
260 | keysym = chr; |
261 | } | |
4d3b6f6e | 262 | |
44bb61c8 ST |
263 | keycode = keysym2scancode(kbd_layout, keysym & KEYSYM_MASK); |
264 | if (keycode == 0) | |
265 | continue; | |
266 | ||
267 | keycode |= (keysym & ~KEYSYM_MASK) >> 16; | |
268 | keycode |= keycode_alt; | |
4d3b6f6e AZ |
269 | } |
270 | ||
44bb61c8 ST |
271 | if (keycode == -1) |
272 | continue; | |
273 | ||
81c0d5a6 | 274 | if (qemu_console_is_graphic(NULL)) { |
4d3b6f6e AZ |
275 | /* since terminals don't know about key press and release |
276 | * events, we need to emit both for each key received */ | |
277 | if (keycode & SHIFT) | |
278 | kbd_put_keycode(SHIFT_CODE); | |
279 | if (keycode & CNTRL) | |
280 | kbd_put_keycode(CNTRL_CODE); | |
281 | if (keycode & ALT) | |
282 | kbd_put_keycode(ALT_CODE); | |
44bb61c8 ST |
283 | if (keycode & ALTGR) { |
284 | kbd_put_keycode(SCANCODE_EMUL0); | |
285 | kbd_put_keycode(ALT_CODE); | |
286 | } | |
4d3b6f6e AZ |
287 | if (keycode & GREY) |
288 | kbd_put_keycode(GREY_CODE); | |
289 | kbd_put_keycode(keycode & KEY_MASK); | |
290 | if (keycode & GREY) | |
291 | kbd_put_keycode(GREY_CODE); | |
292 | kbd_put_keycode((keycode & KEY_MASK) | KEY_RELEASE); | |
44bb61c8 ST |
293 | if (keycode & ALTGR) { |
294 | kbd_put_keycode(SCANCODE_EMUL0); | |
295 | kbd_put_keycode(ALT_CODE | KEY_RELEASE); | |
296 | } | |
4d3b6f6e AZ |
297 | if (keycode & ALT) |
298 | kbd_put_keycode(ALT_CODE | KEY_RELEASE); | |
299 | if (keycode & CNTRL) | |
300 | kbd_put_keycode(CNTRL_CODE | KEY_RELEASE); | |
301 | if (keycode & SHIFT) | |
302 | kbd_put_keycode(SHIFT_CODE | KEY_RELEASE); | |
303 | } else { | |
44bb61c8 | 304 | keysym = curses2qemu[chr]; |
4d3b6f6e AZ |
305 | if (keysym == -1) |
306 | keysym = chr; | |
307 | ||
308 | kbd_put_keysym(keysym); | |
309 | } | |
310 | } | |
311 | } | |
312 | ||
aaf12c25 | 313 | static void curses_atexit(void) |
4d3b6f6e AZ |
314 | { |
315 | endwin(); | |
316 | } | |
317 | ||
4d3b6f6e AZ |
318 | static void curses_setup(void) |
319 | { | |
320 | int i, colour_default[8] = { | |
321 | COLOR_BLACK, COLOR_BLUE, COLOR_GREEN, COLOR_CYAN, | |
322 | COLOR_RED, COLOR_MAGENTA, COLOR_YELLOW, COLOR_WHITE, | |
323 | }; | |
324 | ||
325 | /* input as raw as possible, let everything be interpreted | |
326 | * by the guest system */ | |
327 | initscr(); noecho(); intrflush(stdscr, FALSE); | |
328 | nodelay(stdscr, TRUE); nonl(); keypad(stdscr, TRUE); | |
329 | start_color(); raw(); scrollok(stdscr, FALSE); | |
330 | ||
331 | for (i = 0; i < 64; i ++) | |
332 | init_pair(i, colour_default[i & 7], colour_default[i >> 3]); | |
333 | } | |
334 | ||
335 | static void curses_keyboard_setup(void) | |
336 | { | |
4d3b6f6e AZ |
337 | #if defined(__APPLE__) |
338 | /* always use generic keymaps */ | |
339 | if (!keyboard_layout) | |
340 | keyboard_layout = "en-us"; | |
341 | #endif | |
342 | if(keyboard_layout) { | |
0483755a | 343 | kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout); |
4d3b6f6e AZ |
344 | if (!kbd_layout) |
345 | exit(1); | |
346 | } | |
4d3b6f6e AZ |
347 | } |
348 | ||
7c20b4a3 GH |
349 | static const DisplayChangeListenerOps dcl_ops = { |
350 | .dpy_name = "curses", | |
351 | .dpy_text_update = curses_update, | |
352 | .dpy_text_resize = curses_resize, | |
353 | .dpy_refresh = curses_refresh, | |
354 | .dpy_text_cursor = curses_cursor_position, | |
355 | }; | |
356 | ||
4d3b6f6e AZ |
357 | void curses_display_init(DisplayState *ds, int full_screen) |
358 | { | |
359 | #ifndef _WIN32 | |
360 | if (!isatty(1)) { | |
361 | fprintf(stderr, "We need a terminal output\n"); | |
362 | exit(1); | |
363 | } | |
364 | #endif | |
365 | ||
366 | curses_setup(); | |
367 | curses_keyboard_setup(); | |
28695489 | 368 | atexit(curses_atexit); |
4d3b6f6e | 369 | |
032ac6f8 | 370 | curses_winch_init(); |
4d3b6f6e | 371 | |
7267c094 | 372 | dcl = (DisplayChangeListener *) g_malloc0(sizeof(DisplayChangeListener)); |
7c20b4a3 | 373 | dcl->ops = &dcl_ops; |
5209089f | 374 | register_displaychangelistener(dcl); |
4d3b6f6e AZ |
375 | |
376 | invalidate = 1; | |
4d3b6f6e | 377 | } |