xref: /haiku/src/tests/apps/miniterminal/Console.cpp (revision e81a954787e50e56a7f06f72705b7859b6ab06d1) 
1 /*
2  * Console.cpp - Mimicing the console driver
3  * Based on the console driver.
4  *
5  * Copyright 2005 Michael Lotz. All rights reserved.
6  * Distributed under the Haiku License.
7  *
8  * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
9  * Distributed under the terms of the MIT License.
10  *
11  * Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
12  * Distributed under the terms of the NewOS License.
13  */
14 
15 #include "Console.h"
16 #include "ViewBuffer.h"
17 #include <stdio.h>
18 
19 Console::Console(ViewBuffer *output)
20 	:	fState(CONSOLE_STATE_NORMAL),
21 		fOutput(output)
22 {
23 	fOutput->GetSize(&fColumns, &fLines);
24 	fOutput->SetResizeCallback(&ResizeCallback, this);
25 	ResetConsole();
26 	GotoXY(0, 0);
27 	SaveCursor(true);
28 	fOutput->Clear(0x0f);
29 }
30 
31 
32 Console::~Console()
33 {
34 }
35 
36 
37 void
38 Console::ResetConsole()
39 {
40 	fAttr = 0x0f;
41 	fScrollTop = 0;
42 	fScrollBottom = fLines - 1;
43 	fBrightAttr = true;
44 	fReverseAttr = false;
45 }
46 
47 
48 void
49 Console::ResizeCallback(int32 width, int32 height, void *data)
50 {
51 	Console *console = (Console *)data;
52 
53 	console->fColumns = width;
54 	console->fLines = height;
55 	console->SetScrollRegion(console->fScrollTop, height - 1);
56 }
57 
58 
59 void
60 Console::SetScrollRegion(int top, int bottom)
61 {
62 	if (top < 0)
63 		top = 0;
64 	if (bottom >= fLines)
65 		bottom = fLines - 1;
66 	if (top > bottom)
67 		return;
68 
69 	fScrollTop = top;
70 	fScrollBottom = bottom;
71 }
72 
73 
74 void
75 Console::ScrollUp()
76 {
77 	// see if cursor is outside of scroll region
78 	if (fY < fScrollTop || fY > fScrollBottom)
79 		return;
80 
81 	if (fY - fScrollTop > 1) {
82 		// move the screen up one
83 		fOutput->Blit(0, fScrollTop + 1, fColumns, fY - fScrollTop, 0, fScrollTop);
84 	}
85 
86 	// clear the bottom line
87 	fOutput->FillGlyph(0, fY, fColumns, 1, ' ', fAttr);
88 }
89 
90 
91 void
92 Console::ScrollDown()
93 {
94 	// see if cursor is outside of scroll region
95 	if (fY < fScrollTop || fY > fScrollBottom)
96 		return;
97 
98 	if (fScrollBottom - fY > 1) {
99 		// move the screen down one
100 		fOutput->Blit(0, fY, fColumns, fScrollBottom - fY, 0, fY + 1);
101 	}
102 
103 	// clear the top line
104 	fOutput->FillGlyph(0, fY, fColumns, 1, ' ', fAttr);
105 }
106 
107 
108 void
109 Console::LineFeed()
110 {
111 	if (fY == fScrollBottom) {
112  		// we hit the bottom of our scroll region
113  		ScrollUp();
114 	} else if (fY < fScrollBottom) {
115 		fY++;
116 	}
117 }
118 
119 
120 void
121 Console::RLineFeed()
122 {
123 	if (fY == fScrollTop) {
124  		// we hit the top of our scroll region
125  		ScrollDown();
126 	} else if (fY > fScrollTop) {
127 		fY--;
128 	}
129 }
130 
131 
132 void
133 Console::CariageReturn()
134 {
135 	fX = 0;
136 }
137 
138 
139 void
140 Console::Delete()
141 {
142 	if (fX > 0) {
143 		fX--;
144 	} else if (fY > 0) {
145         fY--;
146         fX = fColumns - 1;
147     } else {
148         ScrollDown();
149         fY--;
150         fX = fColumns - 1;
151         return;
152     }
153 
154 	fOutput->PutGlyph(fX, fY, ' ', fAttr);
155 }
156 
157 
158 void
159 Console::Tab()
160 {
161 	fX = (fX + TAB_SIZE) & ~TAB_MASK;
162 	if (fX >= fColumns) {
163 		fX -= fColumns;
164 		LineFeed();
165 	}
166 }
167 
168 
169 void
170 Console::EraseLine(erase_line_mode mode)
171 {
172 	switch (mode) {
173 		case LINE_ERASE_WHOLE:
174 			fOutput->FillGlyph(0, fY, fColumns, 1, ' ', fAttr);
175 			break;
176 		case LINE_ERASE_LEFT:
177 			fOutput->FillGlyph(0, fY, fX + 1, 1, ' ', fAttr);
178 			break;
179 		case LINE_ERASE_RIGHT:
180 			fOutput->FillGlyph(fX, fY, fColumns - fX, 1, ' ', fAttr);
181 			break;
182 		default:
183 			return;
184 	}
185 }
186 
187 
188 void
189 Console::EraseScreen(erase_screen_mode mode)
190 {
191 	switch (mode) {
192 		case SCREEN_ERASE_WHOLE:
193 			fOutput->Clear(fAttr);
194 			break;
195 		case SCREEN_ERASE_UP:
196 			fOutput->FillGlyph(0, 0, fColumns, fY + 1, ' ', fAttr);
197 			break;
198 		case SCREEN_ERASE_DOWN:
199 			fOutput->FillGlyph(fY, 0, fColumns, fLines - fY, ' ', fAttr);
200 			break;
201 		default:
202 			return;
203 	}
204 }
205 
206 
207 void
208 Console::SaveCursor(bool save_attrs)
209 {
210 	fSavedX = fX;
211 	fSavedY = fY;
212 
213 	if (save_attrs)
214 		fSavedAttr = fAttr;
215 }
216 
217 
218 void
219 Console::RestoreCursor(bool restore_attrs)
220 {
221 	fX = fSavedX;
222 	fY = fSavedY;
223 
224 	if (restore_attrs)
225 		fAttr = fSavedAttr;
226 }
227 
228 
229 void
230 Console::UpdateCursor(int x, int y)
231 {
232 	fOutput->MoveCursor(x, y);
233 }
234 
235 
236 void
237 Console::GotoXY(int new_x, int new_y)
238 {
239 	if (new_x >= fColumns)
240 		new_x = fColumns - 1;
241 	if (new_x < 0)
242 		new_x = 0;
243 	if (new_y >= fLines)
244 		new_y = fLines - 1;
245 	if (new_y < 0)
246 		new_y = 0;
247 
248 	fX = new_x;
249 	fY = new_y;
250 }
251 
252 
253 void
254 Console::PutChar(const char c)
255 {
256 	fOutput->PutGlyph(fX, fY, c, fAttr);
257 	if (++fX >= fColumns) {
258 		CariageReturn();
259 		LineFeed();
260 	}
261 }
262 
263 
264 void
265 Console::SetVT100Attributes(int32 *args, int32 argCount)
266 {
267 	if (argCount == 0) {
268 		// that's the default (attributes off)
269 		argCount++;
270 		args[0] = 0;
271 	}
272 
273 	for (int32 i = 0; i < argCount; i++) {
274 		switch (args[i]) {
275 			case 0: // reset
276 				fAttr = 0x0f;
277 				fBrightAttr = true;
278 				fReverseAttr = false;
279 				break;
280 			case 1: // bright
281 				fBrightAttr = true;
282 				fAttr |= 0x08; // set the bright bit
283 				break;
284 			case 2: // dim
285 				fBrightAttr = false;
286 				fAttr &= ~0x08; // unset the bright bit
287 				break;
288 			case 4: // underscore we can't do
289 				break;
290 			case 5: // blink
291 				fAttr |= 0x80; // set the blink bit
292 				break;
293 			case 7: // reverse
294 				fReverseAttr = true;
295 				fAttr = ((fAttr & BMASK) >> 4) | ((fAttr & FMASK) << 4);
296 				if (fBrightAttr)
297 					fAttr |= 0x08;
298 				break;
299 			case 8: // hidden?
300 				break;
301 
302 			/* foreground colors */
303 			case 30: fAttr = (fAttr & ~FMASK) | 0 | (fBrightAttr ? 0x08 : 0); break; // black
304 			case 31: fAttr = (fAttr & ~FMASK) | 4 | (fBrightAttr ? 0x08 : 0); break; // red
305 			case 32: fAttr = (fAttr & ~FMASK) | 2 | (fBrightAttr ? 0x08 : 0); break; // green
306 			case 33: fAttr = (fAttr & ~FMASK) | 6 | (fBrightAttr ? 0x08 : 0); break; // yellow
307 			case 34: fAttr = (fAttr & ~FMASK) | 1 | (fBrightAttr ? 0x08 : 0); break; // blue
308 			case 35: fAttr = (fAttr & ~FMASK) | 5 | (fBrightAttr ? 0x08 : 0); break; // magenta
309 			case 36: fAttr = (fAttr & ~FMASK) | 3 | (fBrightAttr ? 0x08 : 0); break; // cyan
310 			case 37: fAttr = (fAttr & ~FMASK) | 7 | (fBrightAttr ? 0x08 : 0); break; // white
311 
312 			/* background colors */
313 			case 40: fAttr = (fAttr & ~BMASK) | (0 << 4); break; // black
314 			case 41: fAttr = (fAttr & ~BMASK) | (4 << 4); break; // red
315 			case 42: fAttr = (fAttr & ~BMASK) | (2 << 4); break; // green
316 			case 43: fAttr = (fAttr & ~BMASK) | (6 << 4); break; // yellow
317 			case 44: fAttr = (fAttr & ~BMASK) | (1 << 4); break; // blue
318 			case 45: fAttr = (fAttr & ~BMASK) | (5 << 4); break; // magenta
319 			case 46: fAttr = (fAttr & ~BMASK) | (3 << 4); break; // cyan
320 			case 47: fAttr = (fAttr & ~BMASK) | (7 << 4); break; // white
321 		}
322 	}
323 }
324 
325 
326 bool
327 Console::ProcessVT100Command(const char c, bool seen_bracket, int32 *args, int32 argCount)
328 {
329 	bool ret = true;
330 
331 	if (seen_bracket) {
332 		switch(c) {
333 			case 'H': /* set cursor position */
334 			case 'f': {
335 				int32 row = argCount > 0 ? args[0] : 1;
336 				int32 col = argCount > 1 ? args[1] : 1;
337 				if (row > 0)
338 					row--;
339 				if (col > 0)
340 					col--;
341 				GotoXY(col, row);
342 				break;
343 			}
344 			case 'A': { /* move up */
345 				int32 deltay = argCount > 0 ? -args[0] : -1;
346 				if (deltay == 0)
347 					deltay = -1;
348 				GotoXY(fX, fY + deltay);
349 				break;
350 			}
351 			case 'e':
352 			case 'B': { /* move down */
353 				int32 deltay = argCount > 0 ? args[0] : 1;
354 				if (deltay == 0)
355 					deltay = 1;
356 				GotoXY(fX, fY + deltay);
357 				break;
358 			}
359 			case 'D': { /* move left */
360 				int32 deltax = argCount > 0 ? -args[0] : -1;
361 				if (deltax == 0)
362 					deltax = -1;
363 				GotoXY(fX + deltax, fY);
364 				break;
365 			}
366 			case 'a':
367 			case 'C': { /* move right */
368 				int32 deltax = argCount > 0 ? args[0] : 1;
369 				if (deltax == 0)
370 					deltax = 1;
371 				GotoXY(fX + deltax, fY);
372 				break;
373 			}
374 			case '`':
375 			case 'G': { /* set X position */
376 				int32 newx = argCount > 0 ? args[0] : 1;
377 				if (newx > 0)
378 					newx--;
379 				GotoXY(newx, fY);
380 				break;
381 			}
382 			case 'd': { /* set y position */
383 				int32 newy = argCount > 0 ? args[0] : 1;
384 				if (newy > 0)
385 					newy--;
386 				GotoXY(fX, newy);
387 				break;
388 			}
389 			case 's': /* save current cursor */
390 				SaveCursor(false);
391 				break;
392 			case 'u': /* restore cursor */
393 				RestoreCursor(false);
394 				break;
395 			case 'r': { /* set scroll region */
396 				int32 low = argCount > 0 ? args[0] : 1;
397 				int32 high = argCount > 1 ? args[1] : fLines;
398 				if (low <= high)
399 					SetScrollRegion(low - 1, high - 1);
400 				break;
401 			}
402 			case 'L': { /* scroll virtual down at cursor */
403 				int32 lines = argCount > 0 ? args[0] : 1;
404 				while (lines > 0) {
405 					ScrollDown();
406 					lines--;
407 				}
408 				break;
409 			}
410 			case 'M': { /* scroll virtual up at cursor */
411 				int32 lines = argCount > 0 ? args[0] : 1;
412 				while (lines > 0) {
413 					ScrollUp();
414 					lines--;
415 				}
416 				break;
417 			}
418 			case 'K':
419 				if (argCount == 0 || args[0] == 0) {
420 					// erase to end of line
421 					EraseLine(LINE_ERASE_RIGHT);
422 				} else if (argCount > 0) {
423 					if (args[0] == 1)
424 						EraseLine(LINE_ERASE_LEFT);
425 					else if (args[0] == 2)
426 						EraseLine(LINE_ERASE_WHOLE);
427 				}
428 				break;
429 			case 'J':
430 				if (argCount == 0 || args[0] == 0) {
431 					// erase to end of screen
432 					EraseScreen(SCREEN_ERASE_DOWN);
433 				} else if (argCount > 0) {
434 					if (args[0] == 1)
435 						EraseScreen(SCREEN_ERASE_UP);
436 					else if (args[0] == 2)
437 						EraseScreen(SCREEN_ERASE_WHOLE);
438 				}
439 				break;
440 			case 'm':
441 				if (argCount >= 0)
442 					SetVT100Attributes(args, argCount);
443 				break;
444 			default:
445 				ret = false;
446 		}
447 	} else {
448 		switch (c) {
449 			case 'c':
450 				ResetConsole();
451 				break;
452 			case 'D':
453 				RLineFeed();
454 				break;
455 			case 'M':
456 				LineFeed();
457 				break;
458 			case '7':
459 				SaveCursor(true);
460 				break;
461 			case '8':
462 				RestoreCursor(true);
463 				break;
464 			default:
465 				ret = false;
466 		}
467 	}
468 
469 	return ret;
470 }
471 
472 
473 void
474 Console::Write(const void *buf, size_t len)
475 {
476 	UpdateCursor(-1, -1); // hide the cursor
477 
478 	const char *c;
479 	size_t pos = 0;
480 
481 	while (pos < len) {
482 		c = &((const char *)buf)[pos++];
483 
484 		switch (fState) {
485 			case CONSOLE_STATE_NORMAL:
486 				// just output the stuff
487 				switch (*c) {
488 					case '\n':
489 						LineFeed();
490 						break;
491 					case '\r':
492 						CariageReturn();
493 						break;
494 					case 0x8: // backspace
495 						Delete();
496 						break;
497 					case '\t':
498 						Tab();
499 						break;
500 					case '\a':
501 						// beep
502 						//printf("<BEEP>\n");
503 						break;
504 					case '\0':
505 						break;
506 					case 0x1b:
507 						// escape character
508 						fArgCount = -1;
509 						fState = CONSOLE_STATE_GOT_ESCAPE;
510 						break;
511 					default:
512 						PutChar(*c);
513 				}
514 				break;
515 			case CONSOLE_STATE_GOT_ESCAPE:
516 				// look for either commands with no argument, or the '[' character
517 				switch (*c) {
518 					case '[':
519 						fState = CONSOLE_STATE_SEEN_BRACKET;
520 						break;
521 					default:
522 						fArgs[fArgCount] = 0;
523 						ProcessVT100Command(*c, false, fArgs, fArgCount + 1);
524 						fState = CONSOLE_STATE_NORMAL;
525 				}
526 				break;
527 			case CONSOLE_STATE_SEEN_BRACKET:
528 				switch (*c) {
529 					case '0'...'9':
530 						fArgCount = 0;
531 						fArgs[fArgCount] = *c - '0';
532 						fState = CONSOLE_STATE_PARSING_ARG;
533 						break;
534 					case '?':
535 						// private DEC mode parameter follows - we ignore those anyway
536 						// ToDo: check if it was really used in combination with a mode command
537 						break;
538 					default:
539 						ProcessVT100Command(*c, true, fArgs, fArgCount + 1);
540 						fState = CONSOLE_STATE_NORMAL;
541 				}
542 				break;
543 			case CONSOLE_STATE_NEW_ARG:
544 				switch (*c) {
545 					case '0'...'9':
546 						fArgCount++;
547 						if (fArgCount == MAX_ARGS) {
548 							fState = CONSOLE_STATE_NORMAL;
549 							break;
550 						}
551 						fArgs[fArgCount] = *c - '0';
552 						fState = CONSOLE_STATE_PARSING_ARG;
553 						break;
554 					default:
555 						ProcessVT100Command(*c, true, fArgs, fArgCount + 1);
556 						fState = CONSOLE_STATE_NORMAL;
557 				}
558 				break;
559 			case CONSOLE_STATE_PARSING_ARG:
560 				// parse args
561 				switch (*c) {
562 					case '0'...'9':
563 						fArgs[fArgCount] *= 10;
564 						fArgs[fArgCount] += *c - '0';
565 						break;
566 					case ';':
567 						fState = CONSOLE_STATE_NEW_ARG;
568 						break;
569 					default:
570 						ProcessVT100Command(*c, true, fArgs, fArgCount + 1);
571 						fState = CONSOLE_STATE_NORMAL;
572 				}
573 			}
574 	}
575 
576 	UpdateCursor(fX, fY); // show it again
577 }
578