Refactor in progress for more modular terminal

terminal.cpp

@@ -10,7 +10,7 @@
 using namespace Terminal;
 
 Emulator::Emulator( size_t s_width, size_t s_height )
-  : parser(), fb( s_height, s_width ), as(), terminal_to_host()
+  : parser(), fb( s_width, s_height ), as(), terminal_to_host()
 {}
 
 std::string Emulator::input( char c, int actfd )
@@ -45,22 +45,22 @@ void Emulator::execute( Parser::Execute *act )
 
   switch ( act->ch ) {
   case 0x0a: /* LF */
-    cursor_row++;
-    autoscroll();
-    newgrapheme();
+    fb.cursor_row++;
+    fb.autoscroll();
+    fb.newgrapheme();
     act->handled = true;
     break;
 
   case 0x0d: /* CR */
-    cursor_col = 0;
-    newgrapheme();
+    fb.cursor_col = 0;
+    fb.newgrapheme();
     act->handled = true;
     break;
     
   case 0x08: /* BS */
-    if ( cursor_col > 0 ) {
-      cursor_col--;
-      newgrapheme(); /* this is not xterm's behavior */
+    if ( fb.cursor_col > 0 ) {
+      fb.cursor_col--;
+      fb.newgrapheme(); /* this is not xterm's behavior */
       act->handled = true;
     }
     break;
@@ -71,14 +71,14 @@ void Emulator::print( Parser::Print *act )
 {
   assert( act->char_present );
 
-  if ( (width == 0) || (height == 0) ) {
+  if ( (fb.width == 0) || (fb.height == 0) ) {
     return;
   }
 
-  assert( cursor_row < height ); /* must be on screen */
-  assert( cursor_col <= width + 1 ); /* two off is ok */
-  assert( combining_char_row < height );
-  assert( combining_char_col < width );
+  assert( fb.cursor_row < fb.height ); /* must be on screen */
+  assert( fb.cursor_col <= fb.width + 1 ); /* two off is ok */
+  assert( fb.combining_char_row < fb.height );
+  assert( fb.combining_char_col < fb.width );
 
   int chwidth = act->ch == L'\0' ? -1 : wcwidth( act->ch );
 
@@ -87,40 +87,40 @@ void Emulator::print( Parser::Print *act )
   switch ( chwidth ) {
   case 1: /* normal character */
   case 2: /* wide character */
-    if ( cursor_col >= width ) { /* wrap */
-      cursor_col = 0;
-      cursor_row++;
+    if ( fb.cursor_col >= fb.width ) { /* wrap */
+      fb.cursor_col = 0;
+      fb.cursor_row++;
     }
 
-    autoscroll();
-    newgrapheme();
+    fb.autoscroll();
+    fb.newgrapheme();
 
-    this_cell = &rows[ cursor_row ].cells[ cursor_col ];
+    this_cell = &fb.rows[ fb.cursor_row ].cells[ fb.cursor_col ];
     this_cell->reset();
     this_cell->contents.push_back( act->ch );
 
-    if ( (cursor_col < width - 1) && (chwidth == 2) ) {
-      Cell *next_cell = &rows[ cursor_row ].cells[ cursor_col + 1 ];
+    if ( (fb.cursor_col < fb.width - 1) && (chwidth == 2) ) {
+      Cell *next_cell = &fb.rows[ fb.cursor_row ].cells[ fb.cursor_col + 1 ];
       this_cell->overlapped_cells.push_back( next_cell );
       next_cell->overlapping_cell = this_cell;
     }
 
-    cursor_col += chwidth;
+    fb.cursor_col += chwidth;
     act->handled = true;
     break;
   case 0: /* combining character */
-    if ( rows[ combining_char_row ].cells[ combining_char_col ].contents.size() == 0 ) {
+    if ( fb.rows[ fb.combining_char_row ].cells[ fb.combining_char_col ].contents.size() == 0 ) {
       /* cell starts with combining character */
-      rows[ combining_char_row ].cells[ combining_char_col ].fallback = true;
-      assert( cursor_col == combining_char_col );
-      assert( cursor_row == combining_char_row );
-      assert( cursor_col < width );
-      cursor_col++;
+      fb.rows[ fb.combining_char_row ].cells[ fb.combining_char_col ].fallback = true;
+      assert( fb.cursor_col == fb.combining_char_col );
+      assert( fb.cursor_row == fb.combining_char_row );
+      assert( fb.cursor_col < fb.width );
+      fb.cursor_col++;
       /* a combining character should never be able to wrap us */
     }
 
-    if ( rows[ combining_char_row ].cells[ combining_char_col ].contents.size() < 16 ) { /* seems like a reasonable limit on combining character */
-      rows[ combining_char_row ].cells[ combining_char_col ].contents.push_back( act->ch );
+    if ( fb.rows[ fb.combining_char_row ].cells[ fb.combining_char_col ].contents.size() < 16 ) { /* seems like a reasonable limit on combining character */
+      fb.rows[ fb.combining_char_row ].cells[ fb.combining_char_col ].contents.push_back( act->ch );
     }
     act->handled = true;
     break;
@@ -136,12 +136,12 @@ void Emulator::debug_printout( int fd )
   std::string screen;
   screen.append( "\033[H\033[2J" );
 
-  for ( int y = 0; y < height; y++ ) {
-    for ( int x = 0; x < width; x++ ) {
+  for ( int y = 0; y < fb.height; y++ ) {
+    for ( int x = 0; x < fb.width; x++ ) {
       char curmove[ 32 ];
       snprintf( curmove, 32, "\033[%d;%dH", y + 1, x + 1 );
       screen.append( curmove );
-      Cell *cell = &rows[ y ].cells[ x ];
+      Cell *cell = &fb.rows[ y ].cells[ x ];
       if ( cell->overlapping_cell ) continue;
 
       if ( cell->fallback ) {
@@ -161,7 +161,7 @@ void Emulator::debug_printout( int fd )
   }
 
   char curmove[ 32 ];
-  snprintf( curmove, 32, "\033[%d;%dH", cursor_row + 1, cursor_col + 1 );
+  snprintf( curmove, 32, "\033[%d;%dH", fb.cursor_row + 1, fb.cursor_col + 1 );
   screen.append( curmove );
 
   swrite( fd, screen.c_str() );
@@ -174,7 +174,9 @@ void Emulator::CSI_dispatch( Parser::CSI_Dispatch *act )
   Parser::Collect act2;
   act2.char_present = true;
   act2.ch = act->ch;
-  collect( &act2 ); 
+  as.collect( &act2 ); 
+
+  std::string dispatch_chars = as.dispatch_chars;
 
   if ( dispatch_chars == "K" ) {
     CSI_EL();
@@ -203,9 +205,9 @@ void Emulator::Esc_dispatch( Parser::Esc_Dispatch *act )
   Parser::Collect act2;
   act2.char_present = true;
   act2.ch = act->ch;
-  collect( &act2 ); 
+  as.collect( &act2 ); 
   
-  if ( dispatch_chars == "#8" ) {
+  if ( as.dispatch_chars == "#8" ) {
     Esc_DECALN();
     act->handled = true;
   }