?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Check for SRV/RTV binding conflicts per wined3d_state.
[wine.git] / programs / conhost / conhost.c
blobdd423ee5491c12307a6fbb3dca7d7b2768ee9daa
1 /*
2 * Copyright 1998 Alexandre Julliard
3 * Copyright 2001 Eric Pouech
4 * Copyright 2012 Detlef Riekenberg
5 * Copyright 2020 Jacek Caban
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <assert.h>
23 #include <limits.h>
24
25 #include "conhost.h"
26
27 #include "wine/server.h"
28 #include "wine/debug.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(console);
31
32 static const char_info_t empty_char_info = { ' ', 0x0007 }; /* white on black space */
33
34 static CRITICAL_SECTION console_section;
35 static CRITICAL_SECTION_DEBUG critsect_debug =
36 {
37 0, 0, &console_section,
38 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
39 0, 0, { (DWORD_PTR)(__FILE__ ": console_section") }
40 };
41 static CRITICAL_SECTION console_section = { &critsect_debug, -1, 0, 0, 0, 0 };
42
43 static void *ioctl_buffer;
44 static size_t ioctl_buffer_size;
45
46 static void *alloc_ioctl_buffer( size_t size )
47 {
48 if (size > ioctl_buffer_size)
49 {
50 void *new_buffer;
51 if (!(new_buffer = realloc( ioctl_buffer, size ))) return NULL;
52 ioctl_buffer = new_buffer;
53 ioctl_buffer_size = size;
54 }
55 return ioctl_buffer;
56 }
57
58 static int screen_buffer_compare_id( const void *key, const struct wine_rb_entry *entry )
59 {
60 struct screen_buffer *screen_buffer = WINE_RB_ENTRY_VALUE( entry, struct screen_buffer, entry );
61 return PtrToLong(key) - screen_buffer->id;
62 }
63
64 static struct wine_rb_tree screen_buffer_map = { screen_buffer_compare_id };
65
66 static void destroy_screen_buffer( struct screen_buffer *screen_buffer )
67 {
68 if (screen_buffer->console->active == screen_buffer)
69 screen_buffer->console->active = NULL;
70 wine_rb_remove( &screen_buffer_map, &screen_buffer->entry );
71 free( screen_buffer->data );
72 free( screen_buffer );
73 }
74
75 static struct screen_buffer *create_screen_buffer( struct console *console, int id, int width, int height )
76 {
77 struct screen_buffer *screen_buffer;
78 unsigned int i;
79
80 if (!(screen_buffer = calloc( 1, sizeof(*screen_buffer) ))) return NULL;
81 screen_buffer->console = console;
82 screen_buffer->id = id;
83 screen_buffer->mode = ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT;
84 screen_buffer->cursor_size = 25;
85 screen_buffer->cursor_visible = 1;
86 screen_buffer->width = width;
87 screen_buffer->height = height;
88 screen_buffer->attr = 0x07;
89 screen_buffer->popup_attr = 0xf5;
90 screen_buffer->font.weight = FW_NORMAL;
91 screen_buffer->font.pitch_family = FIXED_PITCH | FF_DONTCARE;
92
93 if (console->active)
94 {
95 screen_buffer->max_width = console->active->max_width;
96 screen_buffer->max_height = console->active->max_height;
97 screen_buffer->win.right = console->active->win.right - console->active->win.left;
98 screen_buffer->win.bottom = console->active->win.bottom - console->active->win.top;
99 }
100 else
101 {
102 screen_buffer->max_width = width;
103 screen_buffer->max_height = height;
104 screen_buffer->win.right = width - 1;
105 screen_buffer->win.bottom = height - 1;
106 }
107
108 if (wine_rb_put( &screen_buffer_map, LongToPtr(id), &screen_buffer->entry ))
109 {
110 free( screen_buffer );
111 ERR( "id %x already exists\n", id );
112 return NULL;
113 }
114
115 if (!(screen_buffer->data = malloc( screen_buffer->width * screen_buffer->height *
116 sizeof(*screen_buffer->data) )))
117 {
118 destroy_screen_buffer( screen_buffer );
119 return NULL;
120 }
121
122 /* clear the first row */
123 for (i = 0; i < screen_buffer->width; i++) screen_buffer->data[i] = empty_char_info;
124 /* and copy it to all other rows */
125 for (i = 1; i < screen_buffer->height; i++)
126 memcpy( &screen_buffer->data[i * screen_buffer->width], screen_buffer->data,
127 screen_buffer->width * sizeof(char_info_t) );
128
129 return screen_buffer;
130 }
131
132 static BOOL is_active( struct screen_buffer *screen_buffer )
133 {
134 return screen_buffer == screen_buffer->console->active;
135 }
136
137 static unsigned int get_tty_cp( struct console *console )
138 {
139 return console->is_unix ? CP_UNIXCP : CP_UTF8;
140 }
141
142 static void tty_flush( struct console *console )
143 {
144 if (!console->tty_output || !console->tty_buffer_count) return;
145 TRACE("%s\n", debugstr_an(console->tty_buffer, console->tty_buffer_count));
146 if (!WriteFile( console->tty_output, console->tty_buffer, console->tty_buffer_count,
147 NULL, NULL ))
148 WARN( "write failed: %u\n", GetLastError() );
149 console->tty_buffer_count = 0;
150 }
151
152 static void tty_write( struct console *console, const char *buffer, size_t size )
153 {
154 if (!size || !console->tty_output) return;
155 if (console->tty_buffer_count + size > sizeof(console->tty_buffer))
156 tty_flush( console );
157 if (console->tty_buffer_count + size <= sizeof(console->tty_buffer))
158 {
159 memcpy( console->tty_buffer + console->tty_buffer_count, buffer, size );
160 console->tty_buffer_count += size;
161 }
162 else
163 {
164 assert( !console->tty_buffer_count );
165 if (!WriteFile( console->tty_output, buffer, size, NULL, NULL ))
166 WARN( "write failed: %u\n", GetLastError() );
167 }
168 }
169
170 static void *tty_alloc_buffer( struct console *console, size_t size )
171 {
172 void *ret;
173 if (console->tty_buffer_count + size > sizeof(console->tty_buffer)) return NULL;
174 ret = console->tty_buffer + console->tty_buffer_count;
175 console->tty_buffer_count += size;
176 return ret;
177 }
178
179 static void hide_tty_cursor( struct console *console )
180 {
181 if (console->tty_cursor_visible)
182 {
183 tty_write( console, "\x1b[?25l", 6 );
184 console->tty_cursor_visible = FALSE;
185 }
186 }
187
188 static void set_tty_cursor( struct console *console, unsigned int x, unsigned int y )
189 {
190 char buf[64];
191
192 if (console->tty_cursor_x == x && console->tty_cursor_y == y) return;
193
194 if (!x && y == console->tty_cursor_y + 1) strcpy( buf, "\r\n" );
195 else if (!x && y == console->tty_cursor_y) strcpy( buf, "\r" );
196 else if (y == console->tty_cursor_y)
197 {
198 if (console->tty_cursor_x >= console->active->width)
199 {
200 if (console->is_unix)
201 {
202 /* Unix will usually have the cursor at width-1 in this case. instead of depending
203 * on the exact behaviour, move the cursor to the first column and move forward
204 * from there. */
205 tty_write( console, "\r", 1 );
206 console->tty_cursor_x = 0;
207 }
208 else if (console->active->mode & ENABLE_WRAP_AT_EOL_OUTPUT)
209 {
210 console->tty_cursor_x--;
211 }
212 if (console->tty_cursor_x == x) return;
213 }
214 if (x + 1 == console->tty_cursor_x) strcpy( buf, "\b" );
215 else if (x > console->tty_cursor_x) sprintf( buf, "\x1b[%uC", x - console->tty_cursor_x );
216 else sprintf( buf, "\x1b[%uD", console->tty_cursor_x - x );
217 }
218 else if (x || y)
219 {
220 hide_tty_cursor( console );
221 sprintf( buf, "\x1b[%u;%uH", y + 1, x + 1);
222 }
223 else strcpy( buf, "\x1b[H" );
224 console->tty_cursor_x = x;
225 console->tty_cursor_y = y;
226 tty_write( console, buf, strlen(buf) );
227 }
228
229 static void set_tty_cursor_relative( struct console *console, unsigned int x, unsigned int y )
230 {
231 if (y < console->tty_cursor_y)
232 {
233 char buf[64];
234 sprintf( buf, "\x1b[%uA", console->tty_cursor_y - y );
235 tty_write( console, buf, strlen(buf) );
236 console->tty_cursor_y = y;
237 }
238 else
239 {
240 while (console->tty_cursor_y < y)
241 {
242 console->tty_cursor_x = 0;
243 console->tty_cursor_y++;
244 tty_write( console, "\r\n", 2 );
245 }
246 }
247 set_tty_cursor( console, x, y );
248 }
249
250 static void set_tty_attr( struct console *console, unsigned int attr )
251 {
252 char buf[8];
253
254 if ((attr & 0x0f) != (console->tty_attr & 0x0f))
255 {
256 if ((attr & 0x0f) != 7)
257 {
258 unsigned int n = 30;
259 if (attr & FOREGROUND_BLUE) n += 4;
260 if (attr & FOREGROUND_GREEN) n += 2;
261 if (attr & FOREGROUND_RED) n += 1;
262 if (attr & FOREGROUND_INTENSITY) n += 60;
263 sprintf(buf, "\x1b[%um", n);
264 tty_write( console, buf, strlen(buf) );
265 }
266 else tty_write( console, "\x1b[m", 3 );
267 }
268
269 if ((attr & 0xf0) != (console->tty_attr & 0xf0) && attr != 7)
270 {
271 unsigned int n = 40;
272 if (attr & BACKGROUND_BLUE) n += 4;
273 if (attr & BACKGROUND_GREEN) n += 2;
274 if (attr & BACKGROUND_RED) n += 1;
275 if (attr & BACKGROUND_INTENSITY) n += 60;
276 sprintf(buf, "\x1b[%um", n);
277 tty_write( console, buf, strlen(buf) );
278 }
279
280 console->tty_attr = attr;
281 }
282
283 static void tty_sync( struct console *console )
284 {
285 if (!console->tty_output) return;
286
287 if (console->active->cursor_visible)
288 {
289 set_tty_cursor( console, get_bounded_cursor_x( console->active ), console->active->cursor_y );
290 if (!console->tty_cursor_visible)
291 {
292 tty_write( console, "\x1b[?25h", 6 ); /* show cursor */
293 console->tty_cursor_visible = TRUE;
294 }
295 }
296 else if (console->tty_cursor_visible)
297 hide_tty_cursor( console );
298 tty_flush( console );
299 }
300
301 static void init_tty_output( struct console *console )
302 {
303 if (!console->is_unix)
304 {
305 /* initialize tty output, but don't flush */
306 tty_write( console, "\x1b[2J", 4 ); /* clear screen */
307 set_tty_attr( console, console->active->attr );
308 tty_write( console, "\x1b[H", 3 ); /* move cursor to (0,0) */
309 }
310 else console->tty_attr = empty_char_info.attr;
311 console->tty_cursor_visible = TRUE;
312 }
313
314 static void scroll_to_cursor( struct screen_buffer *screen_buffer )
315 {
316 unsigned int cursor_x = get_bounded_cursor_x( screen_buffer );
317 int w = screen_buffer->win.right - screen_buffer->win.left + 1;
318 int h = screen_buffer->win.bottom - screen_buffer->win.top + 1;
319
320 if (cursor_x < screen_buffer->win.left)
321 screen_buffer->win.left = min( cursor_x, screen_buffer->width - w );
322 else if (cursor_x > screen_buffer->win.right)
323 screen_buffer->win.left = max( cursor_x, w ) - w + 1;
324 screen_buffer->win.right = screen_buffer->win.left + w - 1;
325
326 if (screen_buffer->cursor_y < screen_buffer->win.top)
327 screen_buffer->win.top = min( screen_buffer->cursor_y, screen_buffer->height - h );
328 else if (screen_buffer->cursor_y > screen_buffer->win.bottom)
329 screen_buffer->win.top = max( screen_buffer->cursor_y, h ) - h + 1;
330 screen_buffer->win.bottom = screen_buffer->win.top + h - 1;
331 }
332
333 static void update_output( struct screen_buffer *screen_buffer, RECT *rect )
334 {
335 int x, y, size, trailing_spaces;
336 char_info_t *ch;
337 char buf[8];
338
339 if (!is_active( screen_buffer ) || rect->top > rect->bottom || rect->right < rect->left)
340 return;
341
342 TRACE( "%s\n", wine_dbgstr_rect( rect ));
343
344 if (screen_buffer->console->win)
345 {
346 update_window_region( screen_buffer->console, rect );
347 return;
348 }
349 if (!screen_buffer->console->tty_output) return;
350
351 hide_tty_cursor( screen_buffer->console );
352
353 for (y = rect->top; y <= rect->bottom; y++)
354 {
355 for (trailing_spaces = 0; trailing_spaces < screen_buffer->width; trailing_spaces++)
356 {
357 ch = &screen_buffer->data[(y + 1) * screen_buffer->width - trailing_spaces - 1];
358 if (ch->ch != ' ' || ch->attr != 7) break;
359 }
360 if (trailing_spaces < 4) trailing_spaces = 0;
361
362 for (x = rect->left; x <= rect->right; x++)
363 {
364 ch = &screen_buffer->data[y * screen_buffer->width + x];
365 set_tty_attr( screen_buffer->console, ch->attr );
366 set_tty_cursor( screen_buffer->console, x, y );
367
368 if (x + trailing_spaces >= screen_buffer->width)
369 {
370 tty_write( screen_buffer->console, "\x1b[K", 3 );
371 break;
372 }
373
374 size = WideCharToMultiByte( get_tty_cp( screen_buffer->console ), 0,
375 &ch->ch, 1, buf, sizeof(buf), NULL, NULL );
376 tty_write( screen_buffer->console, buf, size );
377 screen_buffer->console->tty_cursor_x++;
378 }
379 }
380
381 empty_update_rect( screen_buffer, rect );
382 }
383
384 static void new_line( struct screen_buffer *screen_buffer, RECT *update_rect )
385 {
386 unsigned int i;
387
388 assert( screen_buffer->cursor_y >= screen_buffer->height );
389 screen_buffer->cursor_y = screen_buffer->height - 1;
390
391 if (screen_buffer->console->tty_output)
392 update_output( screen_buffer, update_rect );
393 else
394 SetRect( update_rect, 0, 0, screen_buffer->width - 1, screen_buffer->height - 1 );
395
396 memmove( screen_buffer->data, screen_buffer->data + screen_buffer->width,
397 screen_buffer->width * (screen_buffer->height - 1) * sizeof(*screen_buffer->data) );
398 for (i = 0; i < screen_buffer->width; i++)
399 screen_buffer->data[screen_buffer->width * (screen_buffer->height - 1) + i] = empty_char_info;
400 if (is_active( screen_buffer ))
401 {
402 screen_buffer->console->tty_cursor_y--;
403 if (screen_buffer->console->tty_cursor_y != screen_buffer->height - 2)
404 set_tty_cursor( screen_buffer->console, 0, screen_buffer->height - 2 );
405 set_tty_cursor( screen_buffer->console, 0, screen_buffer->height - 1 );
406 }
407 }
408
409 static void write_char( struct screen_buffer *screen_buffer, WCHAR ch, RECT *update_rect, unsigned int *home_y )
410 {
411 if (screen_buffer->cursor_x == screen_buffer->width)
412 {
413 screen_buffer->cursor_x = 0;
414 screen_buffer->cursor_y++;
415 }
416 if (screen_buffer->cursor_y == screen_buffer->height)
417 {
418 if (home_y)
419 {
420 if (!*home_y) return;
421 (*home_y)--;
422 }
423 new_line( screen_buffer, update_rect );
424 }
425
426 screen_buffer->data[screen_buffer->cursor_y * screen_buffer->width + screen_buffer->cursor_x].ch = ch;
427 screen_buffer->data[screen_buffer->cursor_y * screen_buffer->width + screen_buffer->cursor_x].attr = screen_buffer->attr;
428 update_rect->left = min( update_rect->left, screen_buffer->cursor_x );
429 update_rect->top = min( update_rect->top, screen_buffer->cursor_y );
430 update_rect->right = max( update_rect->right, screen_buffer->cursor_x );
431 update_rect->bottom = max( update_rect->bottom, screen_buffer->cursor_y );
432 screen_buffer->cursor_x++;
433 }
434
435 static NTSTATUS read_complete( struct console *console, NTSTATUS status, const void *buf, size_t size, int signal )
436 {
437 SERVER_START_REQ( get_next_console_request )
438 {
439 req->handle = wine_server_obj_handle( console->server );
440 req->signal = signal;
441 req->read = 1;
442 req->status = status;
443 wine_server_add_data( req, buf, size );
444 status = wine_server_call( req );
445 }
446 SERVER_END_REQ;
447 if (status && (console->read_ioctl || status != STATUS_INVALID_HANDLE)) ERR( "failed: %#x\n", status );
448 console->signaled = signal;
449 console->read_ioctl = 0;
450 console->pending_read = 0;
451 return status;
452 }
453
454 static NTSTATUS read_console_input( struct console *console, size_t out_size )
455 {
456 size_t count = min( out_size / sizeof(INPUT_RECORD), console->record_count );
457
458 TRACE("count %u\n", count);
459
460 read_complete( console, STATUS_SUCCESS, console->records, count * sizeof(*console->records),
461 console->record_count > count );
462
463 if (count < console->record_count)
464 memmove( console->records, console->records + count,
465 (console->record_count - count) * sizeof(*console->records) );
466 console->record_count -= count;
467 return STATUS_SUCCESS;
468 }
469
470 static void read_from_buffer( struct console *console, size_t out_size )
471 {
472 size_t len, read_len = 0;
473 char *buf = NULL;
474
475 switch( console->read_ioctl )
476 {
477 case IOCTL_CONDRV_READ_CONSOLE:
478 out_size = min( out_size, console->read_buffer_count * sizeof(WCHAR) );
479 read_complete( console, STATUS_SUCCESS, console->read_buffer, out_size, console->record_count != 0 );
480 read_len = out_size / sizeof(WCHAR);
481 break;
482 case IOCTL_CONDRV_READ_FILE:
483 read_len = len = 0;
484 while (read_len < console->read_buffer_count && len < out_size)
485 {
486 len += WideCharToMultiByte( console->input_cp, 0, console->read_buffer + read_len, 1, NULL, 0, NULL, NULL );
487 read_len++;
488 }
489 if (len)
490 {
491 if (!(buf = malloc( len )))
492 {
493 read_complete( console, STATUS_NO_MEMORY, NULL, 0, console->record_count != 0 );
494 return;
495 }
496 WideCharToMultiByte( console->input_cp, 0, console->read_buffer, read_len, buf, len, NULL, NULL );
497 }
498 len = min( out_size, len );
499 read_complete( console, STATUS_SUCCESS, buf, len, console->record_count != 0 );
500 free( buf );
501 break;
502 }
503
504 if (read_len < console->read_buffer_count)
505 {
506 memmove( console->read_buffer, console->read_buffer + read_len,
507 (console->read_buffer_count - read_len) * sizeof(WCHAR) );
508 }
509 if (!(console->read_buffer_count -= read_len))
510 free( console->read_buffer );
511 }
512
513 static void append_input_history( struct console *console, const WCHAR *str, size_t len )
514 {
515 struct history_line *ptr;
516
517 if (!console->history_size) return;
518
519 /* don't duplicate entry */
520 if (console->history_mode && console->history_index &&
521 console->history[console->history_index - 1]->len == len &&
522 !memcmp( console->history[console->history_index - 1]->text, str, len ))
523 return;
524
525 if (!(ptr = malloc( offsetof( struct history_line, text[len / sizeof(WCHAR)] )))) return;
526 ptr->len = len;
527 memcpy( ptr->text, str, len );
528
529 if (console->history_index < console->history_size)
530 {
531 console->history[console->history_index++] = ptr;
532 }
533 else
534 {
535 free( console->history[0]) ;
536 memmove( &console->history[0], &console->history[1],
537 (console->history_size - 1) * sizeof(*console->history) );
538 console->history[console->history_size - 1] = ptr;
539 }
540 }
541
542 static void edit_line_update( struct console *console, unsigned int begin, unsigned int length )
543 {
544 struct edit_line *ctx = &console->edit_line;
545 if (!length) return;
546 ctx->update_begin = min( ctx->update_begin, begin );
547 ctx->update_end = max( ctx->update_end, begin + length - 1 );
548 }
549
550 static BOOL edit_line_grow( struct console *console, size_t length )
551 {
552 struct edit_line *ctx = &console->edit_line;
553 WCHAR *new_buf;
554 size_t new_size;
555
556 if (ctx->len + length < ctx->size) return TRUE;
557
558 /* round up size to 32 byte-WCHAR boundary */
559 new_size = (ctx->len + length + 32) & ~31;
560 if (!(new_buf = realloc( ctx->buf, sizeof(WCHAR) * new_size )))
561 {
562 ctx->status = STATUS_NO_MEMORY;
563 return FALSE;
564 }
565 ctx->buf = new_buf;
566 ctx->size = new_size;
567 return TRUE;
568 }
569
570 static void edit_line_delete( struct console *console, int begin, int end )
571 {
572 struct edit_line *ctx = &console->edit_line;
573 unsigned int len = end - begin;
574
575 edit_line_update( console, begin, ctx->len - begin );
576 if (end < ctx->len)
577 memmove( &ctx->buf[begin], &ctx->buf[end], (ctx->len - end) * sizeof(WCHAR));
578 ctx->len -= len;
579 edit_line_update( console, 0, ctx->len );
580 ctx->buf[ctx->len] = 0;
581 }
582
583 static void edit_line_insert( struct console *console, const WCHAR *str, unsigned int len )
584 {
585 struct edit_line *ctx = &console->edit_line;
586 unsigned int update_len;
587
588 if (!len) return;
589 if (ctx->insert_mode)
590 {
591 if (!edit_line_grow( console, len )) return;
592 if (ctx->len > ctx->cursor)
593 memmove( &ctx->buf[ctx->cursor + len], &ctx->buf[ctx->cursor],
594 (ctx->len - ctx->cursor) * sizeof(WCHAR) );
595 ctx->len += len;
596 update_len = ctx->len - ctx->cursor;
597 }
598 else
599 {
600 if (ctx->cursor + len > ctx->len)
601 {
602 if (!edit_line_grow( console, (ctx->cursor + len) - ctx->len) )
603 return;
604 ctx->len = ctx->cursor + len;
605 }
606 update_len = len;
607 }
608 memcpy( &ctx->buf[ctx->cursor], str, len * sizeof(WCHAR) );
609 ctx->buf[ctx->len] = 0;
610 edit_line_update( console, ctx->cursor, update_len );
611 ctx->cursor += len;
612 }
613
614 static void edit_line_save_yank( struct console *console, unsigned int begin, unsigned int end )
615 {
616 struct edit_line *ctx = &console->edit_line;
617 unsigned int len = end - begin;
618 if (len <= 0) return;
619
620 free(ctx->yanked);
621 ctx->yanked = malloc( (len + 1) * sizeof(WCHAR) );
622 if (!ctx->yanked)
623 {
624 ctx->status = STATUS_NO_MEMORY;
625 return;
626 }
627 memcpy( ctx->yanked, &ctx->buf[begin], len * sizeof(WCHAR) );
628 ctx->yanked[len] = 0;
629 }
630
631 static int edit_line_left_word_transition( struct console *console, int offset )
632 {
633 offset--;
634 while (offset >= 0 && !iswalnum( console->edit_line.buf[offset] )) offset--;
635 while (offset >= 0 && iswalnum( console->edit_line.buf[offset] )) offset--;
636 if (offset >= 0) offset++;
637 return max( offset, 0 );
638 }
639
640 static int edit_line_right_word_transition( struct console *console, int offset )
641 {
642 offset++;
643 while (offset <= console->edit_line.len && iswalnum( console->edit_line.buf[offset] ))
644 offset++;
645 while (offset <= console->edit_line.len && !iswalnum( console->edit_line.buf[offset] ))
646 offset++;
647 return min(offset, console->edit_line.len);
648 }
649
650 static WCHAR *edit_line_history( struct console *console, unsigned int index )
651 {
652 WCHAR *ptr = NULL;
653
654 if (index < console->history_index)
655 {
656 if ((ptr = malloc( console->history[index]->len + sizeof(WCHAR) )))
657 {
658 memcpy( ptr, console->history[index]->text, console->history[index]->len );
659 ptr[console->history[index]->len / sizeof(WCHAR)] = 0;
660 }
661 }
662 else if(console->edit_line.current_history)
663 {
664 if ((ptr = malloc( (lstrlenW(console->edit_line.current_history) + 1) * sizeof(WCHAR) )))
665 lstrcpyW( ptr, console->edit_line.current_history );
666 }
667 return ptr;
668 }
669
670 static void edit_line_move_to_history( struct console *console, int index )
671 {
672 struct edit_line *ctx = &console->edit_line;
673 WCHAR *line = edit_line_history(console, index);
674 size_t len = line ? lstrlenW(line) : 0;
675
676 /* save current line edition for recall when needed */
677 if (ctx->history_index == console->history_index)
678 {
679 free( ctx->current_history );
680 ctx->current_history = malloc( (ctx->len + 1) * sizeof(WCHAR) );
681 if (ctx->current_history)
682 {
683 memcpy( ctx->current_history, ctx->buf, (ctx->len + 1) * sizeof(WCHAR) );
684 }
685 else
686 {
687 ctx->status = STATUS_NO_MEMORY;
688 return;
689 }
690 }
691
692 /* need to clean also the screen if new string is shorter than old one */
693 edit_line_delete(console, 0, ctx->len);
694 ctx->cursor = 0;
695 /* insert new string */
696 if (edit_line_grow(console, len + 1))
697 {
698 edit_line_insert( console, line, len );
699 ctx->history_index = index;
700 }
701 free(line);
702 }
703
704 static void edit_line_find_in_history( struct console *console )
705 {
706 struct edit_line *ctx = &console->edit_line;
707 int start_pos = ctx->history_index;
708 unsigned int len, oldoffset;
709 WCHAR *line;
710
711 if (!console->history_index) return;
712 if (ctx->history_index && ctx->history_index == console->history_index)
713 {
714 start_pos--;
715 ctx->history_index--;
716 }
717
718 do
719 {
720 line = edit_line_history(console, ctx->history_index);
721
722 if (ctx->history_index) ctx->history_index--;
723 else ctx->history_index = console->history_index - 1;
724
725 len = lstrlenW(line) + 1;
726 if (len >= ctx->cursor && !memcmp( ctx->buf, line, ctx->cursor * sizeof(WCHAR) ))
727 {
728 /* need to clean also the screen if new string is shorter than old one */
729 edit_line_delete(console, 0, ctx->len);
730
731 if (edit_line_grow(console, len))
732 {
733 oldoffset = ctx->cursor;
734 ctx->cursor = 0;
735 edit_line_insert( console, line, len - 1 );
736 ctx->cursor = oldoffset;
737 free(line);
738 return;
739 }
740 }
741 free(line);
742 }
743 while (ctx->history_index != start_pos);
744 }
745
746 static void edit_line_move_left( struct console *console )
747 {
748 if (console->edit_line.cursor > 0) console->edit_line.cursor--;
749 }
750
751 static void edit_line_move_right( struct console *console )
752 {
753 struct edit_line *ctx = &console->edit_line;
754 if (ctx->cursor < ctx->len) ctx->cursor++;
755 }
756
757 static void edit_line_move_left_word( struct console *console )
758 {
759 console->edit_line.cursor = edit_line_left_word_transition( console, console->edit_line.cursor );
760 }
761
762 static void edit_line_move_right_word( struct console *console )
763 {
764 console->edit_line.cursor = edit_line_right_word_transition( console, console->edit_line.cursor );
765 }
766
767 static void edit_line_move_home( struct console *console )
768 {
769 console->edit_line.cursor = 0;
770 }
771
772 static void edit_line_move_end( struct console *console )
773 {
774 console->edit_line.cursor = console->edit_line.len;
775 }
776
777 static void edit_line_set_mark( struct console *console )
778 {
779 console->edit_line.mark = console->edit_line.cursor;
780 }
781
782 static void edit_line_exchange_mark( struct console *console )
783 {
784 struct edit_line *ctx = &console->edit_line;
785 unsigned int cursor;
786
787 if (ctx->mark > ctx->len) return;
788 cursor = ctx->cursor;
789 ctx->cursor = ctx->mark;
790 ctx->mark = cursor;
791 }
792
793 static void edit_line_copy_marked_zone( struct console *console )
794 {
795 struct edit_line *ctx = &console->edit_line;
796 unsigned int begin, end;
797
798 if (ctx->mark > ctx->len || ctx->mark == ctx->cursor) return;
799 if (ctx->mark > ctx->cursor)
800 {
801 begin = ctx->cursor;
802 end = ctx->mark;
803 }
804 else
805 {
806 begin = ctx->mark;
807 end = ctx->cursor;
808 }
809 edit_line_save_yank( console, begin, end );
810 }
811
812 static void edit_line_transpose_char( struct console *console )
813 {
814 struct edit_line *ctx = &console->edit_line;
815 WCHAR c;
816
817 if (!ctx->cursor || ctx->cursor == ctx->len) return;
818
819 c = ctx->buf[ctx->cursor];
820 ctx->buf[ctx->cursor] = ctx->buf[ctx->cursor - 1];
821 ctx->buf[ctx->cursor - 1] = c;
822
823 edit_line_update( console, ctx->cursor - 1, 2 );
824 ctx->cursor++;
825 }
826
827 static void edit_line_transpose_words( struct console *console )
828 {
829 struct edit_line *ctx = &console->edit_line;
830 unsigned int left_offset = edit_line_left_word_transition( console, ctx->cursor );
831 unsigned int right_offset = edit_line_right_word_transition( console, ctx->cursor );
832 if (left_offset < ctx->cursor && right_offset > ctx->cursor)
833 {
834 unsigned int len_r = right_offset - ctx->cursor;
835 unsigned int len_l = ctx->cursor - left_offset;
836 char *tmp = malloc( len_r * sizeof(WCHAR) );
837 if (!tmp)
838 {
839 ctx->status = STATUS_NO_MEMORY;
840 return;
841 }
842
843 memcpy( tmp, &ctx->buf[ctx->cursor], len_r * sizeof(WCHAR) );
844 memmove( &ctx->buf[left_offset + len_r], &ctx->buf[left_offset],
845 len_l * sizeof(WCHAR) );
846 memcpy( &ctx->buf[left_offset], tmp, len_r * sizeof(WCHAR) );
847 free(tmp);
848
849 edit_line_update( console, left_offset, len_l + len_r );
850 ctx->cursor = right_offset;
851 }
852 }
853
854 static void edit_line_lower_case_word( struct console *console )
855 {
856 struct edit_line *ctx = &console->edit_line;
857 unsigned int new_offset = edit_line_right_word_transition( console, ctx->cursor );
858 if (new_offset != ctx->cursor)
859 {
860 CharLowerBuffW( ctx->buf + ctx->cursor, new_offset - ctx->cursor + 1 );
861 edit_line_update( console, ctx->cursor, new_offset - ctx->cursor + 1 );
862 ctx->cursor = new_offset;
863 }
864 }
865
866 static void edit_line_upper_case_word( struct console *console )
867 {
868 struct edit_line *ctx = &console->edit_line;
869 unsigned int new_offset = edit_line_right_word_transition( console, ctx->cursor );
870 if (new_offset != ctx->cursor)
871 {
872 CharUpperBuffW( ctx->buf + ctx->cursor, new_offset - ctx->cursor + 1 );
873 edit_line_update( console, ctx->cursor, new_offset - ctx->cursor + 1 );
874 ctx->cursor = new_offset;
875 }
876 }
877
878 static void edit_line_capitalize_word( struct console *console )
879 {
880 struct edit_line *ctx = &console->edit_line;
881 unsigned int new_offset = edit_line_right_word_transition( console, ctx->cursor );
882 if (new_offset != ctx->cursor)
883 {
884 CharUpperBuffW( ctx->buf + ctx->cursor, 1 );
885 CharLowerBuffW( ctx->buf + ctx->cursor + 1, new_offset - ctx->cursor );
886 edit_line_update( console, ctx->cursor, new_offset - ctx->cursor + 1 );
887 ctx->cursor = new_offset;
888 }
889 }
890
891 static void edit_line_yank( struct console *console )
892 {
893 struct edit_line *ctx = &console->edit_line;
894 if (ctx->yanked) edit_line_insert( console, ctx->yanked, wcslen(ctx->yanked) );
895 }
896
897 static void edit_line_kill_suffix( struct console *console )
898 {
899 struct edit_line *ctx = &console->edit_line;
900 edit_line_save_yank( console, ctx->cursor, ctx->len );
901 edit_line_delete( console, ctx->cursor, ctx->len );
902 }
903
904 static void edit_line_kill_prefix( struct console *console )
905 {
906 struct edit_line *ctx = &console->edit_line;
907 if (ctx->cursor)
908 {
909 edit_line_save_yank( console, 0, ctx->cursor );
910 edit_line_delete( console, 0, ctx->cursor );
911 ctx->cursor = 0;
912 }
913 }
914
915 static void edit_line_kill_marked_zone( struct console *console )
916 {
917 struct edit_line *ctx = &console->edit_line;
918 unsigned int begin, end;
919
920 if (ctx->mark > ctx->len || ctx->mark == ctx->cursor)
921 return;
922 if (ctx->mark > ctx->cursor)
923 {
924 begin = ctx->cursor;
925 end = ctx->mark;
926 }
927 else
928 {
929 begin = ctx->mark;
930 end = ctx->cursor;
931 }
932 edit_line_save_yank( console, begin, end );
933 edit_line_delete( console, begin, end );
934 ctx->cursor = begin;
935 }
936
937 static void edit_line_delete_prev( struct console *console )
938 {
939 struct edit_line *ctx = &console->edit_line;
940 if (ctx->cursor)
941 {
942 edit_line_delete( console, ctx->cursor - 1, ctx->cursor );
943 ctx->cursor--;
944 }
945 }
946
947 static void edit_line_delete_char( struct console *console )
948 {
949 struct edit_line *ctx = &console->edit_line;
950 if (ctx->cursor < ctx->len)
951 edit_line_delete( console, ctx->cursor, ctx->cursor + 1 );
952 }
953
954 static void edit_line_delete_left_word( struct console *console )
955 {
956 struct edit_line *ctx = &console->edit_line;
957 unsigned int new_offset = edit_line_left_word_transition( console, ctx->cursor );
958 if (new_offset != ctx->cursor)
959 {
960 edit_line_delete( console, new_offset, ctx->cursor );
961 ctx->cursor = new_offset;
962 }
963 }
964
965 static void edit_line_delete_right_word( struct console *console )
966 {
967 struct edit_line *ctx = &console->edit_line;
968 unsigned int new_offset = edit_line_right_word_transition( console, ctx->cursor );
969 if (new_offset != ctx->cursor)
970 {
971 edit_line_delete( console, ctx->cursor, new_offset );
972 }
973 }
974
975 static void edit_line_move_to_prev_hist( struct console *console )
976 {
977 if (console->edit_line.history_index)
978 edit_line_move_to_history( console, console->edit_line.history_index - 1 );
979 }
980
981 static void edit_line_move_to_next_hist( struct console *console )
982 {
983 if (console->edit_line.history_index < console->history_index)
984 edit_line_move_to_history( console, console->edit_line.history_index + 1 );
985 }
986
987 static void edit_line_move_to_first_hist( struct console *console )
988 {
989 if (console->edit_line.history_index)
990 edit_line_move_to_history( console, 0 );
991 }
992
993 static void edit_line_move_to_last_hist( struct console *console )
994 {
995 if (console->edit_line.history_index != console->history_index)
996 edit_line_move_to_history( console, console->history_index );
997 }
998
999 static void edit_line_redraw( struct console *console )
1000 {
1001 if (console->mode & ENABLE_ECHO_INPUT)
1002 edit_line_update( console, 0, console->edit_line.len );
1003 }
1004
1005 static void edit_line_toggle_insert( struct console *console )
1006 {
1007 struct edit_line *ctx = &console->edit_line;
1008 ctx->insert_key = !ctx->insert_key;
1009 console->active->cursor_size = ctx->insert_key ? 100 : 25;
1010 }
1011
1012 static void edit_line_done( struct console *console )
1013 {
1014 console->edit_line.status = STATUS_SUCCESS;
1015 }
1016
1017 struct edit_line_key_entry
1018 {
1019 WCHAR val; /* vk or unicode char */
1020 void (*func)( struct console *console );
1021 };
1022
1023 struct edit_line_key_map
1024 {
1025 DWORD key_state; /* keyState (from INPUT_RECORD) to match */
1026 BOOL is_char; /* check vk or char */
1027 const struct edit_line_key_entry *entries;
1028 };
1029
1030 #define CTRL(x) ((x) - '@')
1031 static const struct edit_line_key_entry std_key_map[] =
1032 {
1033 { VK_BACK, edit_line_delete_prev },
1034 { VK_RETURN, edit_line_done },
1035 { VK_DELETE, edit_line_delete_char },
1036 { 0 }
1037 };
1038
1039 static const struct edit_line_key_entry emacs_key_map_ctrl[] =
1040 {
1041 { CTRL('@'), edit_line_set_mark },
1042 { CTRL('A'), edit_line_move_home },
1043 { CTRL('B'), edit_line_move_left },
1044 { CTRL('D'), edit_line_delete_char },
1045 { CTRL('E'), edit_line_move_end },
1046 { CTRL('F'), edit_line_move_right },
1047 { CTRL('H'), edit_line_delete_prev },
1048 { CTRL('J'), edit_line_done },
1049 { CTRL('K'), edit_line_kill_suffix },
1050 { CTRL('L'), edit_line_redraw },
1051 { CTRL('M'), edit_line_done },
1052 { CTRL('N'), edit_line_move_to_next_hist },
1053 { CTRL('P'), edit_line_move_to_prev_hist },
1054 { CTRL('T'), edit_line_transpose_char },
1055 { CTRL('W'), edit_line_kill_marked_zone },
1056 { CTRL('X'), edit_line_exchange_mark },
1057 { CTRL('Y'), edit_line_yank },
1058 { 0 }
1059 };
1060
1061 static const struct edit_line_key_entry emacs_key_map_alt[] =
1062 {
1063 { 0x7f, edit_line_delete_left_word },
1064 { '<', edit_line_move_to_first_hist },
1065 { '>', edit_line_move_to_last_hist },
1066 { 'b', edit_line_move_left_word },
1067 { 'c', edit_line_capitalize_word },
1068 { 'd', edit_line_delete_right_word },
1069 { 'f', edit_line_move_right_word },
1070 { 'l', edit_line_lower_case_word },
1071 { 't', edit_line_transpose_words },
1072 { 'u', edit_line_upper_case_word },
1073 { 'w', edit_line_copy_marked_zone },
1074 { 0 }
1075 };
1076
1077 static const struct edit_line_key_entry emacs_std_key_map[] =
1078 {
1079 { VK_PRIOR, edit_line_move_to_prev_hist },
1080 { VK_NEXT, edit_line_move_to_next_hist },
1081 { VK_END, edit_line_move_end },
1082 { VK_HOME, edit_line_move_home },
1083 { VK_RIGHT, edit_line_move_right },
1084 { VK_LEFT, edit_line_move_left },
1085 { VK_INSERT, edit_line_toggle_insert },
1086 { 0 }
1087 };
1088
1089 static const struct edit_line_key_map emacs_key_map[] =
1090 {
1091 { 0, 0, std_key_map },
1092 { 0, 0, emacs_std_key_map },
1093 { RIGHT_ALT_PRESSED, 1, emacs_key_map_alt },
1094 { LEFT_ALT_PRESSED, 1, emacs_key_map_alt },
1095 { RIGHT_CTRL_PRESSED, 1, emacs_key_map_ctrl },
1096 { LEFT_CTRL_PRESSED, 1, emacs_key_map_ctrl },
1097 { 0 }
1098 };
1099
1100 static const struct edit_line_key_entry win32_std_key_map[] =
1101 {
1102 { VK_LEFT, edit_line_move_left },
1103 { VK_RIGHT, edit_line_move_right },
1104 { VK_HOME, edit_line_move_home },
1105 { VK_END, edit_line_move_end },
1106 { VK_UP, edit_line_move_to_prev_hist },
1107 { VK_DOWN, edit_line_move_to_next_hist },
1108 { VK_INSERT, edit_line_toggle_insert },
1109 { VK_F8, edit_line_find_in_history },
1110 { 0 }
1111 };
1112
1113 static const struct edit_line_key_entry win32_key_map_ctrl[] =
1114 {
1115 { VK_LEFT, edit_line_move_left_word },
1116 { VK_RIGHT, edit_line_move_right_word },
1117 { VK_END, edit_line_kill_suffix },
1118 { VK_HOME, edit_line_kill_prefix },
1119 { 0 }
1120 };
1121
1122 static const struct edit_line_key_map win32_key_map[] =
1123 {
1124 { 0, 0, std_key_map },
1125 { SHIFT_PRESSED, 0, std_key_map },
1126 { 0, 0, win32_std_key_map },
1127 { RIGHT_CTRL_PRESSED, 0, win32_key_map_ctrl },
1128 { LEFT_CTRL_PRESSED, 0, win32_key_map_ctrl },
1129 { 0 }
1130 };
1131 #undef CTRL
1132
1133 static unsigned int edit_line_string_width( const WCHAR *str, unsigned int len)
1134 {
1135 unsigned int i, offset = 0;
1136 for (i = 0; i < len; i++) offset += str[i] < ' ' ? 2 : 1;
1137 return offset;
1138 }
1139
1140 static void update_read_output( struct console *console )
1141 {
1142 struct screen_buffer *screen_buffer = console->active;
1143 struct edit_line *ctx = &console->edit_line;
1144 int offset = 0, j, end_offset;
1145 RECT update_rect;
1146
1147 empty_update_rect( screen_buffer, &update_rect );
1148
1149 if (ctx->update_end >= ctx->update_begin)
1150 {
1151 TRACE( "update %d-%d %s\n", ctx->update_begin, ctx->update_end,
1152 debugstr_wn( ctx->buf + ctx->update_begin, ctx->update_end - ctx->update_begin + 1 ));
1153
1154 hide_tty_cursor( screen_buffer->console );
1155
1156 offset = edit_line_string_width( ctx->buf, ctx->update_begin );
1157 screen_buffer->cursor_x = (ctx->home_x + offset) % screen_buffer->width;
1158 screen_buffer->cursor_y = ctx->home_y + (ctx->home_x + offset) / screen_buffer->width;
1159 for (j = ctx->update_begin; j <= ctx->update_end; j++)
1160 {
1161 if (screen_buffer->cursor_y >= screen_buffer->height && !ctx->home_y) break;
1162 if (j >= ctx->len) break;
1163 if (ctx->buf[j] < ' ')
1164 {
1165 write_char( screen_buffer, '^', &update_rect, &ctx->home_y );
1166 write_char( screen_buffer, '@' + ctx->buf[j], &update_rect, &ctx->home_y );
1167 offset += 2;
1168 }
1169 else
1170 {
1171 write_char( screen_buffer, ctx->buf[j], &update_rect, &ctx->home_y );
1172 offset++;
1173 }
1174 }
1175 end_offset = ctx->end_offset;
1176 ctx->end_offset = offset;
1177 if (j >= ctx->len)
1178 {
1179 /* clear trailing characters if buffer was shortened */
1180 while (offset < end_offset && screen_buffer->cursor_y < screen_buffer->height)
1181 {
1182 write_char( screen_buffer, ' ', &update_rect, &ctx->home_y );
1183 offset++;
1184 }
1185 }
1186 }
1187
1188 if (!ctx->status)
1189 {
1190 offset = edit_line_string_width( ctx->buf, ctx->len );
1191 screen_buffer->cursor_x = 0;
1192 screen_buffer->cursor_y = ctx->home_y + (ctx->home_x + offset) / screen_buffer->width;
1193 if (++screen_buffer->cursor_y >= screen_buffer->height)
1194 new_line( screen_buffer, &update_rect );
1195 }
1196 else
1197 {
1198 offset = edit_line_string_width( ctx->buf, ctx->cursor );
1199 screen_buffer->cursor_y = ctx->home_y + (ctx->home_x + offset) / screen_buffer->width;
1200 if (screen_buffer->cursor_y < screen_buffer->height)
1201 {
1202 screen_buffer->cursor_x = (ctx->home_x + offset) % screen_buffer->width;
1203 }
1204 else
1205 {
1206 screen_buffer->cursor_x = screen_buffer->width - 1;
1207 screen_buffer->cursor_y = screen_buffer->height - 1;
1208 }
1209 }
1210
1211 /* always try to use relative cursor positions in UNIX mode so that it works even if cursor
1212 * position is out of sync */
1213 if (update_rect.left <= update_rect.right && update_rect.top <= update_rect.bottom)
1214 {
1215 if (console->is_unix)
1216 set_tty_cursor_relative( screen_buffer->console, update_rect.left, update_rect.top );
1217 update_output( screen_buffer, &update_rect );
1218 scroll_to_cursor( screen_buffer );
1219 }
1220 if (console->is_unix)
1221 set_tty_cursor_relative( screen_buffer->console, screen_buffer->cursor_x, screen_buffer->cursor_y );
1222 tty_sync( screen_buffer->console );
1223 update_window_config( screen_buffer->console, TRUE );
1224 }
1225
1226 static NTSTATUS process_console_input( struct console *console )
1227 {
1228 struct edit_line *ctx = &console->edit_line;
1229 unsigned int i;
1230
1231 switch (console->read_ioctl)
1232 {
1233 case IOCTL_CONDRV_READ_INPUT:
1234 if (console->record_count) read_console_input( console, console->pending_read );
1235 return STATUS_SUCCESS;
1236 case IOCTL_CONDRV_READ_CONSOLE:
1237 case IOCTL_CONDRV_READ_FILE:
1238 break;
1239 default:
1240 assert( !console->read_ioctl );
1241 if (console->record_count && !console->signaled)
1242 read_complete( console, STATUS_PENDING, NULL, 0, TRUE ); /* signal server */
1243 return STATUS_SUCCESS;
1244 }
1245
1246 ctx->update_begin = ctx->len + 1;
1247 ctx->update_end = 0;
1248
1249 for (i = 0; i < console->record_count && ctx->status == STATUS_PENDING; i++)
1250 {
1251 void (*func)( struct console *console ) = NULL;
1252 INPUT_RECORD ir = console->records[i];
1253
1254 if (ir.EventType != KEY_EVENT || !ir.Event.KeyEvent.bKeyDown) continue;
1255
1256 TRACE( "key code=%02x scan=%02x char=%02x state=%08x\n",
1257 ir.Event.KeyEvent.wVirtualKeyCode, ir.Event.KeyEvent.wVirtualScanCode,
1258 ir.Event.KeyEvent.uChar.UnicodeChar, ir.Event.KeyEvent.dwControlKeyState );
1259
1260 if (console->mode & ENABLE_LINE_INPUT)
1261 {
1262 const struct edit_line_key_entry *entry;
1263 const struct edit_line_key_map *map;
1264 unsigned int state;
1265
1266 /* mask out some bits which don't interest us */
1267 state = ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON|ENHANCED_KEY);
1268
1269 func = NULL;
1270 for (map = console->edition_mode ? emacs_key_map : win32_key_map; map->entries != NULL; map++)
1271 {
1272 if (map->key_state != state)
1273 continue;
1274 if (map->is_char)
1275 {
1276 for (entry = &map->entries[0]; entry->func != 0; entry++)
1277 if (entry->val == ir.Event.KeyEvent.uChar.UnicodeChar) break;
1278 }
1279 else
1280 {
1281 for (entry = &map->entries[0]; entry->func != 0; entry++)
1282 if (entry->val == ir.Event.KeyEvent.wVirtualKeyCode) break;
1283
1284 }
1285 if (entry->func)
1286 {
1287 func = entry->func;
1288 break;
1289 }
1290 }
1291 }
1292
1293 ctx->insert_mode = ((console->mode & (ENABLE_INSERT_MODE | ENABLE_EXTENDED_FLAGS)) ==
1294 (ENABLE_INSERT_MODE | ENABLE_EXTENDED_FLAGS))
1295 ^ ctx->insert_key;
1296
1297 if (func) func( console );
1298 else if (ir.Event.KeyEvent.uChar.UnicodeChar)
1299 edit_line_insert( console, &ir.Event.KeyEvent.uChar.UnicodeChar, 1 );
1300
1301 if (!(console->mode & ENABLE_LINE_INPUT) && ctx->status == STATUS_PENDING)
1302 {
1303 if (console->read_ioctl == IOCTL_CONDRV_READ_FILE)
1304 {
1305 if (WideCharToMultiByte(console->input_cp, 0, ctx->buf, ctx->len, NULL, 0, NULL, NULL)
1306 >= console->pending_read)
1307 ctx->status = STATUS_SUCCESS;
1308 }
1309 else if (ctx->len >= console->pending_read / sizeof(WCHAR))
1310 ctx->status = STATUS_SUCCESS;
1311 }
1312 }
1313
1314 if (console->record_count > i) memmove( console->records, console->records + i,
1315 (console->record_count - i) * sizeof(*console->records) );
1316 console->record_count -= i;
1317
1318 if (ctx->status == STATUS_PENDING && !(console->mode & ENABLE_LINE_INPUT) && ctx->len)
1319 ctx->status = STATUS_SUCCESS;
1320
1321 if (console->mode & ENABLE_ECHO_INPUT) update_read_output( console );
1322 if (ctx->status == STATUS_PENDING) return STATUS_SUCCESS;
1323
1324 if (!ctx->status && (console->mode & ENABLE_LINE_INPUT))
1325 {
1326 if (ctx->len) append_input_history( console, ctx->buf, ctx->len * sizeof(WCHAR) );
1327 if (edit_line_grow(console, 2))
1328 {
1329 ctx->buf[ctx->len++] = '\r';
1330 ctx->buf[ctx->len++] = '\n';
1331 ctx->buf[ctx->len] = 0;
1332 TRACE( "return %s\n", debugstr_wn( ctx->buf, ctx->len ));
1333 }
1334 }
1335
1336 console->read_buffer = ctx->buf;
1337 console->read_buffer_count = ctx->len;
1338 console->read_buffer_size = ctx->size;
1339
1340 if (ctx->status) read_complete( console, ctx->status, NULL, 0, console->record_count );
1341 else read_from_buffer( console, console->pending_read );
1342
1343 /* reset context */
1344 free( ctx->yanked );
1345 free( ctx->current_history );
1346 memset( &console->edit_line, 0, sizeof(console->edit_line) );
1347 return STATUS_SUCCESS;
1348 }
1349
1350 static NTSTATUS read_console( struct console *console, unsigned int ioctl, size_t out_size )
1351 {
1352 TRACE("\n");
1353
1354 if (out_size > INT_MAX)
1355 {
1356 read_complete( console, STATUS_NO_MEMORY, NULL, 0, console->record_count );
1357 return STATUS_NO_MEMORY;
1358 }
1359
1360 console->read_ioctl = ioctl;
1361 if (!out_size || console->read_buffer_count)
1362 {
1363 read_from_buffer( console, out_size );
1364 return STATUS_SUCCESS;
1365 }
1366
1367 console->edit_line.history_index = console->history_index;
1368 console->edit_line.home_x = console->active->cursor_x;
1369 console->edit_line.home_y = console->active->cursor_y;
1370 console->edit_line.status = STATUS_PENDING;
1371 if (edit_line_grow( console, 1 )) console->edit_line.buf[0] = 0;
1372
1373 console->pending_read = out_size;
1374 return process_console_input( console );
1375 }
1376
1377 /* add input events to a console input queue */
1378 NTSTATUS write_console_input( struct console *console, const INPUT_RECORD *records,
1379 unsigned int count, BOOL flush )
1380 {
1381 TRACE( "%u\n", count );
1382
1383 if (!count) return STATUS_SUCCESS;
1384 if (console->record_count + count > console->record_size)
1385 {
1386 INPUT_RECORD *new_rec;
1387 if (!(new_rec = realloc( console->records, (console->record_size * 2 + count) * sizeof(INPUT_RECORD) )))
1388 return STATUS_NO_MEMORY;
1389 console->records = new_rec;
1390 console->record_size = console->record_size * 2 + count;
1391 }
1392 memcpy( console->records + console->record_count, records, count * sizeof(INPUT_RECORD) );
1393
1394 if (console->mode & ENABLE_PROCESSED_INPUT)
1395 {
1396 unsigned int i = 0;
1397 while (i < count)
1398 {
1399 if (records[i].EventType == KEY_EVENT &&
1400 records[i].Event.KeyEvent.uChar.UnicodeChar == 'C' - 64 &&
1401 !(records[i].Event.KeyEvent.dwControlKeyState & ENHANCED_KEY))
1402 {
1403 if (i != count - 1)
1404 memcpy( &console->records[console->record_count + i],
1405 &console->records[console->record_count + i + 1],
1406 (count - i - 1) * sizeof(INPUT_RECORD) );
1407 count--;
1408 if (records[i].Event.KeyEvent.bKeyDown)
1409 {
1410 struct condrv_ctrl_event ctrl_event;
1411 IO_STATUS_BLOCK io;
1412
1413 ctrl_event.event = CTRL_C_EVENT;
1414 ctrl_event.group_id = 0;
1415 NtDeviceIoControlFile( console->server, NULL, NULL, NULL, &io, IOCTL_CONDRV_CTRL_EVENT,
1416 &ctrl_event, sizeof(ctrl_event), NULL, 0 );
1417
1418 }
1419 }
1420 else i++;
1421 }
1422 }
1423 console->record_count += count;
1424 return flush ? process_console_input( console ) : STATUS_SUCCESS;
1425 }
1426
1427 static void set_key_input_record( INPUT_RECORD *record, WCHAR ch, unsigned int vk, BOOL is_down, unsigned int ctrl_state )
1428 {
1429 record->EventType = KEY_EVENT;
1430 record->Event.KeyEvent.bKeyDown = is_down;
1431 record->Event.KeyEvent.wRepeatCount = 1;
1432 record->Event.KeyEvent.uChar.UnicodeChar = ch;
1433 record->Event.KeyEvent.wVirtualKeyCode = vk;
1434 record->Event.KeyEvent.wVirtualScanCode = MapVirtualKeyW( vk, MAPVK_VK_TO_VSC );
1435 record->Event.KeyEvent.dwControlKeyState = ctrl_state;
1436 }
1437
1438 static NTSTATUS key_press( struct console *console, WCHAR ch, unsigned int vk, unsigned int ctrl_state )
1439 {
1440 INPUT_RECORD records[8];
1441 unsigned int count = 0, ctrl = 0;
1442
1443 if (ctrl_state & SHIFT_PRESSED)
1444 {
1445 ctrl |= SHIFT_PRESSED;
1446 set_key_input_record( &records[count++], 0, VK_SHIFT, TRUE, ctrl );
1447 }
1448 if (ctrl_state & LEFT_ALT_PRESSED)
1449 {
1450 ctrl |= LEFT_ALT_PRESSED;
1451 set_key_input_record( &records[count++], 0, VK_MENU, TRUE, ctrl );
1452 }
1453 if (ctrl_state & LEFT_CTRL_PRESSED)
1454 {
1455 ctrl |= LEFT_CTRL_PRESSED;
1456 set_key_input_record( &records[count++], 0, VK_CONTROL, TRUE, ctrl );
1457 }
1458
1459 set_key_input_record( &records[count++], ch, vk, TRUE, ctrl );
1460 set_key_input_record( &records[count++], ch, vk, FALSE, ctrl );
1461
1462 if (ctrl & LEFT_CTRL_PRESSED)
1463 {
1464 ctrl &= ~LEFT_CTRL_PRESSED;
1465 set_key_input_record( &records[count++], 0, VK_CONTROL, FALSE, ctrl );
1466 }
1467 if (ctrl & LEFT_ALT_PRESSED)
1468 {
1469 ctrl &= ~LEFT_ALT_PRESSED;
1470 set_key_input_record( &records[count++], 0, VK_MENU, FALSE, ctrl );
1471 }
1472 if (ctrl & SHIFT_PRESSED)
1473 {
1474 ctrl &= ~SHIFT_PRESSED;
1475 set_key_input_record( &records[count++], 0, VK_SHIFT, FALSE, ctrl );
1476 }
1477
1478 return write_console_input( console, records, count, FALSE );
1479 }
1480
1481 static void char_key_press( struct console *console, WCHAR ch, unsigned int ctrl )
1482 {
1483 unsigned int vk = VkKeyScanW( ch );
1484 if (vk == ~0) vk = 0;
1485 if (vk & 0x0100) ctrl |= SHIFT_PRESSED;
1486 if (vk & 0x0200) ctrl |= LEFT_CTRL_PRESSED;
1487 if (vk & 0x0400) ctrl |= LEFT_ALT_PRESSED;
1488 vk &= 0xff;
1489 key_press( console, ch, vk, ctrl );
1490 }
1491
1492 static unsigned int escape_char_to_vk( WCHAR ch )
1493 {
1494 switch (ch)
1495 {
1496 case 'A': return VK_UP;
1497 case 'B': return VK_DOWN;
1498 case 'C': return VK_RIGHT;
1499 case 'D': return VK_LEFT;
1500 case 'H': return VK_HOME;
1501 case 'F': return VK_END;
1502 case 'P': return VK_F1;
1503 case 'Q': return VK_F2;
1504 case 'R': return VK_F3;
1505 case 'S': return VK_F4;
1506 default: return 0;
1507 }
1508 }
1509
1510 static unsigned int escape_number_to_vk( unsigned int n )
1511 {
1512 switch(n)
1513 {
1514 case 2: return VK_INSERT;
1515 case 3: return VK_DELETE;
1516 case 5: return VK_PRIOR;
1517 case 6: return VK_NEXT;
1518 case 15: return VK_F5;
1519 case 17: return VK_F6;
1520 case 18: return VK_F7;
1521 case 19: return VK_F8;
1522 case 20: return VK_F9;
1523 case 21: return VK_F10;
1524 case 23: return VK_F11;
1525 case 24: return VK_F12;
1526 default: return 0;
1527 }
1528 }
1529
1530 static unsigned int convert_modifiers( unsigned int n )
1531 {
1532 unsigned int ctrl = 0;
1533 if (!n || n > 16) return 0;
1534 n--;
1535 if (n & 1) ctrl |= SHIFT_PRESSED;
1536 if (n & 2) ctrl |= LEFT_ALT_PRESSED;
1537 if (n & 4) ctrl |= LEFT_CTRL_PRESSED;
1538 return ctrl;
1539 }
1540
1541 static unsigned int process_csi_sequence( struct console *console, const WCHAR *buf, size_t size )
1542 {
1543 unsigned int n, count = 0, params[8], params_cnt = 0, vk;
1544
1545 for (;;)
1546 {
1547 n = 0;
1548 while (count < size && '0' <= buf[count] && buf[count] <= '9')
1549 n = n * 10 + buf[count++] - '0';
1550 if (params_cnt < ARRAY_SIZE(params)) params[params_cnt++] = n;
1551 else FIXME( "too many params, skipping %u\n", n );
1552 if (count == size) return 0;
1553 if (buf[count] != ';') break;
1554 if (++count == size) return 0;
1555 }
1556
1557 if ((vk = escape_char_to_vk( buf[count] )))
1558 {
1559 key_press( console, 0, vk, params_cnt >= 2 ? convert_modifiers( params[1] ) : 0 );
1560 return count + 1;
1561 }
1562
1563 switch (buf[count])
1564 {
1565 case '~':
1566 vk = escape_number_to_vk( params[0] );
1567 key_press( console, 0, vk, params_cnt == 2 ? convert_modifiers( params[1] ) : 0 );
1568 return count + 1;
1569
1570 default:
1571 FIXME( "unhandled sequence %s\n", debugstr_wn( buf, size ));
1572 return 0;
1573 }
1574 }
1575
1576 static unsigned int process_input_escape( struct console *console, const WCHAR *buf, size_t size )
1577 {
1578 unsigned int vk = 0, count = 0, nlen;
1579
1580 if (!size)
1581 {
1582 key_press( console, 0, VK_ESCAPE, 0 );
1583 return 0;
1584 }
1585
1586 switch(buf[0])
1587 {
1588 case '[':
1589 if (++count == size) break;
1590 if ((nlen = process_csi_sequence( console, buf + 1, size - 1 ))) return count + nlen;
1591 break;
1592
1593 case 'O':
1594 if (++count == size) break;
1595 vk = escape_char_to_vk( buf[1] );
1596 if (vk)
1597 {
1598 key_press( console, 0, vk, 0 );
1599 return count + 1;
1600 }
1601 }
1602
1603 char_key_press( console, buf[0], LEFT_ALT_PRESSED );
1604 return 1;
1605 }
1606
1607 static DWORD WINAPI tty_input( void *param )
1608 {
1609 struct console *console = param;
1610 IO_STATUS_BLOCK io;
1611 HANDLE event;
1612 char read_buf[4096];
1613 WCHAR buf[4096];
1614 DWORD count, i;
1615 BOOL signaled;
1616 NTSTATUS status;
1617
1618 if (console->is_unix)
1619 {
1620 unsigned int h = condrv_handle( console->tty_input );
1621 status = NtDeviceIoControlFile( console->server, NULL, NULL, NULL, &io, IOCTL_CONDRV_SETUP_INPUT,
1622 &h, sizeof(h), NULL, 0 );
1623 if (status) ERR( "input setup failed: %#x\n", status );
1624 }
1625
1626 event = CreateEventW( NULL, TRUE, FALSE, NULL );
1627
1628 for (;;)
1629 {
1630 status = NtReadFile( console->tty_input, event, NULL, NULL, &io, read_buf, sizeof(read_buf), NULL, NULL );
1631 if (status == STATUS_PENDING)
1632 {
1633 if ((status = NtWaitForSingleObject( event, FALSE, NULL ))) break;
1634 status = io.Status;
1635 }
1636 if (status) break;
1637
1638 EnterCriticalSection( &console_section );
1639 signaled = console->record_count != 0;
1640
1641 /* FIXME: Handle partial char read */
1642 count = MultiByteToWideChar( get_tty_cp( console ), 0, read_buf, io.Information, buf, ARRAY_SIZE(buf) );
1643
1644 TRACE( "%s\n", debugstr_wn(buf, count) );
1645
1646 for (i = 0; i < count; i++)
1647 {
1648 WCHAR ch = buf[i];
1649 switch (ch)
1650 {
1651 case 3: /* end of text */
1652 LeaveCriticalSection( &console_section );
1653 goto done;
1654 case '\n':
1655 key_press( console, '\n', VK_RETURN, LEFT_CTRL_PRESSED );
1656 break;
1657 case '\b':
1658 key_press( console, ch, 'H', LEFT_CTRL_PRESSED );
1659 break;
1660 case 0x1b:
1661 i += process_input_escape( console, buf + i + 1, count - i - 1 );
1662 break;
1663 case 0x7f:
1664 key_press( console, '\b', VK_BACK, 0 );
1665 break;
1666 default:
1667 char_key_press( console, ch, 0 );
1668 }
1669 }
1670
1671 process_console_input( console );
1672 if (!signaled && console->record_count)
1673 {
1674 assert( !console->read_ioctl );
1675 read_complete( console, STATUS_SUCCESS, NULL, 0, TRUE ); /* signal console */
1676 }
1677 LeaveCriticalSection( &console_section );
1678 }
1679
1680 TRACE( "NtReadFile failed: %#x\n", status );
1681
1682 done:
1683 EnterCriticalSection( &console_section );
1684 if (console->read_ioctl) read_complete( console, status, NULL, 0, FALSE );
1685 if (console->is_unix)
1686 {
1687 unsigned int h = 0;
1688 status = NtDeviceIoControlFile( console->server, NULL, NULL, NULL, &io, IOCTL_CONDRV_SETUP_INPUT,
1689 &h, sizeof(h), NULL, 0 );
1690 if (status) ERR( "input restore failed: %#x\n", status );
1691 }
1692 CloseHandle( console->input_thread );
1693 console->input_thread = NULL;
1694 LeaveCriticalSection( &console_section );
1695
1696 return 0;
1697 }
1698
1699 static BOOL ensure_tty_input_thread( struct console *console )
1700 {
1701 if (!console->tty_input) return TRUE;
1702 if (!console->input_thread)
1703 console->input_thread = CreateThread( NULL, 0, tty_input, console, 0, NULL );
1704 return console->input_thread != NULL;
1705 }
1706
1707 static NTSTATUS screen_buffer_activate( struct screen_buffer *screen_buffer )
1708 {
1709 RECT update_rect;
1710 TRACE( "%p\n", screen_buffer );
1711 screen_buffer->console->active = screen_buffer;
1712 SetRect( &update_rect, 0, 0, screen_buffer->width - 1, screen_buffer->height - 1 );
1713 update_output( screen_buffer, &update_rect );
1714 tty_sync( screen_buffer->console );
1715 update_window_config( screen_buffer->console, FALSE );
1716 return STATUS_SUCCESS;
1717 }
1718
1719 static NTSTATUS get_output_info( struct screen_buffer *screen_buffer, size_t *out_size )
1720 {
1721 struct condrv_output_info *info;
1722
1723 *out_size = min( *out_size, sizeof(*info) + screen_buffer->font.face_len );
1724 if (!(info = alloc_ioctl_buffer( *out_size ))) return STATUS_NO_MEMORY;
1725
1726 info->cursor_size = screen_buffer->cursor_size;
1727 info->cursor_visible = screen_buffer->cursor_visible;
1728 info->cursor_x = get_bounded_cursor_x( screen_buffer );
1729 info->cursor_y = screen_buffer->cursor_y;
1730 info->width = screen_buffer->width;
1731 info->height = screen_buffer->height;
1732 info->attr = screen_buffer->attr;
1733 info->popup_attr = screen_buffer->popup_attr;
1734 info->win_left = screen_buffer->win.left;
1735 info->win_top = screen_buffer->win.top;
1736 info->win_right = screen_buffer->win.right;
1737 info->win_bottom = screen_buffer->win.bottom;
1738 info->max_width = screen_buffer->max_width;
1739 info->max_height = screen_buffer->max_height;
1740 info->font_width = screen_buffer->font.width;
1741 info->font_height = screen_buffer->font.height;
1742 info->font_weight = screen_buffer->font.weight;
1743 info->font_pitch_family = screen_buffer->font.pitch_family;
1744 memcpy( info->color_map, screen_buffer->color_map, sizeof(info->color_map) );
1745 if (*out_size > sizeof(*info)) memcpy( info + 1, screen_buffer->font.face_name, *out_size - sizeof(*info) );
1746
1747 TRACE( "%p cursor_size=%u cursor_visible=%x cursor=(%u,%u) width=%u height=%u win=%s attr=%x popup_attr=%x"
1748 " font_width=%u font_height=%u %s\n", screen_buffer, info->cursor_size, info->cursor_visible,
1749 info->cursor_x, info->cursor_y, info->width, info->height, wine_dbgstr_rect(&screen_buffer->win),
1750 info->attr, info->popup_attr, info->font_width, info->font_height,
1751 debugstr_wn( (const WCHAR *)(info + 1), (*out_size - sizeof(*info)) / sizeof(WCHAR) ) );
1752 return STATUS_SUCCESS;
1753 }
1754
1755 void notify_screen_buffer_size( struct screen_buffer *screen_buffer )
1756 {
1757 if (is_active( screen_buffer ) && screen_buffer->console->mode & ENABLE_WINDOW_INPUT)
1758 {
1759 INPUT_RECORD ir;
1760 ir.EventType = WINDOW_BUFFER_SIZE_EVENT;
1761 ir.Event.WindowBufferSizeEvent.dwSize.X = screen_buffer->width;
1762 ir.Event.WindowBufferSizeEvent.dwSize.Y = screen_buffer->height;
1763 write_console_input( screen_buffer->console, &ir, 1, TRUE );
1764 }
1765 }
1766
1767 NTSTATUS change_screen_buffer_size( struct screen_buffer *screen_buffer, int new_width, int new_height )
1768 {
1769 int i, old_width, old_height, copy_width, copy_height;
1770 char_info_t *new_data;
1771
1772 if (!(new_data = malloc( new_width * new_height * sizeof(*new_data) ))) return STATUS_NO_MEMORY;
1773
1774 old_width = screen_buffer->width;
1775 old_height = screen_buffer->height;
1776 copy_width = min( old_width, new_width );
1777 copy_height = min( old_height, new_height );
1778
1779 /* copy all the rows */
1780 for (i = 0; i < copy_height; i++)
1781 {
1782 memcpy( &new_data[i * new_width], &screen_buffer->data[i * old_width],
1783 copy_width * sizeof(char_info_t) );
1784 }
1785
1786 /* clear the end of each row */
1787 if (new_width > old_width)
1788 {
1789 /* fill first row */
1790 for (i = old_width; i < new_width; i++) new_data[i] = empty_char_info;
1791 /* and blast it to the other rows */
1792 for (i = 1; i < copy_height; i++)
1793 memcpy( &new_data[i * new_width + old_width], &new_data[old_width],
1794 (new_width - old_width) * sizeof(char_info_t) );
1795 }
1796
1797 /* clear remaining rows */
1798 if (new_height > old_height)
1799 {
1800 /* fill first row */
1801 for (i = 0; i < new_width; i++) new_data[old_height * new_width + i] = empty_char_info;
1802 /* and blast it to the other rows */
1803 for (i = old_height+1; i < new_height; i++)
1804 memcpy( &new_data[i * new_width], &new_data[old_height * new_width],
1805 new_width * sizeof(char_info_t) );
1806 }
1807 free( screen_buffer->data );
1808 screen_buffer->data = new_data;
1809 screen_buffer->width = new_width;
1810 screen_buffer->height = new_height;
1811 return STATUS_SUCCESS;
1812 }
1813
1814 static NTSTATUS set_output_info( struct screen_buffer *screen_buffer,
1815 const struct condrv_output_info_params *params, size_t extra_size )
1816 {
1817 const struct condrv_output_info *info = &params->info;
1818 NTSTATUS status;
1819
1820 TRACE( "%p\n", screen_buffer );
1821
1822 extra_size -= sizeof(*params);
1823
1824 if (params->mask & SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM)
1825 {
1826 if (info->cursor_size < 1 || info->cursor_size > 100) return STATUS_INVALID_PARAMETER;
1827
1828 screen_buffer->cursor_size = info->cursor_size;
1829 screen_buffer->cursor_visible = !!info->cursor_visible;
1830 }
1831 if (params->mask & SET_CONSOLE_OUTPUT_INFO_CURSOR_POS)
1832 {
1833 if (info->cursor_x < 0 || info->cursor_x >= screen_buffer->width ||
1834 info->cursor_y < 0 || info->cursor_y >= screen_buffer->height)
1835 {
1836 return STATUS_INVALID_PARAMETER;
1837 }
1838
1839 if (screen_buffer->cursor_x != info->cursor_x || screen_buffer->cursor_y != info->cursor_y)
1840 {
1841 screen_buffer->cursor_x = info->cursor_x;
1842 screen_buffer->cursor_y = info->cursor_y;
1843 scroll_to_cursor( screen_buffer );
1844 }
1845 }
1846 if (params->mask & SET_CONSOLE_OUTPUT_INFO_SIZE)
1847 {
1848 /* new screen-buffer cannot be smaller than actual window */
1849 if (info->width < screen_buffer->win.right - screen_buffer->win.left + 1 ||
1850 info->height < screen_buffer->win.bottom - screen_buffer->win.top + 1)
1851 {
1852 return STATUS_INVALID_PARAMETER;
1853 }
1854 /* FIXME: there are also some basic minimum and max size to deal with */
1855 if ((status = change_screen_buffer_size( screen_buffer, info->width, info->height ))) return status;
1856
1857 /* scroll window to display sb */
1858 if (screen_buffer->win.right >= info->width)
1859 {
1860 screen_buffer->win.right -= screen_buffer->win.left;
1861 screen_buffer->win.left = 0;
1862 }
1863 if (screen_buffer->win.bottom >= info->height)
1864 {
1865 screen_buffer->win.bottom -= screen_buffer->win.top;
1866 screen_buffer->win.top = 0;
1867 }
1868 if (screen_buffer->cursor_x >= info->width) screen_buffer->cursor_x = info->width - 1;
1869 if (screen_buffer->cursor_y >= info->height) screen_buffer->cursor_y = info->height - 1;
1870
1871 notify_screen_buffer_size( screen_buffer );
1872 }
1873 if (params->mask & SET_CONSOLE_OUTPUT_INFO_ATTR)
1874 {
1875 screen_buffer->attr = info->attr;
1876 }
1877 if (params->mask & SET_CONSOLE_OUTPUT_INFO_POPUP_ATTR)
1878 {
1879 screen_buffer->popup_attr = info->popup_attr;
1880 }
1881 if (params->mask & SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW)
1882 {
1883 if (info->win_left < 0 || info->win_left > info->win_right ||
1884 info->win_right >= screen_buffer->width ||
1885 info->win_top < 0 || info->win_top > info->win_bottom ||
1886 info->win_bottom >= screen_buffer->height)
1887 {
1888 return STATUS_INVALID_PARAMETER;
1889 }
1890 if (screen_buffer->win.left != info->win_left || screen_buffer->win.top != info->win_top ||
1891 screen_buffer->win.right != info->win_right || screen_buffer->win.bottom != info->win_bottom)
1892 {
1893 screen_buffer->win.left = info->win_left;
1894 screen_buffer->win.top = info->win_top;
1895 screen_buffer->win.right = info->win_right;
1896 screen_buffer->win.bottom = info->win_bottom;
1897 }
1898 }
1899 if (params->mask & SET_CONSOLE_OUTPUT_INFO_MAX_SIZE)
1900 {
1901 screen_buffer->max_width = info->max_width;
1902 screen_buffer->max_height = info->max_height;
1903 }
1904
1905 if (is_active( screen_buffer ))
1906 {
1907 tty_sync( screen_buffer->console );
1908 update_window_config( screen_buffer->console, FALSE );
1909 }
1910 return STATUS_SUCCESS;
1911 }
1912
1913 static NTSTATUS write_console( struct screen_buffer *screen_buffer, const WCHAR *buffer, size_t len )
1914 {
1915 RECT update_rect;
1916 size_t i, j;
1917
1918 TRACE( "%s\n", debugstr_wn(buffer, len) );
1919
1920 empty_update_rect( screen_buffer, &update_rect );
1921
1922 for (i = 0; i < len; i++)
1923 {
1924 if (screen_buffer->mode & ENABLE_PROCESSED_OUTPUT)
1925 {
1926 switch (buffer[i])
1927 {
1928 case '\b':
1929 screen_buffer->cursor_x = get_bounded_cursor_x( screen_buffer );
1930 if (screen_buffer->cursor_x) screen_buffer->cursor_x--;
1931 continue;
1932 case '\t':
1933 j = min( screen_buffer->width - screen_buffer->cursor_x, 8 - (screen_buffer->cursor_x % 8) );
1934 if (!j) j = 8;
1935 while (j--) write_char( screen_buffer, ' ', &update_rect, NULL );
1936 continue;
1937 case '\n':
1938 screen_buffer->cursor_x = 0;
1939 if (++screen_buffer->cursor_y == screen_buffer->height)
1940 new_line( screen_buffer, &update_rect );
1941 else if (screen_buffer->mode & ENABLE_WRAP_AT_EOL_OUTPUT)
1942 {
1943 update_output( screen_buffer, &update_rect );
1944 set_tty_cursor( screen_buffer->console, screen_buffer->cursor_x, screen_buffer->cursor_y );
1945 }
1946 continue;
1947 case '\a':
1948 FIXME( "beep\n" );
1949 continue;
1950 case '\r':
1951 screen_buffer->cursor_x = 0;
1952 continue;
1953 }
1954 }
1955 if (screen_buffer->cursor_x == screen_buffer->width && !(screen_buffer->mode & ENABLE_WRAP_AT_EOL_OUTPUT))
1956 screen_buffer->cursor_x = update_rect.left;
1957 write_char( screen_buffer, buffer[i], &update_rect, NULL );
1958 }
1959
1960 if (screen_buffer->cursor_x == screen_buffer->width)
1961 {
1962 if (screen_buffer->mode & ENABLE_WRAP_AT_EOL_OUTPUT)
1963 {
1964 if (!(screen_buffer->mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING))
1965 {
1966 screen_buffer->cursor_x = 0;
1967 if (++screen_buffer->cursor_y == screen_buffer->height)
1968 new_line( screen_buffer, &update_rect );
1969 }
1970 }
1971 else screen_buffer->cursor_x = update_rect.left;
1972 }
1973
1974 scroll_to_cursor( screen_buffer );
1975 update_output( screen_buffer, &update_rect );
1976 tty_sync( screen_buffer->console );
1977 update_window_config( screen_buffer->console, TRUE );
1978 return STATUS_SUCCESS;
1979 }
1980
1981 static NTSTATUS write_output( struct screen_buffer *screen_buffer, const struct condrv_output_params *params,
1982 size_t in_size, size_t *out_size )
1983 {
1984 unsigned int i, entry_size, entry_cnt, x, y;
1985 char_info_t *dest;
1986 char *src;
1987
1988 if (*out_size == sizeof(SMALL_RECT) && !params->width) return STATUS_INVALID_PARAMETER;
1989
1990 entry_size = params->mode == CHAR_INFO_MODE_TEXTATTR ? sizeof(char_info_t) : sizeof(WCHAR);
1991 entry_cnt = (in_size - sizeof(*params)) / entry_size;
1992
1993 TRACE( "(%u,%u) cnt %u\n", params->x, params->y, entry_cnt );
1994
1995 if (params->x >= screen_buffer->width)
1996 {
1997 *out_size = 0;
1998 return STATUS_SUCCESS;
1999 }
2000
2001 for (i = 0, src = (char *)(params + 1); i < entry_cnt; i++, src += entry_size)
2002 {
2003 if (params->width)
2004 {
2005 x = params->x + i % params->width;
2006 y = params->y + i / params->width;
2007 if (x >= screen_buffer->width) continue;
2008 }
2009 else
2010 {
2011 x = (params->x + i) % screen_buffer->width;
2012 y = params->y + (params->x + i) / screen_buffer->width;
2013 }
2014 if (y >= screen_buffer->height) break;
2015
2016 dest = &screen_buffer->data[y * screen_buffer->width + x];
2017 switch(params->mode)
2018 {
2019 case CHAR_INFO_MODE_TEXT:
2020 dest->ch = *(const WCHAR *)src;
2021 break;
2022 case CHAR_INFO_MODE_ATTR:
2023 dest->attr = *(const unsigned short *)src;
2024 break;
2025 case CHAR_INFO_MODE_TEXTATTR:
2026 *dest = *(const char_info_t *)src;
2027 break;
2028 default:
2029 return STATUS_INVALID_PARAMETER;
2030 }
2031 }
2032
2033 if (i && is_active( screen_buffer ))
2034 {
2035 RECT update_rect;
2036
2037 update_rect.left = params->x;
2038 update_rect.top = params->y;
2039 if (params->width)
2040 {
2041 update_rect.bottom = min( params->y + entry_cnt / params->width, screen_buffer->height ) - 1;
2042 update_rect.right = min( params->x + params->width, screen_buffer->width ) - 1;
2043 }
2044 else
2045 {
2046 update_rect.bottom = params->y + (params->x + i - 1) / screen_buffer->width;
2047 if (update_rect.bottom != params->y)
2048 {
2049 update_rect.left = 0;
2050 update_rect.right = screen_buffer->width - 1;
2051 }
2052 else
2053 {
2054 update_rect.right = params->x + i - 1;
2055 }
2056 }
2057 update_output( screen_buffer, &update_rect );
2058 tty_sync( screen_buffer->console );
2059 }
2060
2061 if (*out_size == sizeof(SMALL_RECT))
2062 {
2063 SMALL_RECT *region;
2064 unsigned int width = params->width;
2065 x = params->x;
2066 y = params->y;
2067 if (!(region = alloc_ioctl_buffer( sizeof(*region )))) return STATUS_NO_MEMORY;
2068 region->Left = x;
2069 region->Top = y;
2070 region->Right = min( x + width, screen_buffer->width ) - 1;
2071 region->Bottom = min( y + entry_cnt / width, screen_buffer->height ) - 1;
2072 }
2073 else
2074 {
2075 DWORD *result;
2076 if (!(result = alloc_ioctl_buffer( sizeof(*result )))) return STATUS_NO_MEMORY;
2077 *result = i;
2078 }
2079
2080 return STATUS_SUCCESS;
2081 }
2082
2083 static NTSTATUS read_output( struct screen_buffer *screen_buffer, const struct condrv_output_params *params,
2084 size_t *out_size )
2085 {
2086 enum char_info_mode mode;
2087 unsigned int x, y, width;
2088 unsigned int i, count;
2089
2090 x = params->x;
2091 y = params->y;
2092 mode = params->mode;
2093 width = params->width;
2094 TRACE( "(%u %u) mode %u width %u\n", x, y, mode, width );
2095
2096 switch(mode)
2097 {
2098 case CHAR_INFO_MODE_TEXT:
2099 {
2100 WCHAR *data;
2101 char_info_t *src;
2102 if (x >= screen_buffer->width || y >= screen_buffer->height)
2103 {
2104 *out_size = 0;
2105 return STATUS_SUCCESS;
2106 }
2107 src = screen_buffer->data + y * screen_buffer->width + x;
2108 count = min( screen_buffer->data + screen_buffer->height * screen_buffer->width - src,
2109 *out_size / sizeof(*data) );
2110 *out_size = count * sizeof(*data);
2111 if (!(data = alloc_ioctl_buffer( *out_size ))) return STATUS_NO_MEMORY;
2112 for (i = 0; i < count; i++) data[i] = src[i].ch;
2113 }
2114 break;
2115 case CHAR_INFO_MODE_ATTR:
2116 {
2117 unsigned short *data;
2118 char_info_t *src;
2119 if (x >= screen_buffer->width || y >= screen_buffer->height)
2120 {
2121 *out_size = 0;
2122 return STATUS_SUCCESS;
2123 }
2124 src = screen_buffer->data + y * screen_buffer->width + x;
2125 count = min( screen_buffer->data + screen_buffer->height * screen_buffer->width - src,
2126 *out_size / sizeof(*data) );
2127 *out_size = count * sizeof(*data);
2128 if (!(data = alloc_ioctl_buffer( *out_size ))) return STATUS_NO_MEMORY;
2129 for (i = 0; i < count; i++) data[i] = src[i].attr;
2130 }
2131 break;
2132 case CHAR_INFO_MODE_TEXTATTR:
2133 {
2134 SMALL_RECT *region;
2135 char_info_t *data;
2136 if (!width || *out_size < sizeof(*region) || x >= screen_buffer->width || y >= screen_buffer->height)
2137 return STATUS_INVALID_PARAMETER;
2138 count = min( (*out_size - sizeof(*region)) / (width * sizeof(*data)), screen_buffer->height - y );
2139 width = min( width, screen_buffer->width - x );
2140 *out_size = sizeof(*region) + width * count * sizeof(*data);
2141 if (!(region = alloc_ioctl_buffer( *out_size ))) return STATUS_NO_MEMORY;
2142 region->Left = x;
2143 region->Top = y;
2144 region->Right = x + width - 1;
2145 region->Bottom = y + count - 1;
2146 data = (char_info_t *)(region + 1);
2147 for (i = 0; i < count; i++)
2148 {
2149 memcpy( &data[i * width], &screen_buffer->data[(y + i) * screen_buffer->width + x],
2150 width * sizeof(*data) );
2151 }
2152 }
2153 break;
2154 default:
2155 return STATUS_INVALID_PARAMETER;
2156 }
2157
2158 return STATUS_SUCCESS;
2159 }
2160
2161 static NTSTATUS fill_output( struct screen_buffer *screen_buffer, const struct condrv_fill_output_params *params )
2162 {
2163 char_info_t *end, *dest;
2164 DWORD i, count, *result;
2165
2166 TRACE( "(%u %u) mode %u\n", params->x, params->y, params->mode );
2167
2168 if (params->y >= screen_buffer->height) return STATUS_SUCCESS;
2169 dest = screen_buffer->data + min( params->y * screen_buffer->width + params->x,
2170 screen_buffer->height * screen_buffer->width );
2171
2172 end = screen_buffer->data + screen_buffer->height * screen_buffer->width;
2173
2174 count = params->count;
2175 if (count > end - dest) count = end - dest;
2176
2177 switch(params->mode)
2178 {
2179 case CHAR_INFO_MODE_TEXT:
2180 for (i = 0; i < count; i++) dest[i].ch = params->ch;
2181 break;
2182 case CHAR_INFO_MODE_ATTR:
2183 for (i = 0; i < count; i++) dest[i].attr = params->attr;
2184 break;
2185 case CHAR_INFO_MODE_TEXTATTR:
2186 for (i = 0; i < count; i++)
2187 {
2188 dest[i].ch = params->ch;
2189 dest[i].attr = params->attr;
2190 }
2191 break;
2192 default:
2193 return STATUS_INVALID_PARAMETER;
2194 }
2195
2196 if (count && is_active(screen_buffer))
2197 {
2198 RECT update_rect;
2199 SetRect( &update_rect,
2200 params->x % screen_buffer->width,
2201 params->y + params->x / screen_buffer->width,
2202 (params->x + i - 1) % screen_buffer->width,
2203 params->y + (params->x + i - 1) / screen_buffer->width );
2204 update_output( screen_buffer, &update_rect );
2205 tty_sync( screen_buffer->console );
2206 }
2207
2208 if (!(result = alloc_ioctl_buffer( sizeof(*result) ))) return STATUS_NO_MEMORY;
2209 *result = count;
2210 return STATUS_SUCCESS;
2211 }
2212
2213 static NTSTATUS scroll_output( struct screen_buffer *screen_buffer, const struct condrv_scroll_params *params )
2214 {
2215 int x, y, xsrc, ysrc, w, h;
2216 char_info_t *psrc, *pdst;
2217 SMALL_RECT src, dst;
2218 RECT update_rect;
2219 SMALL_RECT clip;
2220
2221 xsrc = params->scroll.Left;
2222 ysrc = params->scroll.Top;
2223 w = params->scroll.Right - params->scroll.Left + 1;
2224 h = params->scroll.Bottom - params->scroll.Top + 1;
2225
2226 TRACE( "(%d %d) -> (%u %u) w %u h %u\n", xsrc, ysrc, params->origin.X, params->origin.Y, w, h );
2227
2228 clip.Left = max( params->clip.Left, 0 );
2229 clip.Top = max( params->clip.Top, 0 );
2230 clip.Right = min( params->clip.Right, screen_buffer->width - 1 );
2231 clip.Bottom = min( params->clip.Bottom, screen_buffer->height - 1 );
2232 if (clip.Left > clip.Right || clip.Top > clip.Bottom || params->scroll.Left < 0 || params->scroll.Top < 0 ||
2233 params->scroll.Right >= screen_buffer->width || params->scroll.Bottom >= screen_buffer->height ||
2234 params->scroll.Right < params->scroll.Left || params->scroll.Top > params->scroll.Bottom ||
2235 params->origin.X < 0 || params->origin.X >= screen_buffer->width || params->origin.Y < 0 ||
2236 params->origin.Y >= screen_buffer->height)
2237 return STATUS_INVALID_PARAMETER;
2238
2239 src.Left = max( xsrc, clip.Left );
2240 src.Top = max( ysrc, clip.Top );
2241 src.Right = min( xsrc + w - 1, clip.Right );
2242 src.Bottom = min( ysrc + h - 1, clip.Bottom );
2243
2244 dst.Left = params->origin.X;
2245 dst.Top = params->origin.Y;
2246 dst.Right = params->origin.X + w - 1;
2247 dst.Bottom = params->origin.Y + h - 1;
2248
2249 if (dst.Left < clip.Left)
2250 {
2251 xsrc += clip.Left - dst.Left;
2252 w -= clip.Left - dst.Left;
2253 dst.Left = clip.Left;
2254 }
2255 if (dst.Top < clip.Top)
2256 {
2257 ysrc += clip.Top - dst.Top;
2258 h -= clip.Top - dst.Top;
2259 dst.Top = clip.Top;
2260 }
2261 if (dst.Right > clip.Right) w -= dst.Right - clip.Right;
2262 if (dst.Bottom > clip.Bottom) h -= dst.Bottom - clip.Bottom;
2263
2264 if (w > 0 && h > 0)
2265 {
2266 if (ysrc < dst.Top)
2267 {
2268 psrc = &screen_buffer->data[(ysrc + h - 1) * screen_buffer->width + xsrc];
2269 pdst = &screen_buffer->data[(dst.Top + h - 1) * screen_buffer->width + dst.Left];
2270
2271 for (y = h; y > 0; y--)
2272 {
2273 memcpy( pdst, psrc, w * sizeof(*pdst) );
2274 pdst -= screen_buffer->width;
2275 psrc -= screen_buffer->width;
2276 }
2277 }
2278 else
2279 {
2280 psrc = &screen_buffer->data[ysrc * screen_buffer->width + xsrc];
2281 pdst = &screen_buffer->data[dst.Top * screen_buffer->width + dst.Left];
2282
2283 for (y = 0; y < h; y++)
2284 {
2285 /* we use memmove here because when psrc and pdst are the same,
2286 * copies are done on the same row, so the dst and src blocks
2287 * can overlap */
2288 memmove( pdst, psrc, w * sizeof(*pdst) );
2289 pdst += screen_buffer->width;
2290 psrc += screen_buffer->width;
2291 }
2292 }
2293 }
2294
2295 for (y = src.Top; y <= src.Bottom; y++)
2296 {
2297 int left = src.Left;
2298 int right = src.Right;
2299 if (dst.Top <= y && y <= dst.Bottom)
2300 {
2301 if (dst.Left <= src.Left) left = max( left, dst.Right + 1 );
2302 if (dst.Left >= src.Left) right = min( right, dst.Left - 1 );
2303 }
2304 for (x = left; x <= right; x++) screen_buffer->data[y * screen_buffer->width + x] = params->fill;
2305 }
2306
2307 SetRect( &update_rect, min( src.Left, dst.Left ), min( src.Top, dst.Top ),
2308 max( src.Right, dst.Right ), max( src.Bottom, dst.Bottom ));
2309 update_output( screen_buffer, &update_rect );
2310 tty_sync( screen_buffer->console );
2311 return STATUS_SUCCESS;
2312 }
2313
2314 static NTSTATUS set_console_title( struct console *console, const WCHAR *in_title, size_t size )
2315 {
2316 WCHAR *title = NULL;
2317
2318 TRACE( "%s\n", debugstr_wn(in_title, size / sizeof(WCHAR)) );
2319
2320 if (size)
2321 {
2322 if (!(title = malloc( size + sizeof(WCHAR) ))) return STATUS_NO_MEMORY;
2323 memcpy( title, in_title, size );
2324 title[size / sizeof(WCHAR)] = 0;
2325 }
2326 free( console->title );
2327 console->title = title;
2328
2329 if (console->tty_output)
2330 {
2331 size_t len;
2332 char *vt;
2333
2334 tty_write( console, "\x1b]0;", 4 );
2335 len = WideCharToMultiByte( get_tty_cp( console ), 0, console->title, size / sizeof(WCHAR),
2336 NULL, 0, NULL, NULL);
2337 if ((vt = tty_alloc_buffer( console, len )))
2338 WideCharToMultiByte( get_tty_cp( console ), 0, console->title, size / sizeof(WCHAR),
2339 vt, len, NULL, NULL );
2340 tty_write( console, "\x07", 1 );
2341 tty_sync( console );
2342 }
2343 if (console->win)
2344 SetWindowTextW( console->win, console->title );
2345 return STATUS_SUCCESS;
2346 }
2347
2348 static NTSTATUS screen_buffer_ioctl( struct screen_buffer *screen_buffer, unsigned int code,
2349 const void *in_data, size_t in_size, size_t *out_size )
2350 {
2351 switch (code)
2352 {
2353 case IOCTL_CONDRV_CLOSE_OUTPUT:
2354 if (in_size || *out_size) return STATUS_INVALID_PARAMETER;
2355 destroy_screen_buffer( screen_buffer );
2356 return STATUS_SUCCESS;
2357
2358 case IOCTL_CONDRV_ACTIVATE:
2359 if (in_size || *out_size) return STATUS_INVALID_PARAMETER;
2360 return screen_buffer_activate( screen_buffer );
2361
2362 case IOCTL_CONDRV_GET_MODE:
2363 {
2364 DWORD *mode;
2365 TRACE( "returning mode %x\n", screen_buffer->mode );
2366 if (in_size || *out_size != sizeof(*mode)) return STATUS_INVALID_PARAMETER;
2367 if (!(mode = alloc_ioctl_buffer( *out_size ))) return STATUS_NO_MEMORY;
2368 *mode = screen_buffer->mode;
2369 return STATUS_SUCCESS;
2370 }
2371
2372 case IOCTL_CONDRV_SET_MODE:
2373 if (in_size != sizeof(unsigned int) || *out_size) return STATUS_INVALID_PARAMETER;
2374 screen_buffer->mode = *(unsigned int *)in_data;
2375 TRACE( "set %x mode\n", screen_buffer->mode );
2376 return STATUS_SUCCESS;
2377
2378 case IOCTL_CONDRV_IS_UNIX:
2379 return screen_buffer->console->is_unix ? STATUS_SUCCESS : STATUS_NOT_SUPPORTED;
2380
2381 case IOCTL_CONDRV_WRITE_CONSOLE:
2382 if (in_size % sizeof(WCHAR) || *out_size) return STATUS_INVALID_PARAMETER;
2383 return write_console( screen_buffer, in_data, in_size / sizeof(WCHAR) );
2384
2385 case IOCTL_CONDRV_WRITE_FILE:
2386 {
2387 unsigned int len;
2388 WCHAR *buf;
2389 NTSTATUS status;
2390
2391 len = MultiByteToWideChar( screen_buffer->console->output_cp, 0, in_data, in_size,
2392 NULL, 0 );
2393 if (!len) return STATUS_SUCCESS;
2394 if (!(buf = malloc( len * sizeof(WCHAR) ))) return STATUS_NO_MEMORY;
2395 MultiByteToWideChar( screen_buffer->console->output_cp, 0, in_data, in_size, buf, len );
2396 status = write_console( screen_buffer, buf, len );
2397 free( buf );
2398 return status;
2399 }
2400
2401 case IOCTL_CONDRV_WRITE_OUTPUT:
2402 if ((*out_size != sizeof(DWORD) && *out_size != sizeof(SMALL_RECT)) ||
2403 in_size < sizeof(struct condrv_output_params))
2404 return STATUS_INVALID_PARAMETER;
2405 return write_output( screen_buffer, in_data, in_size, out_size );
2406
2407 case IOCTL_CONDRV_READ_OUTPUT:
2408 if (in_size != sizeof(struct condrv_output_params)) return STATUS_INVALID_PARAMETER;
2409 return read_output( screen_buffer, in_data, out_size );
2410
2411 case IOCTL_CONDRV_GET_OUTPUT_INFO:
2412 if (in_size || *out_size < sizeof(struct condrv_output_info)) return STATUS_INVALID_PARAMETER;
2413 return get_output_info( screen_buffer, out_size );
2414
2415 case IOCTL_CONDRV_SET_OUTPUT_INFO:
2416 if (in_size < sizeof(struct condrv_output_info) || *out_size) return STATUS_INVALID_PARAMETER;
2417 return set_output_info( screen_buffer, in_data, in_size );
2418
2419 case IOCTL_CONDRV_FILL_OUTPUT:
2420 if (in_size != sizeof(struct condrv_fill_output_params) || *out_size != sizeof(DWORD))
2421 return STATUS_INVALID_PARAMETER;
2422 return fill_output( screen_buffer, in_data );
2423
2424 case IOCTL_CONDRV_SCROLL:
2425 if (in_size != sizeof(struct condrv_scroll_params) || *out_size)
2426 return STATUS_INVALID_PARAMETER;
2427 return scroll_output( screen_buffer, in_data );
2428
2429 default:
2430 WARN( "invalid ioctl %x\n", code );
2431 return STATUS_INVALID_HANDLE;
2432 }
2433 }
2434
2435 static NTSTATUS console_input_ioctl( struct console *console, unsigned int code, const void *in_data,
2436 size_t in_size, size_t *out_size )
2437 {
2438 NTSTATUS status;
2439
2440 switch (code)
2441 {
2442 case IOCTL_CONDRV_GET_MODE:
2443 {
2444 DWORD *mode;
2445 TRACE( "returning mode %x\n", console->mode );
2446 if (in_size || *out_size != sizeof(*mode)) return STATUS_INVALID_PARAMETER;
2447 if (!(mode = alloc_ioctl_buffer( *out_size ))) return STATUS_NO_MEMORY;
2448 *mode = console->mode;
2449 return STATUS_SUCCESS;
2450 }
2451
2452 case IOCTL_CONDRV_SET_MODE:
2453 if (in_size != sizeof(unsigned int) || *out_size) return STATUS_INVALID_PARAMETER;
2454 console->mode = *(unsigned int *)in_data;
2455 TRACE( "set %x mode\n", console->mode );
2456 return STATUS_SUCCESS;
2457
2458 case IOCTL_CONDRV_IS_UNIX:
2459 return console->is_unix ? STATUS_SUCCESS : STATUS_NOT_SUPPORTED;
2460
2461 case IOCTL_CONDRV_READ_CONSOLE:
2462 if (in_size || *out_size % sizeof(WCHAR)) return STATUS_INVALID_PARAMETER;
2463 ensure_tty_input_thread( console );
2464 status = read_console( console, code, *out_size );
2465 *out_size = 0;
2466 return status;
2467
2468 case IOCTL_CONDRV_READ_FILE:
2469 ensure_tty_input_thread( console );
2470 status = read_console( console, code, *out_size );
2471 *out_size = 0;
2472 return status;
2473
2474 case IOCTL_CONDRV_READ_INPUT:
2475 {
2476 if (in_size) return STATUS_INVALID_PARAMETER;
2477 ensure_tty_input_thread( console );
2478 if (!console->record_count && *out_size)
2479 {
2480 TRACE( "pending read\n" );
2481 console->read_ioctl = IOCTL_CONDRV_READ_INPUT;
2482 console->pending_read = *out_size;
2483 return STATUS_PENDING;
2484 }
2485 status = read_console_input( console, *out_size );
2486 *out_size = 0;
2487 return status;
2488 }
2489
2490 case IOCTL_CONDRV_WRITE_INPUT:
2491 if (in_size % sizeof(INPUT_RECORD) || *out_size) return STATUS_INVALID_PARAMETER;
2492 return write_console_input( console, in_data, in_size / sizeof(INPUT_RECORD), TRUE );
2493
2494 case IOCTL_CONDRV_PEEK:
2495 {
2496 void *result;
2497 TRACE( "peek\n" );
2498 if (in_size) return STATUS_INVALID_PARAMETER;
2499 ensure_tty_input_thread( console );
2500 *out_size = min( *out_size, console->record_count * sizeof(INPUT_RECORD) );
2501 if (!(result = alloc_ioctl_buffer( *out_size ))) return STATUS_NO_MEMORY;
2502 if (*out_size) memcpy( result, console->records, *out_size );
2503 return STATUS_SUCCESS;
2504 }
2505
2506 case IOCTL_CONDRV_GET_INPUT_INFO:
2507 {
2508 struct condrv_input_info *info;
2509 TRACE( "get info\n" );
2510 if (in_size || *out_size != sizeof(*info)) return STATUS_INVALID_PARAMETER;
2511 if (!(info = alloc_ioctl_buffer( sizeof(*info )))) return STATUS_NO_MEMORY;
2512 info->input_cp = console->input_cp;
2513 info->output_cp = console->output_cp;
2514 info->win = condrv_handle( console->win );
2515 info->input_count = console->record_count;
2516 return STATUS_SUCCESS;
2517 }
2518
2519 case IOCTL_CONDRV_SET_INPUT_INFO:
2520 {
2521 const struct condrv_input_info_params *params = in_data;
2522 TRACE( "set info\n" );
2523 if (in_size != sizeof(*params) || *out_size) return STATUS_INVALID_PARAMETER;
2524 if (params->mask & SET_CONSOLE_INPUT_INFO_INPUT_CODEPAGE)
2525 {
2526 if (!IsValidCodePage( params->info.input_cp )) return STATUS_INVALID_PARAMETER;
2527 console->input_cp = params->info.input_cp;
2528 }
2529 if (params->mask & SET_CONSOLE_INPUT_INFO_OUTPUT_CODEPAGE)
2530 {
2531 if (!IsValidCodePage( params->info.output_cp )) return STATUS_INVALID_PARAMETER;
2532 console->output_cp = params->info.output_cp;
2533 }
2534 return STATUS_SUCCESS;
2535 }
2536
2537 case IOCTL_CONDRV_GET_TITLE:
2538 {
2539 WCHAR *result;
2540 if (in_size) return STATUS_INVALID_PARAMETER;
2541 TRACE( "returning title %s\n", debugstr_w(console->title) );
2542 *out_size = min( *out_size, console->title ? wcslen( console->title ) * sizeof(WCHAR) : 0 );
2543 if (!(result = alloc_ioctl_buffer( *out_size ))) return STATUS_NO_MEMORY;
2544 if (*out_size) memcpy( result, console->title, *out_size );
2545 return STATUS_SUCCESS;
2546 }
2547
2548 case IOCTL_CONDRV_SET_TITLE:
2549 if (in_size % sizeof(WCHAR) || *out_size) return STATUS_INVALID_PARAMETER;
2550 return set_console_title( console, in_data, in_size );
2551
2552 case IOCTL_CONDRV_BEEP:
2553 if (in_size || *out_size) return STATUS_INVALID_PARAMETER;
2554 if (console->is_unix)
2555 {
2556 tty_write( console, "\a", 1 );
2557 tty_sync( console );
2558 }
2559 return STATUS_SUCCESS;
2560
2561 case IOCTL_CONDRV_FLUSH:
2562 if (in_size || *out_size) return STATUS_INVALID_PARAMETER;
2563 TRACE( "flush\n" );
2564 console->record_count = 0;
2565 return STATUS_SUCCESS;
2566
2567 default:
2568 FIXME( "unsupported ioctl %x\n", code );
2569 return STATUS_NOT_SUPPORTED;
2570 }
2571 }
2572
2573 static NTSTATUS process_console_ioctls( struct console *console )
2574 {
2575 size_t out_size = 0, in_size;
2576 unsigned int code;
2577 int output;
2578 NTSTATUS status = STATUS_SUCCESS;
2579
2580 for (;;)
2581 {
2582 if (status) out_size = 0;
2583
2584 console->signaled = console->record_count != 0;
2585 SERVER_START_REQ( get_next_console_request )
2586 {
2587 req->handle = wine_server_obj_handle( console->server );
2588 req->status = status;
2589 req->signal = console->signaled;
2590 wine_server_add_data( req, ioctl_buffer, out_size );
2591 wine_server_set_reply( req, ioctl_buffer, ioctl_buffer_size );
2592 status = wine_server_call( req );
2593 code = reply->code;
2594 output = reply->output;
2595 out_size = reply->out_size;
2596 in_size = wine_server_reply_size( reply );
2597 }
2598 SERVER_END_REQ;
2599
2600 if (status == STATUS_PENDING) return STATUS_SUCCESS;
2601 if (status == STATUS_BUFFER_OVERFLOW)
2602 {
2603 if (!alloc_ioctl_buffer( out_size )) return STATUS_NO_MEMORY;
2604 status = STATUS_SUCCESS;
2605 continue;
2606 }
2607 if (status)
2608 {
2609 TRACE( "failed to get next request: %#x\n", status );
2610 return status;
2611 }
2612
2613 if (code == IOCTL_CONDRV_INIT_OUTPUT)
2614 {
2615 TRACE( "initializing output %x\n", output );
2616 if (console->active)
2617 create_screen_buffer( console, output, console->active->width, console->active->height );
2618 else
2619 create_screen_buffer( console, output, 80, 150 );
2620 }
2621 else if (!output)
2622 {
2623 status = console_input_ioctl( console, code, ioctl_buffer, in_size, &out_size );
2624 }
2625 else
2626 {
2627 struct wine_rb_entry *entry;
2628 if (!(entry = wine_rb_get( &screen_buffer_map, LongToPtr(output) )))
2629 {
2630 ERR( "invalid screen buffer id %x\n", output );
2631 status = STATUS_INVALID_HANDLE;
2632 }
2633 else
2634 {
2635 status = screen_buffer_ioctl( WINE_RB_ENTRY_VALUE( entry, struct screen_buffer, entry ), code,
2636 ioctl_buffer, in_size, &out_size );
2637 }
2638 }
2639 }
2640 }
2641
2642 static int main_loop( struct console *console, HANDLE signal )
2643 {
2644 HANDLE signal_event = NULL;
2645 HANDLE wait_handles[3];
2646 unsigned int wait_cnt = 0;
2647 unsigned short signal_id;
2648 IO_STATUS_BLOCK signal_io;
2649 NTSTATUS status;
2650 BOOL pump_msgs;
2651 DWORD res;
2652
2653 if (signal)
2654 {
2655 if (!(signal_event = CreateEventW( NULL, TRUE, FALSE, NULL ))) return 1;
2656 status = NtReadFile( signal, signal_event, NULL, NULL, &signal_io, &signal_id,
2657 sizeof(signal_id), NULL, NULL );
2658 if (status && status != STATUS_PENDING) return 1;
2659 }
2660
2661 if (!alloc_ioctl_buffer( 4096 )) return 1;
2662
2663 wait_handles[wait_cnt++] = console->server;
2664 if (signal) wait_handles[wait_cnt++] = signal_event;
2665 if (console->input_thread) wait_handles[wait_cnt++] = console->input_thread;
2666 pump_msgs = console->win != NULL;
2667
2668 for (;;)
2669 {
2670 if (pump_msgs)
2671 res = MsgWaitForMultipleObjects( wait_cnt, wait_handles, FALSE, INFINITE, QS_ALLINPUT );
2672 else
2673 res = WaitForMultipleObjects( wait_cnt, wait_handles, FALSE, INFINITE );
2674
2675 if (res == WAIT_OBJECT_0 + wait_cnt)
2676 {
2677 MSG msg;
2678 while (PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ))
2679 {
2680 if (msg.message == WM_QUIT) return 0;
2681 DispatchMessageW(&msg);
2682 }
2683 continue;
2684 }
2685
2686 switch (res)
2687 {
2688 case WAIT_OBJECT_0:
2689 EnterCriticalSection( &console_section );
2690 status = process_console_ioctls( console );
2691 LeaveCriticalSection( &console_section );
2692 if (status) return 0;
2693 break;
2694
2695 case WAIT_OBJECT_0 + 1:
2696 if (signal_io.Status || signal_io.Information != sizeof(signal_id))
2697 {
2698 TRACE( "signaled quit\n" );
2699 return 0;
2700 }
2701 FIXME( "unimplemented signal %x\n", signal_id );
2702 status = NtReadFile( signal, signal_event, NULL, NULL, &signal_io, &signal_id,
2703 sizeof(signal_id), NULL, NULL );
2704 if (status && status != STATUS_PENDING) return 1;
2705 break;
2706
2707 default:
2708 TRACE( "wait failed, quit\n");
2709 return 0;
2710 }
2711 }
2712
2713 return 0;
2714 }
2715
2716 static LONG WINAPI handle_ctrl_c( EXCEPTION_POINTERS *eptr )
2717 {
2718 if (eptr->ExceptionRecord->ExceptionCode != CONTROL_C_EXIT) return EXCEPTION_CONTINUE_SEARCH;
2719 /* In Unix mode, ignore ctrl c exceptions. Signals are sent it to clients as well and we will
2720 * terminate the usual way if they don't handle it. */
2721 return EXCEPTION_CONTINUE_EXECUTION;
2722 }
2723
2724 int __cdecl wmain(int argc, WCHAR *argv[])
2725 {
2726 int headless = 0, i, width = 0, height = 0;
2727 HANDLE signal = NULL;
2728 WCHAR *end;
2729
2730 static struct console console;
2731
2732 for (i = 0; i < argc; i++) TRACE("%s ", wine_dbgstr_w(argv[i]));
2733 TRACE("\n");
2734
2735 console.mode = ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT |
2736 ENABLE_ECHO_INPUT | ENABLE_MOUSE_INPUT | ENABLE_INSERT_MODE |
2737 ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS | ENABLE_AUTO_POSITION;
2738 console.input_cp = console.output_cp = GetOEMCP();
2739 console.history_size = 50;
2740 if (!(console.history = calloc( console.history_size, sizeof(*console.history) ))) return 1;
2741
2742 for (i = 1; i < argc; i++)
2743 {
2744 if (!wcscmp( argv[i], L"--headless"))
2745 {
2746 headless = 1;
2747 continue;
2748 }
2749 if (!wcscmp( argv[i], L"--unix"))
2750 {
2751 console.is_unix = 1;
2752 headless = 1;
2753 continue;
2754 }
2755 if (!wcscmp( argv[i], L"--width" ))
2756 {
2757 if (++i == argc) return 1;
2758 width = wcstol( argv[i], &end, 0 );
2759 if ((!width && !console.is_unix) || width > 0xffff || *end) return 1;
2760 continue;
2761 }
2762 if (!wcscmp( argv[i], L"--height" ))
2763 {
2764 if (++i == argc) return 1;
2765 height = wcstol( argv[i], &end, 0 );
2766 if ((!height && !console.is_unix) || height > 0xffff || *end) return 1;
2767 continue;
2768 }
2769 if (!wcscmp( argv[i], L"--signal" ))
2770 {
2771 if (++i == argc) return 1;
2772 signal = ULongToHandle( wcstol( argv[i], &end, 0 ));
2773 if (*end) return 1;
2774 continue;
2775 }
2776 if (!wcscmp( argv[i], L"--server" ))
2777 {
2778 if (++i == argc) return 1;
2779 console.server = ULongToHandle( wcstol( argv[i], &end, 0 ));
2780 if (*end) return 1;
2781 continue;
2782 }
2783 FIXME( "unknown option %s\n", debugstr_w(argv[i]) );
2784 return 1;
2785 }
2786
2787 if (!console.server)
2788 {
2789 ERR( "no server handle\n" );
2790 return 1;
2791 }
2792
2793 if (!width) width = 80;
2794 if (!height) height = 150;
2795
2796 if (!(console.active = create_screen_buffer( &console, 1, width, height ))) return 1;
2797 if (headless)
2798 {
2799 console.tty_input = GetStdHandle( STD_INPUT_HANDLE );
2800 console.tty_output = GetStdHandle( STD_OUTPUT_HANDLE );
2801 init_tty_output( &console );
2802 if (!console.is_unix && !ensure_tty_input_thread( &console )) return 1;
2803 }
2804 else
2805 {
2806 STARTUPINFOW si;
2807 if (!init_window( &console )) return 1;
2808 GetStartupInfoW( &si );
2809 set_console_title( &console, si.lpTitle, wcslen( si.lpTitle ) * sizeof(WCHAR) );
2810 ShowWindow( console.win, (si.dwFlags & STARTF_USESHOWWINDOW) ? si.wShowWindow : SW_SHOW );
2811 }
2812
2813 if (console.is_unix) RtlAddVectoredExceptionHandler( FALSE, handle_ctrl_c );
2814
2815 return main_loop( &console, signal );
2816 }
Windows API implementation