]> git.proxmox.com Git - spiceterm.git/commitdiff
white space cleanup
authorDietmar Maurer <dietmar@proxmox.com>
Thu, 12 Sep 2013 05:16:03 +0000 (07:16 +0200)
committerDietmar Maurer <dietmar@proxmox.com>
Thu, 12 Sep 2013 05:16:03 +0000 (07:16 +0200)
spiceterm.c

index 6a09e402bc4eb8818f753dc86a46c938ab692784..6b10173b1eeb8636a75a34d15a6d89fa088e1d56 100644 (file)
 
      Author: Dietmar Maurer <dietmar@proxmox.com>
 
-     Note: most of the code here is copied from vncterm (which is 
+     Note: most of the code here is copied from vncterm (which is
      also written by me).
 
 */
 
-#define _GNU_SOURCE  
+#define _GNU_SOURCE
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -56,7 +56,7 @@
 #include "translations.h"
 
 static int debug = 0;
-    
+
 #define DPRINTF(x, format, ...) { \
     if (x <= debug) { \
         printf("%s: " format "\n" , __FUNCTION__, ## __VA_ARGS__); \
@@ -80,10 +80,10 @@ unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
 
 
 static void
-print_usage (const char *msg)
+print_usage(const char *msg)
 {
-  if (msg) { fprintf(stderr, "ERROR: %s\n", msg); }
-  fprintf(stderr, "USAGE: spiceterm [spiceopts] [-c command [args]]\n");
+    if (msg) { fprintf(stderr, "ERROR: %s\n", msg); }
+    fprintf(stderr, "USAGE: spiceterm [spiceopts] [-c command [args]]\n");
 }
 
 /* Convert UCS2 to UTF8 sequence, trailing zero */
@@ -125,88 +125,89 @@ draw_char_at (spiceTerm *vt, int x, int y, gunichar2 ch, TextAttributes attrib)
 static void
 spiceterm_update_xy (spiceTerm *vt, int x, int y)
 {
-  if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
+    if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
 
-  int y1 = (vt->y_base + y) % vt->total_height;
-  int y2 = y1 - vt->y_displ;
-  if (y2 < 0) {
-    y2 += vt->total_height;
-  }
-  if (y2 < vt->height) {
-    TextCell *c = &vt->cells[y1 * vt->width + x];
-    draw_char_at (vt, x, y2, c->ch, c->attrib);
-  }
+    int y1 = (vt->y_base + y) % vt->total_height;
+    int y2 = y1 - vt->y_displ;
+    if (y2 < 0) {
+        y2 += vt->total_height;
+    }
+    if (y2 < vt->height) {
+        TextCell *c = &vt->cells[y1 * vt->width + x];
+        draw_char_at (vt, x, y2, c->ch, c->attrib);
+    }
 }
 
 static void
 spiceterm_clear_xy (spiceTerm *vt, int x, int y)
 {
-  if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
+    if (x < 0 || y < 0 || x >= vt->width || y >= vt->height) { return; }
 
-  int y1 = (vt->y_base + y) % vt->total_height;
-  int y2 = y1 - vt->y_displ;
-  if (y2 < 0) {
-    y2 += vt->total_height;
-  }
-  if (y2 < vt->height) {
-    TextCell *c = &vt->cells[y1 * vt->width + x];
-    c->ch = ' ';
-    c->attrib = vt->default_attrib;
-    c->attrib.fgcol = vt->cur_attrib.fgcol;
-    c->attrib.bgcol = vt->cur_attrib.bgcol;
-
-    draw_char_at (vt, x, y, c->ch, c->attrib);
-  }
+    int y1 = (vt->y_base + y) % vt->total_height;
+    int y2 = y1 - vt->y_displ;
+    if (y2 < 0) {
+        y2 += vt->total_height;
+    }
+    if (y2 < vt->height) {
+        TextCell *c = &vt->cells[y1 * vt->width + x];
+        c->ch = ' ';
+        c->attrib = vt->default_attrib;
+        c->attrib.fgcol = vt->cur_attrib.fgcol;
+        c->attrib.bgcol = vt->cur_attrib.bgcol;
+
+        draw_char_at (vt, x, y, c->ch, c->attrib);
+    }
 }
 
 static void
 spiceterm_show_cursor (spiceTerm *vt, int show)
 {
-  int x = vt->cx;
-  if (x >= vt->width) {
-    x = vt->width - 1;
-  }
+    int x = vt->cx;
+    if (x >= vt->width) {
+        x = vt->width - 1;
+    }
 
-  int y1 = (vt->y_base + vt->cy) % vt->total_height;
-  int y = y1 - vt->y_displ;
-  if (y < 0) {
-    y += vt->total_height;
-  }
+    int y1 = (vt->y_base + vt->cy) % vt->total_height;
+    int y = y1 - vt->y_displ;
+    if (y < 0) {
+        y += vt->total_height;
+    }
 
-  if (y < vt->height) {
+    if (y < vt->height) {
 
-    TextCell *c = &vt->cells[y1 * vt->width + x];
+        TextCell *c = &vt->cells[y1 * vt->width + x];
 
-    if (show) {
-      TextAttributes attrib = vt->default_attrib;
-      attrib.invers = !(attrib.invers); /* invert fg and bg */
-      draw_char_at (vt, x, y, c->ch, attrib);
-    } else {
-      draw_char_at (vt, x, y, c->ch, c->attrib);
+        if (show) {
+            TextAttributes attrib = vt->default_attrib;
+            attrib.invers = !(attrib.invers); /* invert fg and bg */
+            draw_char_at (vt, x, y, c->ch, attrib);
+        } else {
+            draw_char_at (vt, x, y, c->ch, c->attrib);
+        }
     }
-  }
 }
 
 static void
 spiceterm_refresh (spiceTerm *vt)
 {
-  int x, y, y1;
+    int x, y, y1;
 
-  // rfbFillRect (vt->screen, 0, 0, vt->maxx, vt->maxy, vt->default_attrib.bgcol);
+    // fixme?
+    // rfbFillRect (vt->screen, 0, 0, vt->maxx, vt->maxy, vt->default_attrib.bgcol);
 
-  y1 = vt->y_displ;
-  for(y = 0; y < vt->height; y++) {
-    TextCell *c = vt->cells + y1 * vt->width;
-    for(x = 0; x < vt->width; x++) {
-      draw_char_at (vt, x, y, c->ch, c->attrib);
-      c++;
+    y1 = vt->y_displ;
+    for(y = 0; y < vt->height; y++) {
+        TextCell *c = vt->cells + y1 * vt->width;
+        for(x = 0; x < vt->width; x++) {
+            draw_char_at (vt, x, y, c->ch, c->attrib);
+            c++;
+        }
+        if (++y1 == vt->total_height)
+            y1 = 0;
     }
-    if (++y1 == vt->total_height)
-      y1 = 0;
-  }
-  //rfbMarkRectAsModified (vt->screen, 0, 0, vt->maxx, vt->maxy);
+    //rfbMarkRectAsModified (vt->screen, 0, 0, vt->maxx, vt->maxy);
 
-  spiceterm_show_cursor (vt, 1);
+    spiceterm_show_cursor (vt, 1);
 }
 
 static void
@@ -266,7 +267,7 @@ spiceterm_scroll_up (spiceTerm *vt, int top, int bottom, int lines, int moveattr
 
     spice_screen_scroll(vt->screen, 0, y0, vt->screen->primary_width, y2 -h, 0, y1);
     spice_screen_clear(vt->screen, 0, y2 -h, vt->screen->primary_width, y2);
-    
+
     if (!moveattr) {
         return;
     }
@@ -295,321 +296,320 @@ spiceterm_scroll_up (spiceTerm *vt, int top, int bottom, int lines, int moveattr
 static void
 spiceterm_virtual_scroll (spiceTerm *vt, int lines)
 {
-  if (vt->altbuf || lines == 0) return;
-
-  if (lines < 0) {
-    lines = -lines;
-    int i = vt->scroll_height;
-    if (i > vt->total_height - vt->height)
-      i = vt->total_height - vt->height;
-    int y1 = vt->y_base - i;
-    if (y1 < 0)
-      y1 += vt->total_height;
-    for(i = 0; i < lines; i++) {
-      if (vt->y_displ == y1) break;
-      if (--vt->y_displ < 0) {
-       vt->y_displ = vt->total_height - 1;
-      }
-    }
-  } else {
-    int i;
-    for(i = 0; i < lines; i++) {
-      if (vt->y_displ == vt->y_base) break;
-      if (++vt->y_displ == vt->total_height) {
-       vt->y_displ = 0;
-      }
+    if (vt->altbuf || lines == 0) return;
+
+    if (lines < 0) {
+        lines = -lines;
+        int i = vt->scroll_height;
+        if (i > vt->total_height - vt->height)
+            i = vt->total_height - vt->height;
+        int y1 = vt->y_base - i;
+        if (y1 < 0)
+            y1 += vt->total_height;
+        for(i = 0; i < lines; i++) {
+            if (vt->y_displ == y1) break;
+            if (--vt->y_displ < 0) {
+                vt->y_displ = vt->total_height - 1;
+            }
+        }
+    } else {
+        int i;
+        for(i = 0; i < lines; i++) {
+            if (vt->y_displ == vt->y_base) break;
+            if (++vt->y_displ == vt->total_height) {
+                vt->y_displ = 0;
+            }
+        }
     }
 
-  }
-
-  spiceterm_refresh (vt);
+    spiceterm_refresh (vt);
 }
+
 static void
 spiceterm_respond_esc (spiceTerm *vt, const char *esc)
 {
-  int len = strlen (esc);
-  int i;
+    int len = strlen (esc);
+    int i;
 
-  if (vt->ibuf_count < (IBUFSIZE - 1 - len)) {
-    vt->ibuf[vt->ibuf_count++] = 27;
-    for (i = 0; i < len; i++) {
-      vt->ibuf[vt->ibuf_count++] = esc[i];
+    if (vt->ibuf_count < (IBUFSIZE - 1 - len)) {
+        vt->ibuf[vt->ibuf_count++] = 27;
+        for (i = 0; i < len; i++) {
+            vt->ibuf[vt->ibuf_count++] = esc[i];
+        }
     }
-  }
 }
 
 static void
 spiceterm_put_lf (spiceTerm *vt)
 {
-  if (vt->cy + 1 == vt->region_bottom) {
+    if (vt->cy + 1 == vt->region_bottom) {
 
-    if (vt->altbuf || vt->region_top != 0 || vt->region_bottom != vt->height) {
-      spiceterm_scroll_up (vt, vt->region_top, vt->region_bottom, 1, 1);
-      return;
-    }
+        if (vt->altbuf || vt->region_top != 0 || vt->region_bottom != vt->height) {
+            spiceterm_scroll_up (vt, vt->region_top, vt->region_bottom, 1, 1);
+            return;
+        }
 
-    if (vt->y_displ == vt->y_base) {
-      spiceterm_scroll_up (vt, vt->region_top, vt->region_bottom, 1, 0);
-    }
+        if (vt->y_displ == vt->y_base) {
+            spiceterm_scroll_up (vt, vt->region_top, vt->region_bottom, 1, 0);
+        }
 
-    if (vt->y_displ == vt->y_base) {
-      if (++vt->y_displ == vt->total_height) {
-       vt->y_displ = 0;
-      }
-    }
+        if (vt->y_displ == vt->y_base) {
+            if (++vt->y_displ == vt->total_height) {
+                vt->y_displ = 0;
+            }
+        }
 
-    if (++vt->y_base == vt->total_height) {
-      vt->y_base = 0;
-    }
+        if (++vt->y_base == vt->total_height) {
+            vt->y_base = 0;
+        }
 
-    if (vt->scroll_height < vt->total_height) {
-      vt->scroll_height++;
-    }
+        if (vt->scroll_height < vt->total_height) {
+            vt->scroll_height++;
+        }
 
-    int y1 = (vt->y_base + vt->height - 1) % vt->total_height;
-    TextCell *c = &vt->cells[y1 * vt->width];
-    int x;
-    for (x = 0; x < vt->width; x++) {
-      c->ch = ' ';
-      c->attrib = vt->default_attrib;
-      c++;
-    }
+        int y1 = (vt->y_base + vt->height - 1) % vt->total_height;
+        TextCell *c = &vt->cells[y1 * vt->width];
+        int x;
+        for (x = 0; x < vt->width; x++) {
+            c->ch = ' ';
+            c->attrib = vt->default_attrib;
+            c++;
+        }
 
-    // fprintf (stderr, "BASE: %d DISPLAY %d\n", vt->y_base, vt->y_displ);
+        // fprintf (stderr, "BASE: %d DISPLAY %d\n", vt->y_base, vt->y_displ);
 
-  } else if (vt->cy < vt->height - 1) {
-    vt->cy += 1;
-  }
+    } else if (vt->cy < vt->height - 1) {
+        vt->cy += 1;
+    }
 }
 
-
 static void
 spiceterm_csi_m (spiceTerm *vt)
 {
-  int i;
+    int i;
 
-  for (i = 0; i < vt->esc_count; i++) {
-    switch (vt->esc_buf[i]) {
-    case 0: /* reset all console attributes to default */
-      vt->cur_attrib = vt->default_attrib;
-      break;
-    case 1:
-      vt->cur_attrib.bold = 1;
-      break;
-    case 4:
-      vt->cur_attrib.uline = 1;
-      break;
-    case 5:
-      vt->cur_attrib.blink = 1;
-      break;
-    case 7:
-      vt->cur_attrib.invers = 1;
-      break;
-    case 8:
-      vt->cur_attrib.unvisible = 1;
-      break;
-    case 10:
-      vt->cur_enc = LAT1_MAP;
-      // fixme: dispaly controls = 0 ?
-      // fixme: toggle meta = 0 ?
-      break;
-    case 11:
-      vt->cur_enc = IBMPC_MAP;
-      // fixme: dispaly controls = 1 ?
-      // fixme: toggle meta = 0 ?
-      break;
-    case 12:
-      vt->cur_enc = IBMPC_MAP;
-      // fixme: dispaly controls = 1 ?
-      // fixme: toggle meta = 1 ?
-      break;
-    case 22:
-      vt->cur_attrib.bold = 0;
-      break;
-    case 24:
-      vt->cur_attrib.uline = 0;
-      break;
-    case 25:
-      vt->cur_attrib.blink = 0;
-      break;
-    case 27:
-      vt->cur_attrib.invers = 0;
-      break;
-    case 28:
-      vt->cur_attrib.unvisible = 0;
-      break;
-    case 30:
-    case 31:
-    case 32:
-    case 33:
-    case 34:
-    case 35:
-    case 36:
-    case 37:
-      /* set foreground color */
-      vt->cur_attrib.fgcol = color_table [vt->esc_buf[i] - 30];
-      break;
-    case 38:
-      /* reset color to default, enable underline */
-      vt->cur_attrib.fgcol = vt->default_attrib.fgcol;
-      vt->cur_attrib.uline = 1;
-      break;
-    case 39:
-      /* reset color to default, disable underline */
-      vt->cur_attrib.fgcol = vt->default_attrib.fgcol;
-      vt->cur_attrib.uline = 0;
-      break;
-    case 40:
-    case 41:
-    case 42:
-    case 43:
-    case 44:
-    case 45:
-    case 46:
-    case 47:
-      /* set background color */
-      vt->cur_attrib.bgcol = color_table [vt->esc_buf[i] - 40];
-      break;
-    case 49:
-      /* reset background color */
-      vt->cur_attrib.bgcol = vt->default_attrib.bgcol;
-      break;
-    default:
-      fprintf(stderr, "unhandled ESC[%d m code\n",vt->esc_buf[i]);
-      //fixme: implement
-     }
-  }
+    for (i = 0; i < vt->esc_count; i++) {
+        switch (vt->esc_buf[i]) {
+        case 0: /* reset all console attributes to default */
+            vt->cur_attrib = vt->default_attrib;
+            break;
+        case 1:
+            vt->cur_attrib.bold = 1;
+            break;
+        case 4:
+            vt->cur_attrib.uline = 1;
+            break;
+        case 5:
+            vt->cur_attrib.blink = 1;
+            break;
+        case 7:
+            vt->cur_attrib.invers = 1;
+            break;
+        case 8:
+            vt->cur_attrib.unvisible = 1;
+            break;
+        case 10:
+            vt->cur_enc = LAT1_MAP;
+            // fixme: dispaly controls = 0 ?
+            // fixme: toggle meta = 0 ?
+            break;
+        case 11:
+            vt->cur_enc = IBMPC_MAP;
+            // fixme: dispaly controls = 1 ?
+            // fixme: toggle meta = 0 ?
+            break;
+        case 12:
+            vt->cur_enc = IBMPC_MAP;
+            // fixme: dispaly controls = 1 ?
+            // fixme: toggle meta = 1 ?
+            break;
+        case 22:
+            vt->cur_attrib.bold = 0;
+            break;
+        case 24:
+            vt->cur_attrib.uline = 0;
+            break;
+        case 25:
+            vt->cur_attrib.blink = 0;
+            break;
+        case 27:
+            vt->cur_attrib.invers = 0;
+            break;
+        case 28:
+            vt->cur_attrib.unvisible = 0;
+            break;
+        case 30:
+        case 31:
+        case 32:
+        case 33:
+        case 34:
+        case 35:
+        case 36:
+        case 37:
+            /* set foreground color */
+            vt->cur_attrib.fgcol = color_table [vt->esc_buf[i] - 30];
+            break;
+        case 38:
+            /* reset color to default, enable underline */
+            vt->cur_attrib.fgcol = vt->default_attrib.fgcol;
+            vt->cur_attrib.uline = 1;
+            break;
+        case 39:
+            /* reset color to default, disable underline */
+            vt->cur_attrib.fgcol = vt->default_attrib.fgcol;
+            vt->cur_attrib.uline = 0;
+            break;
+        case 40:
+        case 41:
+        case 42:
+        case 43:
+        case 44:
+        case 45:
+        case 46:
+        case 47:
+            /* set background color */
+            vt->cur_attrib.bgcol = color_table [vt->esc_buf[i] - 40];
+            break;
+        case 49:
+            /* reset background color */
+            vt->cur_attrib.bgcol = vt->default_attrib.bgcol;
+            break;
+        default:
+            fprintf(stderr, "unhandled ESC[%d m code\n",vt->esc_buf[i]);
+            //fixme: implement
+        }
+    }
 }
 
 static void
 spiceterm_save_cursor (spiceTerm *vt)
 {
-  vt->cx_saved = vt->cx;
-  vt->cy_saved = vt->cy;
-  vt->cur_attrib_saved = vt->cur_attrib;
-  vt->charset_saved = vt->charset;
-  vt->g0enc_saved = vt->g0enc;
-  vt->g1enc_saved = vt->g1enc;
-  vt->cur_enc_saved = vt->cur_enc;
+    vt->cx_saved = vt->cx;
+    vt->cy_saved = vt->cy;
+    vt->cur_attrib_saved = vt->cur_attrib;
+    vt->charset_saved = vt->charset;
+    vt->g0enc_saved = vt->g0enc;
+    vt->g1enc_saved = vt->g1enc;
+    vt->cur_enc_saved = vt->cur_enc;
 }
 
 static void
 spiceterm_restore_cursor (spiceTerm *vt)
 {
-  vt->cx = vt->cx_saved;
-  vt->cy = vt->cy_saved;
-  vt->cur_attrib = vt->cur_attrib_saved;
-  vt->charset = vt->charset_saved;
-  vt->g0enc = vt->g0enc_saved;
-  vt->g1enc = vt->g1enc_saved;
-  vt->cur_enc = vt->cur_enc_saved;
+    vt->cx = vt->cx_saved;
+    vt->cy = vt->cy_saved;
+    vt->cur_attrib = vt->cur_attrib_saved;
+    vt->charset = vt->charset_saved;
+    vt->g0enc = vt->g0enc_saved;
+    vt->g1enc = vt->g1enc_saved;
+    vt->cur_enc = vt->cur_enc_saved;
 }
 
 static void
 spiceterm_set_alternate_buffer (spiceTerm *vt, int on_off)
 {
-  int x, y;
+    int x, y;
 
-  vt->y_displ = vt->y_base;
+    vt->y_displ = vt->y_base;
 
-  if (on_off) {
+    if (on_off) {
 
-    if (vt->altbuf) return;
+        if (vt->altbuf) return;
 
-    vt->altbuf = 1;
+        vt->altbuf = 1;
 
-    /* alternate buffer & cursor */
-
-    spiceterm_save_cursor (vt);
-    /* save screen to altcels */
-    for (y = 0; y < vt->height; y++) {
-      int y1 = (vt->y_base + y) % vt->total_height;
-      for (x = 0; x < vt->width; x++) {
-       vt->altcells[y*vt->width + x] = vt->cells[y1*vt->width + x];
-      }
-    }
+        /* alternate buffer & cursor */
 
-    /* clear screen */
-    for (y = 0; y <= vt->height; y++) {
-      for (x = 0; x < vt->width; x++) {
-       spiceterm_clear_xy (vt, x, y);
-      }
-    }
+        spiceterm_save_cursor (vt);
+        /* save screen to altcels */
+        for (y = 0; y < vt->height; y++) {
+            int y1 = (vt->y_base + y) % vt->total_height;
+            for (x = 0; x < vt->width; x++) {
+                vt->altcells[y*vt->width + x] = vt->cells[y1*vt->width + x];
+            }
+        }
 
-  } else {
+        /* clear screen */
+        for (y = 0; y <= vt->height; y++) {
+            for (x = 0; x < vt->width; x++) {
+                spiceterm_clear_xy (vt, x, y);
+            }
+        }
+        
+    } else {
+        
+        if (vt->altbuf == 0) return;
 
-    if (vt->altbuf == 0) return;
+        vt->altbuf = 0;
 
-    vt->altbuf = 0;
+        /* restore saved data */
+        for (y = 0; y < vt->height; y++) {
+            int y1 = (vt->y_base + y) % vt->total_height;
+            for (x = 0; x < vt->width; x++) {
+                vt->cells[y1*vt->width + x] = vt->altcells[y*vt->width + x];
+            }
+        }
 
-    /* restore saved data */
-    for (y = 0; y < vt->height; y++) {
-      int y1 = (vt->y_base + y) % vt->total_height;
-      for (x = 0; x < vt->width; x++) {
-       vt->cells[y1*vt->width + x] = vt->altcells[y*vt->width + x];
-      }
+        spiceterm_restore_cursor (vt);
     }
 
-    spiceterm_restore_cursor (vt);
-  }
-
-  spiceterm_refresh (vt);
+    spiceterm_refresh (vt);
 }
 
 static void
 spiceterm_set_mode (spiceTerm *vt, int on_off)
 {
-  int i;
+    int i;
 
-  for (i = 0; i <= vt->esc_count; i++) {
-    if (vt->esc_ques) {          /* DEC private modes set/reset */
-      switch(vt->esc_buf[i]) {
-      case 10:                   /* X11 mouse reporting on/off */
-      case 1000:
-       vt->report_mouse = on_off;
-       break;
-      case 1049:               /* start/end special app mode (smcup/rmcup) */
-       spiceterm_set_alternate_buffer (vt, on_off);
-       break;
-      case 25:                 /* Cursor on/off */
-      case 9:                   /* X10 mouse reporting on/off */
-      case 6:                  /* Origin relative/absolute */
-      case 1:                  /* Cursor keys in appl mode*/
-      case 5:                  /* Inverted screen on/off */
-      case 7:                  /* Autowrap on/off */
-      case 8:                  /* Autorepeat on/off */
-       break;
-      }
-    } else { /* ANSI modes set/reset */
-      /* fixme: implement me */
+    for (i = 0; i <= vt->esc_count; i++) {
+        if (vt->esc_ques) {          /* DEC private modes set/reset */
+            switch(vt->esc_buf[i]) {
+            case 10:                   /* X11 mouse reporting on/off */
+            case 1000:
+                vt->report_mouse = on_off;
+                break;
+            case 1049:         /* start/end special app mode (smcup/rmcup) */
+                spiceterm_set_alternate_buffer (vt, on_off);
+                break;
+            case 25:                   /* Cursor on/off */
+            case 9:                   /* X10 mouse reporting on/off */
+            case 6:                    /* Origin relative/absolute */
+            case 1:                    /* Cursor keys in appl mode*/
+            case 5:                    /* Inverted screen on/off */
+            case 7:                    /* Autowrap on/off */
+            case 8:                    /* Autorepeat on/off */
+                break;
+            }
+        } else { /* ANSI modes set/reset */
+            /* fixme: implement me */
+        }
     }
-  }
 }
 
 static void
 spiceterm_gotoxy (spiceTerm *vt, int x, int y)
 {
-  /* verify all boundaries */
+    /* verify all boundaries */
 
-  if (x < 0) {
-    x = 0;
-  }
+    if (x < 0) {
+        x = 0;
+    }
 
-  if (x >= vt->width) {
-    x = vt->width - 1;
-  }
+    if (x >= vt->width) {
+        x = vt->width - 1;
+    }
 
-  vt->cx = x;
+    vt->cx = x;
 
-  if (y < 0) {
-    y = 0;
-  }
+    if (y < 0) {
+        y = 0;
+    }
 
-  if (y >= vt->height) {
-    y = vt->height - 1;
-  }
+    if (y >= vt->height) {
+        y = vt->height - 1;
+    }
 
-  vt->cy = y;
+    vt->cy = y;
 }
 
 enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
@@ -619,561 +619,563 @@ enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
 static void
 spiceterm_putchar (spiceTerm *vt, gunichar2 ch)
 {
-  int x, y, i, c;
-
-  if (!vt->tty_state) {
-      DPRINTF(1, "%s: CHAR:%2d: %4x '%c' (cur_enc %d) %d %d", __func__,
-              vt->tty_state, ch, ch, vt->cur_enc, vt->cx, vt->cy);
-  }
-
-  switch(vt->tty_state) {
-  case ESesc:
-    vt->tty_state = ESnormal;
-    switch (ch) {
-    case '[':
-      vt->tty_state = ESsquare;
-      break;
-    case ']':
-      vt->tty_state = ESnonstd;
-      break;
-    case '%':
-      vt->tty_state = ESpercent;
-      break;
-    case '7':
-      spiceterm_save_cursor (vt);
-      break;
-    case '8':
-      spiceterm_restore_cursor (vt);
-      break;
-    case '(':
-      vt->tty_state = ESsetG0; // SET G0
-      break;
-    case ')':
-      vt->tty_state = ESsetG1; // SET G1
-      break;
-    case 'M':
-      /* cursor up (ri) */
-      if (vt->cy == vt->region_top)
-       spiceterm_scroll_down (vt, vt->region_top, vt->region_bottom, 1);
-      else if (vt->cy > 0) {
-       vt->cy--;
-      }
-      break;
-    case '>':
-      /* numeric keypad  - ignored */
-      break;
-    case '=':
-      /* appl. keypad - ignored */
-      break;
-    default:
-      DPRINTF(1, "%s: got unhandled ESC%c  %d", __func__, ch, ch);
-      break;
-    }
-    break;
-  case ESnonstd: /* Operating System Controls */
-    vt->tty_state = ESnormal;
-
-    switch (ch) {
-    case 'P':   /* palette escape sequence */
-      for(i = 0; i < MAX_ESC_PARAMS; i++) {
-       vt->esc_buf[i] = 0;
-      }
+    int x, y, i, c;
 
-      vt->esc_count = 0;
-      vt->tty_state = ESpalette;
-      break;
-    case 'R':   /* reset palette */
-      // fixme: reset_palette(vc);
-      break;
-    case '0':
-    case '1':
-    case '2':
-    case '4':
-      vt->osc_cmd = ch;
-      vt->osc_textbuf[0] = 0;
-      vt->tty_state = ESosc1;
-      break;
-    default:
-      DPRINTF(1, "%s: got unhandled OSC %c", __func__, ch);
-      vt->tty_state = ESnormal;
-      break;
-    }
-    break;
-  case ESosc1:
-    vt->tty_state = ESnormal;
-    if (ch == ';') {
-      vt->tty_state = ESosc2;
-    } else {
-      DPRINTF(1, "%s: got illegal OSC sequence", __func__);
-    }
-    break;
-  case ESosc2:
-    if (ch != 0x9c && ch != 7) {
-      int i = 0;
-      while (vt->osc_textbuf[i]) i++;
-      vt->osc_textbuf[i++] = ch;
-      vt->osc_textbuf[i] = 0;
-    } else {
-      DPRINTF(1, "%s: OSC:%c:%s", __func__, vt->osc_cmd, vt->osc_textbuf);
-      vt->tty_state = ESnormal;
-    }
-    break;
-  case ESpalette:
-    if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F')
-       || (ch >= 'a' && ch <= 'f')) {
-      vt->esc_buf[vt->esc_count++] = (ch > '9' ? (ch & 0xDF) - 'A' + 10 : ch - '0');
-      if (vt->esc_count == 7) {
-       // fixme: this does not work - please test
-          /*
-       rfbColourMap *cmap =&vt->screen->colourMap;
-
-       int i = color_table[vt->esc_buf[0]] * 3, j = 1;
-       cmap->data.bytes[i] = 16 * vt->esc_buf[j++];
-       cmap->data.bytes[i++] += vt->esc_buf[j++];
-       cmap->data.bytes[i] = 16 * vt->esc_buf[j++];
-       cmap->data.bytes[i++] += vt->esc_buf[j++];
-       cmap->data.bytes[i] = 16 * vt->esc_buf[j++];
-       cmap->data.bytes[i] += vt->esc_buf[j];
-          */
-       //set_palette(vc); ?
-
-       vt->tty_state = ESnormal;
-      }
-    } else
-       vt->tty_state = ESnormal;
-    break;
-  case ESsquare:
-    for(i = 0; i < MAX_ESC_PARAMS; i++) {
-      vt->esc_buf[i] = 0;
+    if (debug && !vt->tty_state) {
+        DPRINTF(1, "%s: CHAR:%2d: %4x '%c' (cur_enc %d) %d %d", __func__,
+                vt->tty_state, ch, ch, vt->cur_enc, vt->cx, vt->cy);
     }
 
-    vt->esc_count = 0;
-    vt->esc_has_par = 0;
-    vt->tty_state = ESgetpars;
-
-    if (ch == '>') {
-      vt->tty_state = ESidquery;
-      break;
-    }
+    switch(vt->tty_state) {
+    case ESesc:
+        vt->tty_state = ESnormal;
+        switch (ch) {
+        case '[':
+            vt->tty_state = ESsquare;
+            break;
+        case ']':
+            vt->tty_state = ESnonstd;
+            break;
+        case '%':
+            vt->tty_state = ESpercent;
+            break;
+        case '7':
+            spiceterm_save_cursor (vt);
+            break;
+        case '8':
+            spiceterm_restore_cursor (vt);
+            break;
+        case '(':
+            vt->tty_state = ESsetG0; // SET G0
+            break;
+        case ')':
+            vt->tty_state = ESsetG1; // SET G1
+            break;
+        case 'M':
+            /* cursor up (ri) */
+            if (vt->cy == vt->region_top)
+                spiceterm_scroll_down (vt, vt->region_top, vt->region_bottom, 1);
+            else if (vt->cy > 0) {
+                vt->cy--;
+            }
+            break;
+        case '>':
+            /* numeric keypad  - ignored */
+            break;
+        case '=':
+            /* appl. keypad - ignored */
+            break;
+        default:
+            DPRINTF(1, "%s: got unhandled ESC%c  %d", __func__, ch, ch);
+            break;
+        }
+        break;
+    case ESnonstd: /* Operating System Controls */
+        vt->tty_state = ESnormal;
+
+        switch (ch) {
+        case 'P':   /* palette escape sequence */
+            for(i = 0; i < MAX_ESC_PARAMS; i++) {
+                vt->esc_buf[i] = 0;
+            }
 
-    if ((vt->esc_ques = (ch == '?'))) {
-      break;
-    }
-  case ESgetpars:
-    if (ch >= '0' && ch <= '9') {
-      vt->esc_has_par = 1;
-      if (vt->esc_count < MAX_ESC_PARAMS) {
-       vt->esc_buf[vt->esc_count] = vt->esc_buf[vt->esc_count] * 10 + ch - '0';
-      }
-      break;
-    } else if (ch == ';') {
-      vt->esc_count++;
-      break;
-    } else {
-      if (vt->esc_has_par) {
-       vt->esc_count++;
-      }
-      vt->tty_state = ESgotpars;
-    }
-  case ESgotpars:
+            vt->esc_count = 0;
+            vt->tty_state = ESpalette;
+            break;
+        case 'R':   /* reset palette */
+            // fixme: reset_palette(vc);
+            break;
+        case '0':
+        case '1':
+        case '2':
+        case '4':
+            vt->osc_cmd = ch;
+            vt->osc_textbuf[0] = 0;
+            vt->tty_state = ESosc1;
+            break;
+        default:
+            DPRINTF(1, "%s: got unhandled OSC %c", __func__, ch);
+            vt->tty_state = ESnormal;
+            break;
+        }
+        break;
+    case ESosc1:
+        vt->tty_state = ESnormal;
+        if (ch == ';') {
+            vt->tty_state = ESosc2;
+        } else {
+            DPRINTF(1, "%s: got illegal OSC sequence", __func__);
+        }
+        break;
+    case ESosc2:
+        if (ch != 0x9c && ch != 7) {
+            int i = 0;
+            while (vt->osc_textbuf[i]) i++;
+            vt->osc_textbuf[i++] = ch;
+            vt->osc_textbuf[i] = 0;
+        } else {
+            DPRINTF(1, "%s: OSC:%c:%s", __func__, vt->osc_cmd, vt->osc_textbuf);
+            vt->tty_state = ESnormal;
+        }
+        break;
+    case ESpalette:
+        if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F')
+            || (ch >= 'a' && ch <= 'f')) {
+            vt->esc_buf[vt->esc_count++] = (ch > '9' ? (ch & 0xDF) - 'A' + 10 : ch - '0');
+            if (vt->esc_count == 7) {
+                // fixme: this does not work - please test
+                /*
+                  rfbColourMap *cmap =&vt->screen->colourMap;
+
+                  int i = color_table[vt->esc_buf[0]] * 3, j = 1;
+                  cmap->data.bytes[i] = 16 * vt->esc_buf[j++];
+                  cmap->data.bytes[i++] += vt->esc_buf[j++];
+                  cmap->data.bytes[i] = 16 * vt->esc_buf[j++];
+                  cmap->data.bytes[i++] += vt->esc_buf[j++];
+                  cmap->data.bytes[i] = 16 * vt->esc_buf[j++];
+                  cmap->data.bytes[i] += vt->esc_buf[j];
+                */
+                //set_palette(vc); ?
+                
+                vt->tty_state = ESnormal;
+            }
+        } else
+            vt->tty_state = ESnormal;
+        break;
+    case ESsquare:
+        for(i = 0; i < MAX_ESC_PARAMS; i++) {
+            vt->esc_buf[i] = 0;
+        }
 
-    vt->tty_state = ESnormal;
+        vt->esc_count = 0;
+        vt->esc_has_par = 0;
+        vt->tty_state = ESgetpars;
+        
+        if (ch == '>') {
+            vt->tty_state = ESidquery;
+            break;
+        }
 
-    char *qes = vt->esc_ques ? "?" : "";
-    
-    if (debug) {
-        if (vt->esc_count == 0) {
-            DPRINTF(1, "%s: ESC[%s%c", __func__, qes, ch);
-        } else if (vt->esc_count == 1) {
-            DPRINTF(1, "%s: ESC[%s%d%c\n", __func__, qes, vt->esc_buf[0], ch);
+        if ((vt->esc_ques = (ch == '?'))) {
+            break;
+        }
+    case ESgetpars:
+        if (ch >= '0' && ch <= '9') {
+            vt->esc_has_par = 1;
+            if (vt->esc_count < MAX_ESC_PARAMS) {
+                vt->esc_buf[vt->esc_count] = vt->esc_buf[vt->esc_count] * 10 + ch - '0';
+            }
+            break;
+        } else if (ch == ';') {
+            vt->esc_count++;
+            break;
         } else {
-            int i;
-            printf("ESC[%s%d", qes, vt->esc_buf[0]);
-            for (i = 1; i < vt->esc_count; i++) {
-                printf(";%d",  vt->esc_buf[i]);
+            if (vt->esc_has_par) {
+                vt->esc_count++;
+            }
+            vt->tty_state = ESgotpars;
+        }
+    case ESgotpars:
+        
+        vt->tty_state = ESnormal;
+
+        char *qes = vt->esc_ques ? "?" : "";
+
+        if (debug) {
+            //fixme:
+            if (vt->esc_count == 0) {
+                DPRINTF(1, "%s: ESC[%s%c", __func__, qes, ch);
+            } else if (vt->esc_count == 1) {
+                DPRINTF(1, "%s: ESC[%s%d%c\n", __func__, qes, vt->esc_buf[0], ch);
+            } else {
+                int i;
+                printf("ESC[%s%d", qes, vt->esc_buf[0]);
+                for (i = 1; i < vt->esc_count; i++) {
+                    printf(";%d",  vt->esc_buf[i]);
+                }
+                printf("%c\n", ch);
             }
-            printf("%c\n", ch);
         }
-    }
 
-    switch (ch) {
-    case 'h':
-      spiceterm_set_mode (vt, 1);
-      break;
-    case 'l':
-      spiceterm_set_mode (vt, 0);
-      break;
-    case 'm':
-      if (!vt->esc_count) {
-       vt->esc_count++; // default parameter 0
-      }
-      spiceterm_csi_m (vt);
-      break;
-    case 'n':
-      /* report cursor position */
-      /* TODO: send ESC[row;colR */
-      break;
-    case 'A':
-      /* move cursor up */
-      if (vt->esc_buf[0] == 0) {
-       vt->esc_buf[0] = 1;
-      }
-      vt->cy -= vt->esc_buf[0];
-      if (vt->cy < 0) {
-       vt->cy = 0;
-      }
-      break;
-    case 'B':
-    case 'e':
-      /* move cursor down */
-      if (vt->esc_buf[0] == 0) {
-       vt->esc_buf[0] = 1;
-      }
-      vt->cy += vt->esc_buf[0];
-      if (vt->cy >= vt->height) {
-       vt->cy = vt->height - 1;
-      }
-      break;
-    case 'C':
-    case 'a':
-      /* move cursor right */
-      if (vt->esc_buf[0] == 0) {
-       vt->esc_buf[0] = 1;
-      }
-      vt->cx += vt->esc_buf[0];
-      if (vt->cx >= vt->width) {
-       vt->cx = vt->width - 1;
-      }
-      break;
-    case 'D':
-      /* move cursor left */
-      if (vt->esc_buf[0] == 0) {
-       vt->esc_buf[0] = 1;
-      }
-      vt->cx -= vt->esc_buf[0];
-      if (vt->cx < 0) {
-       vt->cx = 0;
-      }
-      break;
-    case 'G':
-    case '`':
-      /* move cursor to column */
-      spiceterm_gotoxy (vt, vt->esc_buf[0] - 1, vt->cy);
-      break;
-    case 'd':
-      /* move cursor to row */
-      spiceterm_gotoxy (vt, vt->cx , vt->esc_buf[0] - 1);
-      break;
-    case 'f':
-    case 'H':
-      /* move cursor to row, column */
-      spiceterm_gotoxy (vt, vt->esc_buf[1] - 1,  vt->esc_buf[0] - 1);
-      break;
-    case 'J':
-      switch (vt->esc_buf[0]) {
-      case 0:
-       /* clear to end of screen */
-       for (y = vt->cy; y < vt->height; y++) {
-         for (x = 0; x < vt->width; x++) {
-           if (y == vt->cy && x < vt->cx) {
-             continue;
-           }
-           spiceterm_clear_xy (vt, x, y);
-         }
-       }
-       break;
-      case 1:
-       /* clear from beginning of screen */
-       for (y = 0; y <= vt->cy; y++) {
-         for (x = 0; x < vt->width; x++) {
-           if (y == vt->cy && x > vt->cx) {
-             break;
-           }
-           spiceterm_clear_xy (vt, x, y);
-         }
-       }
-       break;
-      case 2:
-       /* clear entire screen */
-       for (y = 0; y <= vt->height; y++) {
-         for (x = 0; x < vt->width; x++) {
-           spiceterm_clear_xy (vt, x, y);
-         }
-       }
-       break;
-      }
-      break;
-    case 'K':
-      switch (vt->esc_buf[0]) {
-      case 0:
-       /* clear to eol */
-       for(x = vt->cx; x < vt->width; x++) {
-         spiceterm_clear_xy (vt, x, vt->cy);
-       }
-       break;
-      case 1:
-       /* clear from beginning of line */
-       for (x = 0; x <= vt->cx; x++) {
-         spiceterm_clear_xy (vt, x, vt->cy);
-       }
-       break;
-      case 2:
-       /* clear entire line */
-       for(x = 0; x < vt->width; x++) {
-         spiceterm_clear_xy (vt, x, vt->cy);
-       }
-       break;
-      }
-      break;
-    case 'L':
-      /* insert line */
-      c = vt->esc_buf[0];
-
-      if (c > vt->height - vt->cy)
-       c = vt->height - vt->cy;
-      else if (!c)
-       c = 1;
-
-      spiceterm_scroll_down (vt, vt->cy, vt->region_bottom, c);
-      break;
-    case 'M':
-      /* delete line */
-      c = vt->esc_buf[0];
-
-      if (c > vt->height - vt->cy)
-       c = vt->height - vt->cy;
-      else if (!c)
-       c = 1;
-
-      spiceterm_scroll_up (vt, vt->cy, vt->region_bottom, c, 1);
-      break;
-    case 'T':
-      /* scroll down */
-      c = vt->esc_buf[0];
-      if (!c) c = 1;
-      spiceterm_scroll_down (vt, vt->region_top, vt->region_bottom, c);
-      break;
-    case 'S':
-      /* scroll up */
-      c = vt->esc_buf[0];
-      if (!c) c = 1;
-      spiceterm_scroll_up (vt, vt->region_top, vt->region_bottom, c, 1);
-      break;
-    case 'P':
-      /* delete c character */
-      c = vt->esc_buf[0];
-
-      if (c > vt->width - vt->cx)
-       c = vt->width - vt->cx;
-      else if (!c)
-       c = 1;
-
-      for (x = vt->cx; x < vt->width - c; x++) {
-       int y1 = (vt->y_base + vt->cy) % vt->total_height;
-       TextCell *dst = &vt->cells[y1 * vt->width + x];
-       TextCell *src = dst + c;
-       *dst = *src;
-       spiceterm_update_xy (vt, x + c, vt->cy);
-       src->ch = ' ';
-       src->attrib = vt->default_attrib;
-       spiceterm_update_xy (vt, x, vt->cy);
-      }
-      break;
-    case 's':
-      /* save cursor position */
-      spiceterm_save_cursor (vt);
-      break;
-    case 'u':
-      /* restore cursor position */
-      spiceterm_restore_cursor (vt);
-      break;
-    case 'X':
-      /* erase c characters */
-      c = vt->esc_buf[0];
-      if (!c) c = 1;
-
-      if (c > (vt->width - vt->cx)) c = vt->width - vt->cx;
-
-      for(i = 0; i < c; i++) {
-       spiceterm_clear_xy (vt, vt->cx + i, vt->cy);
-      }
-      break;
-    case '@':
-      /* insert c character */
-      c = vt->esc_buf[0];
-      if (c > (vt->width - vt->cx)) {
-       c = vt->width - vt->cx;
-      }
-      if (!c) c = 1;
-
-      for (x = vt->width - c; x >= vt->cx; x--) {
-       int y1 = (vt->y_base + vt->cy) % vt->total_height;
-       TextCell *src = &vt->cells[y1 * vt->width + x];
-       TextCell *dst = src + c;
-       *dst = *src;
-       spiceterm_update_xy (vt, x + c, vt->cy);
-       src->ch = ' ';
-       src->attrib = vt->cur_attrib;
-       spiceterm_update_xy (vt, x, vt->cy);
-      }
+        switch (ch) {
+        case 'h':
+            spiceterm_set_mode (vt, 1);
+            break;
+        case 'l':
+            spiceterm_set_mode (vt, 0);
+            break;
+        case 'm':
+            if (!vt->esc_count) {
+                vt->esc_count++; // default parameter 0
+            }
+            spiceterm_csi_m (vt);
+            break;
+        case 'n':
+            /* report cursor position */
+            /* TODO: send ESC[row;colR */
+            break;
+        case 'A':
+            /* move cursor up */
+            if (vt->esc_buf[0] == 0) {
+                vt->esc_buf[0] = 1;
+            }
+            vt->cy -= vt->esc_buf[0];
+            if (vt->cy < 0) {
+                vt->cy = 0;
+            }
+            break;
+        case 'B':
+        case 'e':
+            /* move cursor down */
+            if (vt->esc_buf[0] == 0) {
+                vt->esc_buf[0] = 1;
+            }
+            vt->cy += vt->esc_buf[0];
+            if (vt->cy >= vt->height) {
+                vt->cy = vt->height - 1;
+            }
+            break;
+        case 'C':
+        case 'a':
+            /* move cursor right */
+            if (vt->esc_buf[0] == 0) {
+                vt->esc_buf[0] = 1;
+            }
+            vt->cx += vt->esc_buf[0];
+            if (vt->cx >= vt->width) {
+                vt->cx = vt->width - 1;
+            }
+            break;
+        case 'D':
+            /* move cursor left */
+            if (vt->esc_buf[0] == 0) {
+                vt->esc_buf[0] = 1;
+            }
+            vt->cx -= vt->esc_buf[0];
+            if (vt->cx < 0) {
+                vt->cx = 0;
+            }
+            break;
+        case 'G':
+        case '`':
+            /* move cursor to column */
+            spiceterm_gotoxy (vt, vt->esc_buf[0] - 1, vt->cy);
+            break;
+        case 'd':
+            /* move cursor to row */
+            spiceterm_gotoxy (vt, vt->cx , vt->esc_buf[0] - 1);
+            break;
+        case 'f':
+        case 'H':
+            /* move cursor to row, column */
+            spiceterm_gotoxy (vt, vt->esc_buf[1] - 1,  vt->esc_buf[0] - 1);
+            break;
+        case 'J':
+            switch (vt->esc_buf[0]) {
+            case 0:
+                /* clear to end of screen */
+                for (y = vt->cy; y < vt->height; y++) {
+                    for (x = 0; x < vt->width; x++) {
+                        if (y == vt->cy && x < vt->cx) {
+                            continue;
+                        }
+                        spiceterm_clear_xy (vt, x, y);
+                    }
+                }
+                break;
+            case 1:
+                /* clear from beginning of screen */
+                for (y = 0; y <= vt->cy; y++) {
+                    for (x = 0; x < vt->width; x++) {
+                        if (y == vt->cy && x > vt->cx) {
+                            break;
+                        }
+                        spiceterm_clear_xy (vt, x, y);
+                    }
+                }
+                break;
+            case 2:
+                /* clear entire screen */
+                for (y = 0; y <= vt->height; y++) {
+                    for (x = 0; x < vt->width; x++) {
+                        spiceterm_clear_xy (vt, x, y);
+                    }
+                }
+                break;
+            }
+            break;
+        case 'K':
+            switch (vt->esc_buf[0]) {
+            case 0:
+                /* clear to eol */
+                for(x = vt->cx; x < vt->width; x++) {
+                    spiceterm_clear_xy (vt, x, vt->cy);
+                }
+                break;
+            case 1:
+                /* clear from beginning of line */
+                for (x = 0; x <= vt->cx; x++) {
+                    spiceterm_clear_xy (vt, x, vt->cy);
+                }
+                break;
+            case 2:
+                /* clear entire line */
+                for(x = 0; x < vt->width; x++) {
+                    spiceterm_clear_xy (vt, x, vt->cy);
+                }
+                break;
+            }
+            break;
+        case 'L':
+            /* insert line */
+            c = vt->esc_buf[0];
+            
+            if (c > vt->height - vt->cy)
+                c = vt->height - vt->cy;
+            else if (!c)
+                c = 1;
+
+            spiceterm_scroll_down (vt, vt->cy, vt->region_bottom, c);
+            break;
+        case 'M':
+            /* delete line */
+            c = vt->esc_buf[0];
+            
+            if (c > vt->height - vt->cy)
+                c = vt->height - vt->cy;
+            else if (!c)
+                c = 1;
+
+            spiceterm_scroll_up (vt, vt->cy, vt->region_bottom, c, 1);
+            break;
+        case 'T':
+            /* scroll down */
+            c = vt->esc_buf[0];
+            if (!c) c = 1;
+            spiceterm_scroll_down (vt, vt->region_top, vt->region_bottom, c);
+            break;
+        case 'S':
+            /* scroll up */
+            c = vt->esc_buf[0];
+            if (!c) c = 1;
+            spiceterm_scroll_up (vt, vt->region_top, vt->region_bottom, c, 1);
+            break;
+        case 'P':
+            /* delete c character */
+            c = vt->esc_buf[0];
+            
+            if (c > vt->width - vt->cx)
+                c = vt->width - vt->cx;
+            else if (!c)
+                c = 1;
+
+            for (x = vt->cx; x < vt->width - c; x++) {
+                int y1 = (vt->y_base + vt->cy) % vt->total_height;
+                TextCell *dst = &vt->cells[y1 * vt->width + x];
+                TextCell *src = dst + c;
+                *dst = *src;
+                spiceterm_update_xy (vt, x + c, vt->cy);
+                src->ch = ' ';
+                src->attrib = vt->default_attrib;
+                spiceterm_update_xy (vt, x, vt->cy);
+            }
+            break;
+        case 's':
+            /* save cursor position */
+            spiceterm_save_cursor (vt);
+            break;
+        case 'u':
+            /* restore cursor position */
+            spiceterm_restore_cursor (vt);
+            break;
+        case 'X':
+            /* erase c characters */
+            c = vt->esc_buf[0];
+            if (!c) c = 1;
+            
+            if (c > (vt->width - vt->cx)) c = vt->width - vt->cx;
 
-      break;
-    case 'r':
-      /* set region */
-      if (!vt->esc_buf[0])
-       vt->esc_buf[0]++;
-      if (!vt->esc_buf[1])
-       vt->esc_buf[1] = vt->height;
-      /* Minimum allowed region is 2 lines */
-      if (vt->esc_buf[0] < vt->esc_buf[1] &&
-         vt->esc_buf[1] <= vt->height) {
-       vt->region_top = vt->esc_buf[0] - 1;
-       vt->region_bottom = vt->esc_buf[1];
-       vt->cx = 0;
-       vt->cy = vt->region_top;
-       DPRINTF(1, "%s: set region %d %d", __func__, vt->region_top, vt->region_bottom);
-      }
+            for(i = 0; i < c; i++) {
+                spiceterm_clear_xy (vt, vt->cx + i, vt->cy);
+            }
+            break;
+        case '@':
+            /* insert c character */
+            c = vt->esc_buf[0];
+            if (c > (vt->width - vt->cx)) {
+                c = vt->width - vt->cx;
+            }
+            if (!c) c = 1;
+            
+            for (x = vt->width - c; x >= vt->cx; x--) {
+                int y1 = (vt->y_base + vt->cy) % vt->total_height;
+                TextCell *src = &vt->cells[y1 * vt->width + x];
+                TextCell *dst = src + c;
+                *dst = *src;
+                spiceterm_update_xy (vt, x + c, vt->cy);
+                src->ch = ' ';
+                src->attrib = vt->cur_attrib;
+                spiceterm_update_xy (vt, x, vt->cy);
+            }
 
-      break;
-    default:
-      if (debug) {
-          if (vt->esc_count == 0) {
-              DPRINTF(1, "%s: unhandled escape ESC[%s%c", __func__,  qes, ch);
-          } else if (vt->esc_count == 1) {
-              DPRINTF(1, "%s: unhandled escape ESC[%s%d%c\n", __func__, qes, vt->esc_buf[0], ch);
-          } else {
-              int i;
-              printf("unhandled escape ESC[%s%d", qes, vt->esc_buf[0]);
-              for (i = 1; i < vt->esc_count; i++) {
-                  printf(";%d",  vt->esc_buf[i]);
-              }
-              printf("%c\n", ch);
-          }
-      }
-      break;
-    }
-    vt->esc_ques = 0;
-    break;
-  case ESsetG0: // Set G0
-    vt->tty_state = ESnormal;
-
-    if (ch == '0')
-      vt->g0enc = GRAF_MAP;
-    else if (ch == 'B')
-      vt->g0enc = LAT1_MAP;
-    else if (ch == 'U')
-      vt->g0enc = IBMPC_MAP;
-    else if (ch == 'K')
-      vt->g0enc = USER_MAP;
-
-    if (vt->charset == 0)
-      vt->cur_enc = vt->g0enc;
-
-    break;
-  case ESsetG1: // Set G1
-    vt->tty_state = ESnormal;
-
-    if (ch == '0')
-      vt->g1enc = GRAF_MAP;
-    else if (ch == 'B')
-      vt->g1enc = LAT1_MAP;
-    else if (ch == 'U')
-      vt->g1enc = IBMPC_MAP;
-    else if (ch == 'K')
-      vt->g1enc = USER_MAP;
-
-    if (vt->charset == 1)
-      vt->cur_enc = vt->g1enc;
-
-    break;
-  case ESidquery: // vt100 query id
-    vt->tty_state = ESnormal;
-
-    if (ch == 'c') {
-      DPRINTF(1, "%s: ESC[>c   Query term ID", __func__);
-      spiceterm_respond_esc (vt, TERMIDCODE);
-    }
-    break;
-  case ESpercent:
-    vt->tty_state = ESnormal;
-    switch (ch) {
-    case '@':  /* defined in ISO 2022 */
-      vt->utf8 = 0;
-      break;
-    case 'G':  /* prelim official escape code */
-    case '8':  /* retained for compatibility */
-      vt->utf8 = 1;
-      break;
-    }
-    break;
-  default: // ESnormal
-    vt->tty_state = ESnormal;
-
-    switch(ch) {
-    case 0:
-      break;
-    case 7:  /* alert aka. bell */
-        // fixme:
-        //rfbSendBell(vt->screen);
-      break;
-    case 8:  /* backspace */
-      if (vt->cx > 0)
-       vt->cx--;
-      break;
-    case 9:  /* tabspace */
-      if (vt->cx + (8 - (vt->cx % 8)) > vt->width) {
-       vt->cx = 0;
-       spiceterm_put_lf (vt);
-      } else {
-       vt->cx = vt->cx + (8 - (vt->cx % 8));
-      }
-      break;
-    case 10:  /* LF,*/
-    case 11:  /* VT */
-    case 12:  /* FF */
-      spiceterm_put_lf (vt);
-      break;
-    case 13:  /* carriage return */
-      vt->cx = 0;
-      break;
-    case 14:
-      /* SI (shift in), select character set 1 */
-      vt->charset = 1;
-      vt->cur_enc = vt->g1enc;
-      /* fixme: display controls = 1 */
-      break;
-    case 15:
-      /* SO (shift out), select character set 0 */
-      vt->charset = 0;
-      vt->cur_enc = vt->g0enc;
-      /* fixme: display controls = 0 */
-      break;
-    case 27:    /* esc */
-      vt->tty_state = ESesc;
-      break;
-    case 127: /* delete */
-      /* ignore */
-      break;
-    case 128+27:    /* csi */
-      vt->tty_state = ESsquare;
-      break;
-    default:
-      if (vt->cx >= vt->width) {
-       /* line wrap */
-       vt->cx = 0;
-       spiceterm_put_lf (vt);
-      }
+            break;
+        case 'r':
+            /* set region */
+            if (!vt->esc_buf[0])
+                vt->esc_buf[0]++;
+            if (!vt->esc_buf[1])
+                vt->esc_buf[1] = vt->height;
+            /* Minimum allowed region is 2 lines */
+            if (vt->esc_buf[0] < vt->esc_buf[1] &&
+                vt->esc_buf[1] <= vt->height) {
+                vt->region_top = vt->esc_buf[0] - 1;
+                vt->region_bottom = vt->esc_buf[1];
+                vt->cx = 0;
+                vt->cy = vt->region_top;
+                DPRINTF(1, "%s: set region %d %d", __func__, vt->region_top, vt->region_bottom);
+            }
 
-      int y1 = (vt->y_base + vt->cy) % vt->total_height;
-      TextCell *c = &vt->cells[y1*vt->width + vt->cx];
-      c->attrib = vt->cur_attrib;
-      c->ch = ch;
-      spiceterm_update_xy (vt, vt->cx, vt->cy);
-      vt->cx++;
-      break;
+            break;
+        default:
+            if (debug) {
+                // fixme
+                if (vt->esc_count == 0) {
+                    DPRINTF(1, "%s: unhandled escape ESC[%s%c", __func__,  qes, ch);
+                } else if (vt->esc_count == 1) {
+                    DPRINTF(1, "%s: unhandled escape ESC[%s%d%c\n", __func__, qes, vt->esc_buf[0], ch);
+                } else {
+                    int i;
+                    printf("unhandled escape ESC[%s%d", qes, vt->esc_buf[0]);
+                    for (i = 1; i < vt->esc_count; i++) {
+                        printf(";%d",  vt->esc_buf[i]);
+                    }
+                    printf("%c\n", ch);
+                }
+            }
+            break;
+        }
+        vt->esc_ques = 0;
+        break;
+    case ESsetG0: // Set G0
+        vt->tty_state = ESnormal;
+
+        if (ch == '0')
+            vt->g0enc = GRAF_MAP;
+        else if (ch == 'B')
+            vt->g0enc = LAT1_MAP;
+        else if (ch == 'U')
+            vt->g0enc = IBMPC_MAP;
+        else if (ch == 'K')
+            vt->g0enc = USER_MAP;
+        
+        if (vt->charset == 0)
+            vt->cur_enc = vt->g0enc;
+
+        break;
+    case ESsetG1: // Set G1
+        vt->tty_state = ESnormal;
+
+        if (ch == '0')
+            vt->g1enc = GRAF_MAP;
+        else if (ch == 'B')
+            vt->g1enc = LAT1_MAP;
+        else if (ch == 'U')
+            vt->g1enc = IBMPC_MAP;
+        else if (ch == 'K')
+            vt->g1enc = USER_MAP;
+
+        if (vt->charset == 1)
+            vt->cur_enc = vt->g1enc;
+
+        break;
+    case ESidquery: // vt100 query id
+        vt->tty_state = ESnormal;
+
+        if (ch == 'c') {
+            DPRINTF(1, "%s: ESC[>c   Query term ID", __func__);
+            spiceterm_respond_esc (vt, TERMIDCODE);
+        }
+        break;
+    case ESpercent:
+        vt->tty_state = ESnormal;
+        switch (ch) {
+        case '@':  /* defined in ISO 2022 */
+            vt->utf8 = 0;
+            break;
+        case 'G':  /* prelim official escape code */
+        case '8':  /* retained for compatibility */
+            vt->utf8 = 1;
+            break;
+        }
+        break;
+    default: // ESnormal
+        vt->tty_state = ESnormal;
+
+        switch(ch) {
+        case 0:
+            break;
+        case 7:  /* alert aka. bell */
+            // fixme:
+            //rfbSendBell(vt->screen);
+            break;
+        case 8:  /* backspace */
+            if (vt->cx > 0)
+                vt->cx--;
+            break;
+        case 9:  /* tabspace */
+            if (vt->cx + (8 - (vt->cx % 8)) > vt->width) {
+                vt->cx = 0;
+                spiceterm_put_lf (vt);
+            } else {
+                vt->cx = vt->cx + (8 - (vt->cx % 8));
+            }
+            break;
+        case 10:  /* LF,*/
+        case 11:  /* VT */
+        case 12:  /* FF */
+            spiceterm_put_lf (vt);
+            break;
+        case 13:  /* carriage return */
+            vt->cx = 0;
+            break;
+        case 14:
+            /* SI (shift in), select character set 1 */
+            vt->charset = 1;
+            vt->cur_enc = vt->g1enc;
+            /* fixme: display controls = 1 */
+            break;
+        case 15:
+            /* SO (shift out), select character set 0 */
+            vt->charset = 0;
+            vt->cur_enc = vt->g0enc;
+            /* fixme: display controls = 0 */
+            break;
+        case 27:    /* esc */
+            vt->tty_state = ESesc;
+            break;
+        case 127: /* delete */
+            /* ignore */
+            break;
+        case 128+27:    /* csi */
+            vt->tty_state = ESsquare;
+            break;
+        default:
+            if (vt->cx >= vt->width) {
+                /* line wrap */
+                vt->cx = 0;
+                spiceterm_put_lf (vt);
+            }
+
+            int y1 = (vt->y_base + vt->cy) % vt->total_height;
+            TextCell *c = &vt->cells[y1*vt->width + vt->cx];
+            c->attrib = vt->cur_attrib;
+            c->ch = ch;
+            spiceterm_update_xy (vt, vt->cx, vt->cy);
+            vt->cx++;
+            break;
+        }
+        break;
     }
-    break;
-  }
 }
 
 static int
@@ -1184,68 +1186,68 @@ spiceterm_puts (spiceTerm *vt, const char *buf, int len)
     spiceterm_show_cursor (vt, 0);
 
     while (len) {
-      unsigned char c = *buf;
-      len--;
-      buf++;
-
-      if (vt->tty_state != ESnormal) {
-       // never translate escape sequence
-       tc = c;
-      } else if (vt->utf8 && !vt->cur_enc) {
-
-       if(c & 0x80) { // utf8 multi-byte sequence
-
-         if (vt->utf_count > 0 && (c & 0xc0) == 0x80) {
-           // inside UTF8 sequence
-           vt->utf_char = (vt->utf_char << 6) | (c & 0x3f);
-           vt->utf_count--;
-           if (vt->utf_count == 0) {
-             tc = vt->utf_char;
-           } else {
-             continue;
-           }
-         } else {
-           //  first char of a UTF8 sequence
-           if ((c & 0xe0) == 0xc0) {
-             vt->utf_count = 1;
-             vt->utf_char = (c & 0x1f);
-           } else if ((c & 0xf0) == 0xe0) {
-             vt->utf_count = 2;
-             vt->utf_char = (c & 0x0f);
-           } else if ((c & 0xf8) == 0xf0) {
-             vt->utf_count = 3;
-             vt->utf_char = (c & 0x07);
-           } else if ((c & 0xfc) == 0xf8) {
-             vt->utf_count = 4;
-             vt->utf_char = (c & 0x03);
-           } else if ((c & 0xfe) == 0xfc) {
-             vt->utf_count = 5;
-             vt->utf_char = (c & 0x01);
-           } else
-             vt->utf_count = 0;
-
-           continue;
-         }
-       } else {
-         // utf8 single byte
-         tc = c;
-         vt->utf_count = 0;
-       }
-
-      }        else {
-       // never translate controls
-       if (c >= 32 && c != 127 && c != (128+27)) {
-         tc = translations[vt->cur_enc][c & 0x0ff];
-       } else {
-         tc = c;
-       }
-      }
+        unsigned char c = *buf;
+        len--;
+        buf++;
+
+        if (vt->tty_state != ESnormal) {
+            // never translate escape sequence
+            tc = c;
+        } else if (vt->utf8 && !vt->cur_enc) {
+
+            if(c & 0x80) { // utf8 multi-byte sequence
+
+                if (vt->utf_count > 0 && (c & 0xc0) == 0x80) {
+                    // inside UTF8 sequence
+                    vt->utf_char = (vt->utf_char << 6) | (c & 0x3f);
+                    vt->utf_count--;
+                    if (vt->utf_count == 0) {
+                        tc = vt->utf_char;
+                    } else {
+                        continue;
+                    }
+                } else {
+                    //  first char of a UTF8 sequence
+                    if ((c & 0xe0) == 0xc0) {
+                        vt->utf_count = 1;
+                        vt->utf_char = (c & 0x1f);
+                    } else if ((c & 0xf0) == 0xe0) {
+                        vt->utf_count = 2;
+                        vt->utf_char = (c & 0x0f);
+                    } else if ((c & 0xf8) == 0xf0) {
+                        vt->utf_count = 3;
+                        vt->utf_char = (c & 0x07);
+                    } else if ((c & 0xfc) == 0xf8) {
+                        vt->utf_count = 4;
+                        vt->utf_char = (c & 0x03);
+                    } else if ((c & 0xfe) == 0xfc) {
+                        vt->utf_count = 5;
+                        vt->utf_char = (c & 0x01);
+                    } else
+                        vt->utf_count = 0;
+
+                    continue;
+                }
+            } else {
+                // utf8 single byte
+                tc = c;
+                vt->utf_count = 0;
+            }
 
-      spiceterm_putchar (vt, tc);
+        } else {
+            // never translate controls
+            if (c >= 32 && c != 127 && c != (128+27)) {
+                tc = translations[vt->cur_enc][c & 0x0ff];
+            } else {
+                tc = c;
+            }
+        }
+        
+        spiceterm_putchar (vt, tc);
     }
 
     spiceterm_show_cursor (vt, 1);
-
+    
     return len;
 }
 
@@ -1362,7 +1364,7 @@ spiceterm_pointer_event (int buttonMask, int x, int y, rfbClientPtr cl)
   if (buttonMask & 1) {
     int pos = cy*vt->width + cx;
 
-    // code borrowed from libspiceserver (SPICEonsole.c)
+    // code borrowed from libvncserver (VNCconsole.c)
 
     if (!vt->mark_active) {
 
@@ -1554,7 +1556,7 @@ static void my_kbd_push_keyval(SpiceKbdInstance *sin, uint32_t keySym, int flags
                 vt->y_displ = vt->y_base;
                 spiceterm_refresh (vt);
             }
-            
+
             if (esc) {
                 spiceterm_respond_esc(vt, esc);
             } else if (uc > 0) {
@@ -1586,7 +1588,7 @@ ret:
         }
     }
 
-    vt->screen->core->watch_update_mask(vt->screen->mwatch, 
+    vt->screen->core->watch_update_mask(vt->screen->mwatch,
                                         SPICE_WATCH_EVENT_READ|SPICE_WATCH_EVENT_WRITE);
 }
 
@@ -1608,68 +1610,68 @@ static SpiceKbdInterface my_keyboard_sif = {
 spiceTerm *
 create_spiceterm (int argc, char** argv, int maxx, int maxy)
 {
-  int i;
-
-  SpiceScreen *spice_screen;
+    int i;
 
-  SpiceCoreInterface *core = basic_event_loop_init();
-  spice_screen = spice_screen_new(core);
-  //spice_server_set_image_compression(server, SPICE_IMAGE_COMPRESS_OFF);
-  spice_screen_add_display_interface(spice_screen);
-  spice_screen_add_agent_interface(spice_screen->server);
+    SpiceScreen *spice_screen;
 
-  spiceTerm *vt = (spiceTerm *)calloc (sizeof(spiceTerm), 1);
+    SpiceCoreInterface *core = basic_event_loop_init();
+    spice_screen = spice_screen_new(core);
+    //spice_server_set_image_compression(server, SPICE_IMAGE_COMPRESS_OFF);
+    spice_screen_add_display_interface(spice_screen);
+    spice_screen_add_agent_interface(spice_screen->server);
 
-  vt->keyboard_sin.base.sif = &my_keyboard_sif.base;
-  spice_server_add_interface(spice_screen->server, &vt->keyboard_sin.base);
+    spiceTerm *vt = (spiceTerm *)calloc (sizeof(spiceTerm), 1);
 
-  // screen->setXCutText = spiceterm_set_xcut_text;
-  // screen->ptrAddEvent = spiceterm_pointer_event;
-  // screen->newClientHook = new_client;
-  // screen->desktopName = "SPICE Command Terminal";
+    vt->keyboard_sin.base.sif = &my_keyboard_sif.base;
+    spice_server_add_interface(spice_screen->server, &vt->keyboard_sin.base);
 
-  vt->maxx = spice_screen->width;
-  vt->maxy = spice_screen->height;
+    // screen->setXCutText = spiceterm_set_xcut_text;
+    // screen->ptrAddEvent = spiceterm_pointer_event;
+    // screen->newClientHook = new_client;
+    // screen->desktopName = "SPICE Command Terminal";
 
-  vt->width = vt->maxx / 8;
-  vt->height = vt->maxy / 16;
+    vt->maxx = spice_screen->width;
+    vt->maxy = spice_screen->height;
 
-  vt->total_height = vt->height * 20;
-  vt->scroll_height = 0;
-  vt->y_base =  0;
-  vt->y_displ =  0;
+    vt->width = vt->maxx / 8;
+    vt->height = vt->maxy / 16;
 
-  vt->region_top = 0;
-  vt->region_bottom = vt->height;
+    vt->total_height = vt->height * 20;
+    vt->scroll_height = 0;
+    vt->y_base =  0;
+    vt->y_displ =  0;
 
-  vt->g0enc = LAT1_MAP;
-  vt->g1enc = GRAF_MAP;
-  vt->cur_enc = vt->g0enc;
-  vt->charset = 0;
+    vt->region_top = 0;
+    vt->region_bottom = vt->height;
 
-  /* default text attributes */
-  vt->default_attrib.bold = 0;
-  vt->default_attrib.uline = 0;
-  vt->default_attrib.blink = 0;
-  vt->default_attrib.invers = 0;
-  vt->default_attrib.unvisible = 0;
-  vt->default_attrib.fgcol = 7;
-  vt->default_attrib.bgcol = 0;
+    vt->g0enc = LAT1_MAP;
+    vt->g1enc = GRAF_MAP;
+    vt->cur_enc = vt->g0enc;
+    vt->charset = 0;
 
-  vt->cur_attrib = vt->default_attrib;
+    /* default text attributes */
+    vt->default_attrib.bold = 0;
+    vt->default_attrib.uline = 0;
+    vt->default_attrib.blink = 0;
+    vt->default_attrib.invers = 0;
+    vt->default_attrib.unvisible = 0;
+    vt->default_attrib.fgcol = 7;
+    vt->default_attrib.bgcol = 0;
 
-  vt->cells = (TextCell *)calloc (sizeof (TextCell), vt->width*vt->total_height);
+    vt->cur_attrib = vt->default_attrib;
 
-  for (i = 0; i < vt->width*vt->total_height; i++) {
-    vt->cells[i].ch = ' ';
-    vt->cells[i].attrib = vt->default_attrib;
-  }
+    vt->cells = (TextCell *)calloc (sizeof (TextCell), vt->width*vt->total_height);
+    
+    for (i = 0; i < vt->width*vt->total_height; i++) {
+        vt->cells[i].ch = ' ';
+        vt->cells[i].attrib = vt->default_attrib;
+    }
 
-  vt->altcells = (TextCell *)calloc (sizeof (TextCell), vt->width*vt->height);
+    vt->altcells = (TextCell *)calloc (sizeof (TextCell), vt->width*vt->height);
 
-  vt->screen = spice_screen;
+    vt->screen = spice_screen;
 
-  return vt;
+    return vt;
 }
 
 static void master_watch(int master, int event, void *opaque)
@@ -1701,87 +1703,87 @@ static void master_watch(int master, int event, void *opaque)
 int
 main (int argc, char** argv)
 {
-  int i;
-  char **cmdargv = NULL;
-  char *command = "/bin/bash"; // execute normal shell as default
-  int pid;
-  int master;
-  char ptyname[1024];
-  struct winsize dimensions;
-
-  g_thread_init(NULL);
-
-  for (i = 1; i < argc; i++) {
-    if (!strcmp (argv[i], "-c")) {
-      command = argv[i+1];
-      cmdargv = &argv[i+1];
-      argc = i;
-      argv[i] = NULL;
-      break;
+    int i;
+    char **cmdargv = NULL;
+    char *command = "/bin/bash"; // execute normal shell as default
+    int pid;
+    int master;
+    char ptyname[1024];
+    struct winsize dimensions;
+
+    g_thread_init(NULL);
+
+    for (i = 1; i < argc; i++) {
+        if (!strcmp (argv[i], "-c")) {
+            command = argv[i+1];
+            cmdargv = &argv[i+1];
+            argc = i;
+            argv[i] = NULL;
+            break;
+        }
     }
-  }
 
-  if (0) print_usage(NULL); // fixme:
+    if (0) print_usage(NULL); // fixme:
 
-  spiceTerm *vt = create_spiceterm (argc, argv, 745, 400);
+    spiceTerm *vt = create_spiceterm (argc, argv, 745, 400);
 
-  setlocale(LC_ALL, ""); // set from environment
+    setlocale(LC_ALL, ""); // set from environment
 
-  char *ctype = setlocale (LC_CTYPE, NULL); // query LC_CTYPE
+    char *ctype = setlocale (LC_CTYPE, NULL); // query LC_CTYPE
 
-  // fixme: ist there a standard way to detect utf8 mode ?
-  if (strcasestr (ctype, ".utf-8")||strcasestr (ctype, ".utf8")) {
-    vt->utf8 = 1;
-  }
+    // fixme: ist there a standard way to detect utf8 mode ?
+    if (strcasestr (ctype, ".utf-8")||strcasestr (ctype, ".utf8")) {
+        vt->utf8 = 1;
+    }
 
-  dimensions.ws_col = vt->width;
-  dimensions.ws_row = vt->height;
+    dimensions.ws_col = vt->width;
+    dimensions.ws_row = vt->height;
 
-  setenv ("TERM", TERM, 1);
+    setenv ("TERM", TERM, 1);
 
-  DPRINTF(1, "%s: execute %s", __func__, command);
+    DPRINTF(1, "%s: execute %s", __func__, command);
 
-  pid = forkpty (&master, ptyname, NULL, &dimensions);
-  if(!pid) {
+    pid = forkpty (&master, ptyname, NULL, &dimensions);
+    if(!pid) {
 
-    // install default signal handlers
-    signal (SIGQUIT, SIG_DFL);
-    signal (SIGTERM, SIG_DFL);
-    signal (SIGINT, SIG_DFL);
+        // install default signal handlers
+        signal (SIGQUIT, SIG_DFL);
+        signal (SIGTERM, SIG_DFL);
+        signal (SIGINT, SIG_DFL);
 
-    if (cmdargv) {
-      execvp (command, cmdargv);
-    } else {
-      execlp (command, command, NULL);
+        if (cmdargv) {
+            execvp (command, cmdargv);
+        } else {
+            execlp (command, command, NULL);
+        }
+        perror ("Error: exec failed\n");
+        exit (-1); // should not be reached
+    } else if (pid == -1) {
+        perror ("Error: fork failed\n");
+        exit (-1);
     }
-    perror ("Error: exec failed\n");
-    exit (-1); // should not be reached
-  } else if (pid == -1) {
-    perror ("Error: fork failed\n");
-    exit (-1);
-  }
 
 
-  vt->screen->mwatch = vt->screen->core->watch_add(
-      master, SPICE_WATCH_EVENT_READ /* |SPICE_WATCH_EVENT_WRITE */,
-      master_watch, vt);
+    vt->screen->mwatch = vt->screen->core->watch_add(
+        master, SPICE_WATCH_EVENT_READ /* |SPICE_WATCH_EVENT_WRITE */,
+        master_watch, vt);
 
-  basic_event_loop_mainloop();
+    basic_event_loop_mainloop();
 
-  //rfbProcessEvents (vt->screen, 40000); /* 40 ms */
+    //rfbProcessEvents (vt->screen, 40000); /* 40 ms */
 
-  /*
-    if (vt->ibuf_count > 0) {
+    /*
+      if (vt->ibuf_count > 0) {
       printf ("DEBUG: WRITE %d %d\n", vt->ibuf[0], vt->ibuf_count);
       write (master, vt->ibuf, vt->ibuf_count);
       vt->ibuf_count = 0;
       last_time = time (NULL);
-    }
-  */
+      }
+    */
 
-  kill (pid, 9);
-  int status;
-  waitpid(pid, &status, 0);
+    kill (pid, 9);
+    int status;
+    waitpid(pid, &status, 0);
 
-  exit (0);
+    exit (0);
 }