unix/pterm.c

   1 /*
   2  * pterm - a fusion of the PuTTY terminal emulator with a Unix pty
   3  * back end, all running as a GTK application. Wish me luck.
   4  */
   5
   6 #define _GNU_SOURCE
   7
   8 #include <string.h>
   9 #include <assert.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <signal.h>
  13 #include <stdio.h>
  14 #include <time.h>
  15 #include <errno.h>
  16 #include <fcntl.h>
  17 #include <unistd.h>
  18 #include <sys/types.h>
  19 #include <sys/wait.h>
  20 #include <gtk/gtk.h>
  21 #include <gdk/gdkkeysyms.h>
  22 #include <gdk/gdkx.h>
  23 #include <X11/Xlib.h>
  24 #include <X11/Xutil.h>
  25
  26 #define PUTTY_DO_GLOBALS               /* actually _define_ globals */
  27
  28 #include "putty.h"
  29 #include "terminal.h"
  30
  31 #define CAT2(x,y) x ## y
  32 #define CAT(x,y) CAT2(x,y)
  33 #define ASSERT(x) enum {CAT(assertion_,__LINE__) = 1 / (x)}
  34
  35 #define NCOLOURS (lenof(((Config *)0)->colours))
  36
  37 GdkAtom compound_text_atom, utf8_string_atom;
  38
  39 extern char **pty_argv;        /* declared in pty.c */
  40 extern int use_pty_argv;
  41
  42 struct gui_data {
  43     GtkWidget *window, *area, *sbar;
  44     GtkBox *hbox;
  45     GtkAdjustment *sbar_adjust;
  46     GtkWidget *menu, *specialsmenu, *specialsitem1, *specialsitem2;
  47     GtkWidget *sessionsmenu;
  48     GdkPixmap *pixmap;
  49     GdkFont *fonts[4];                 /* normal, bold, wide, widebold */
  50     struct {
  51         int charset;
  52         int is_wide;
  53     } fontinfo[4];
  54     int xpos, ypos, gotpos, gravity;
  55     GdkCursor *rawcursor, *textcursor, *blankcursor, *currcursor;
  56     GdkColor cols[NCOLOURS];
  57     GdkColormap *colmap;
  58     wchar_t *pastein_data;
  59     int direct_to_font;
  60     int pastein_data_len;
  61     char *pasteout_data, *pasteout_data_utf8;
  62     int pasteout_data_len, pasteout_data_utf8_len;
  63     int font_width, font_height;
  64     int width, height;
  65     int ignore_sbar;
  66     int mouseptr_visible;
  67     guint term_paste_idle_id;
  68     int alt_keycode;
  69     int alt_digits;
  70     char wintitle[sizeof(((Config *)0)->wintitle)];
  71     char icontitle[sizeof(((Config *)0)->wintitle)];
  72     int master_fd, master_func_id;
  73     void *ldisc;
  74     Backend *back;
  75     void *backhandle;
  76     Terminal *term;
  77     void *logctx;
  78     int exited;
  79     struct unicode_data ucsdata;
  80     Config cfg;
  81     void *eventlogstuff;
  82     char *progname, **gtkargvstart;
  83     int ngtkargs;
  84 };
  85
  86 struct draw_ctx {
  87     GdkGC *gc;
  88     struct gui_data *inst;
  89 };
  90
  91 static int send_raw_mouse;
  92
  93 static char *app_name = "pterm";
  94
  95 char *x_get_default(const char *key)
  96 {
  97     return XGetDefault(GDK_DISPLAY(), app_name, key);
  98 }
  99
 100 void connection_fatal(void *frontend, char *p, ...)
 101 {
 102     struct gui_data *inst = (struct gui_data *)frontend;
 103
 104     va_list ap;
 105     char *msg;
 106     va_start(ap, p);
 107     msg = dupvprintf(p, ap);
 108     va_end(ap);
 109     inst->exited = TRUE;
 110     fatal_message_box(inst->window, msg);
 111     sfree(msg);
 112     if (inst->cfg.close_on_exit == FORCE_ON)
 113         cleanup_exit(1);
 114 }
 115
 116 /*
 117  * Default settings that are specific to pterm.
 118  */
 119 FontSpec platform_default_fontspec(const char *name)
 120 {
 121     FontSpec ret;
 122     if (!strcmp(name, "Font"))
 123         strcpy(ret.name, "fixed");
 124     else
 125         *ret.name = '\0';
 126     return ret;
 127 }
 128
 129 Filename platform_default_filename(const char *name)
 130 {
 131     Filename ret;
 132     if (!strcmp(name, "LogFileName"))
 133         strcpy(ret.path, "putty.log");
 134     else
 135         *ret.path = '\0';
 136     return ret;
 137 }
 138
 139 char *platform_default_s(const char *name)
 140 {
 141     return NULL;
 142 }
 143
 144 int platform_default_i(const char *name, int def)
 145 {
 146     if (!strcmp(name, "CloseOnExit"))
 147         return 2;  /* maps to FORCE_ON after painful rearrangement :-( */
 148     if (!strcmp(name, "WinNameAlways"))
 149         return 0;  /* X natively supports icon titles, so use 'em by default */
 150     return def;
 151 }
 152
 153 void ldisc_update(void *frontend, int echo, int edit)
 154 {
 155     /*
 156      * This is a stub in pterm. If I ever produce a Unix
 157      * command-line ssh/telnet/rlogin client (i.e. a port of plink)
 158      * then it will require some termios manoeuvring analogous to
 159      * that in the Windows plink.c, but here it's meaningless.
 160      */
 161 }
 162
 163 int from_backend(void *frontend, int is_stderr, const char *data, int len)
 164 {
 165     struct gui_data *inst = (struct gui_data *)frontend;
 166     return term_data(inst->term, is_stderr, data, len);
 167 }
 168
 169 void logevent(void *frontend, const char *string)
 170 {
 171     struct gui_data *inst = (struct gui_data *)frontend;
 172
 173     log_eventlog(inst->logctx, string);
 174
 175     logevent_dlg(inst->eventlogstuff, string);
 176 }
 177
 178 int font_dimension(void *frontend, int which)/* 0 for width, 1 for height */
 179 {
 180     struct gui_data *inst = (struct gui_data *)frontend;
 181
 182     if (which)
 183         return inst->font_height;
 184     else
 185         return inst->font_width;
 186 }
 187
 188 /*
 189  * Translate a raw mouse button designation (LEFT, MIDDLE, RIGHT)
 190  * into a cooked one (SELECT, EXTEND, PASTE).
 191  *
 192  * In Unix, this is not configurable; the X button arrangement is
 193  * rock-solid across all applications, everyone has a three-button
 194  * mouse or a means of faking it, and there is no need to switch
 195  * buttons around at all.
 196  */
 197 static Mouse_Button translate_button(Mouse_Button button)
 198 {
 199     /* struct gui_data *inst = (struct gui_data *)frontend; */
 200
 201     if (button == MBT_LEFT)
 202         return MBT_SELECT;
 203     if (button == MBT_MIDDLE)
 204         return MBT_PASTE;
 205     if (button == MBT_RIGHT)
 206         return MBT_EXTEND;
 207     return 0;                          /* shouldn't happen */
 208 }
 209
 210 /*
 211  * Return the top-level GtkWindow associated with a particular
 212  * front end instance.
 213  */
 214 void *get_window(void *frontend)
 215 {
 216     struct gui_data *inst = (struct gui_data *)frontend;
 217     return inst->window;
 218 }
 219
 220 /*
 221  * Minimise or restore the window in response to a server-side
 222  * request.
 223  */
 224 void set_iconic(void *frontend, int iconic)
 225 {
 226     /*
 227      * GTK 1.2 doesn't know how to do this.
 228      */
 229 #if GTK_CHECK_VERSION(2,0,0)
 230     struct gui_data *inst = (struct gui_data *)frontend;
 231     if (iconic)
 232         gtk_window_iconify(GTK_WINDOW(inst->window));
 233     else
 234         gtk_window_deiconify(GTK_WINDOW(inst->window));
 235 #endif
 236 }
 237
 238 /*
 239  * Move the window in response to a server-side request.
 240  */
 241 void move_window(void *frontend, int x, int y)
 242 {
 243     struct gui_data *inst = (struct gui_data *)frontend;
 244     /*
 245      * I assume that when the GTK version of this call is available
 246      * we should use it. Not sure how it differs from the GDK one,
 247      * though.
 248      */
 249 #if GTK_CHECK_VERSION(2,0,0)
 250     gtk_window_move(GTK_WINDOW(inst->window), x, y);
 251 #else
 252     gdk_window_move(inst->window->window, x, y);
 253 #endif
 254 }
 255
 256 /*
 257  * Move the window to the top or bottom of the z-order in response
 258  * to a server-side request.
 259  */
 260 void set_zorder(void *frontend, int top)
 261 {
 262     struct gui_data *inst = (struct gui_data *)frontend;
 263     if (top)
 264         gdk_window_raise(inst->window->window);
 265     else
 266         gdk_window_lower(inst->window->window);
 267 }
 268
 269 /*
 270  * Refresh the window in response to a server-side request.
 271  */
 272 void refresh_window(void *frontend)
 273 {
 274     struct gui_data *inst = (struct gui_data *)frontend;
 275     term_invalidate(inst->term);
 276 }
 277
 278 /*
 279  * Maximise or restore the window in response to a server-side
 280  * request.
 281  */
 282 void set_zoomed(void *frontend, int zoomed)
 283 {
 284     /*
 285      * GTK 1.2 doesn't know how to do this.
 286      */
 287 #if GTK_CHECK_VERSION(2,0,0)
 288     struct gui_data *inst = (struct gui_data *)frontend;
 289     if (iconic)
 290         gtk_window_maximize(GTK_WINDOW(inst->window));
 291     else
 292         gtk_window_unmaximize(GTK_WINDOW(inst->window));
 293 #endif
 294 }
 295
 296 /*
 297  * Report whether the window is iconic, for terminal reports.
 298  */
 299 int is_iconic(void *frontend)
 300 {
 301     struct gui_data *inst = (struct gui_data *)frontend;
 302     return !gdk_window_is_viewable(inst->window->window);
 303 }
 304
 305 /*
 306  * Report the window's position, for terminal reports.
 307  */
 308 void get_window_pos(void *frontend, int *x, int *y)
 309 {
 310     struct gui_data *inst = (struct gui_data *)frontend;
 311     /*
 312      * I assume that when the GTK version of this call is available
 313      * we should use it. Not sure how it differs from the GDK one,
 314      * though.
 315      */
 316 #if GTK_CHECK_VERSION(2,0,0)
 317     gtk_window_get_position(GTK_WINDOW(inst->window), x, y);
 318 #else
 319     gdk_window_get_position(inst->window->window, x, y);
 320 #endif
 321 }
 322
 323 /*
 324  * Report the window's pixel size, for terminal reports.
 325  */
 326 void get_window_pixels(void *frontend, int *x, int *y)
 327 {
 328     struct gui_data *inst = (struct gui_data *)frontend;
 329     /*
 330      * I assume that when the GTK version of this call is available
 331      * we should use it. Not sure how it differs from the GDK one,
 332      * though.
 333      */
 334 #if GTK_CHECK_VERSION(2,0,0)
 335     gtk_window_get_size(GTK_WINDOW(inst->window), x, y);
 336 #else
 337     gdk_window_get_size(inst->window->window, x, y);
 338 #endif
 339 }
 340
 341 /*
 342  * Return the window or icon title.
 343  */
 344 char *get_window_title(void *frontend, int icon)
 345 {
 346     struct gui_data *inst = (struct gui_data *)frontend;
 347     return icon ? inst->wintitle : inst->icontitle;
 348 }
 349
 350 gint delete_window(GtkWidget *widget, GdkEvent *event, gpointer data)
 351 {
 352     struct gui_data *inst = (struct gui_data *)data;
 353     if (!inst->exited && inst->cfg.warn_on_close) {
 354         if (!reallyclose(inst))
 355             return TRUE;
 356     }
 357     return FALSE;
 358 }
 359
 360 static void show_mouseptr(struct gui_data *inst, int show)
 361 {
 362     if (!inst->cfg.hide_mouseptr)
 363         show = 1;
 364     if (show)
 365         gdk_window_set_cursor(inst->area->window, inst->currcursor);
 366     else
 367         gdk_window_set_cursor(inst->area->window, inst->blankcursor);
 368     inst->mouseptr_visible = show;
 369 }
 370
 371 gint configure_area(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
 372 {
 373     struct gui_data *inst = (struct gui_data *)data;
 374     int w, h, need_size = 0;
 375     GdkGC *gc;
 376
 377     /*
 378      * See if the terminal size has changed, in which case we must
 379      * let the terminal know.
 380      */
 381     w = (event->width - 2*inst->cfg.window_border) / inst->font_width;
 382     h = (event->height - 2*inst->cfg.window_border) / inst->font_height;
 383     if (w != inst->width || h != inst->height) {
 384         inst->cfg.width = inst->width = w;
 385         inst->cfg.height = inst->height = h;
 386         need_size = 1;
 387     }
 388
 389     if (inst->pixmap) {
 390         gdk_pixmap_unref(inst->pixmap);
 391         inst->pixmap = NULL;
 392     }
 393
 394     inst->pixmap = gdk_pixmap_new(widget->window,
 395                                   (inst->cfg.width * inst->font_width +
 396                                    2*inst->cfg.window_border),
 397                                   (inst->cfg.height * inst->font_height +
 398                                    2*inst->cfg.window_border), -1);
 399
 400     gc = gdk_gc_new(inst->area->window);
 401     gdk_gc_set_foreground(gc, &inst->cols[18]);   /* default background */
 402     gdk_draw_rectangle(inst->pixmap, gc, 1, 0, 0,
 403                        inst->cfg.width * inst->font_width + 2*inst->cfg.window_border,
 404                        inst->cfg.height * inst->font_height + 2*inst->cfg.window_border);
 405     gdk_gc_unref(gc);
 406
 407     if (need_size && inst->term) {
 408         term_size(inst->term, h, w, inst->cfg.savelines);
 409     }
 410
 411     if (inst->term)
 412         term_invalidate(inst->term);
 413
 414     return TRUE;
 415 }
 416
 417 gint expose_area(GtkWidget *widget, GdkEventExpose *event, gpointer data)
 418 {
 419     struct gui_data *inst = (struct gui_data *)data;
 420
 421     /*
 422      * Pass the exposed rectangle to terminal.c, which will call us
 423      * back to do the actual painting.
 424      */
 425     if (inst->pixmap) {
 426         gdk_draw_pixmap(widget->window,
 427                         widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 428                         inst->pixmap,
 429                         event->area.x, event->area.y,
 430                         event->area.x, event->area.y,
 431                         event->area.width, event->area.height);
 432     }
 433     return TRUE;
 434 }
 435
 436 #define KEY_PRESSED(k) \
 437     (inst->keystate[(k) / 32] & (1 << ((k) % 32)))
 438
 439 gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 440 {
 441     struct gui_data *inst = (struct gui_data *)data;
 442     char output[32];
 443     wchar_t ucsoutput[2];
 444     int ucsval, start, end, special, use_ucsoutput;
 445
 446     /* By default, nothing is generated. */
 447     end = start = 0;
 448     special = use_ucsoutput = FALSE;
 449
 450     /*
 451      * If Alt is being released after typing an Alt+numberpad
 452      * sequence, we should generate the code that was typed.
 453      *
 454      * Note that we only do this if more than one key was actually
 455      * pressed - I don't think Alt+NumPad4 should be ^D or that
 456      * Alt+NumPad3 should be ^C, for example. There's no serious
 457      * inconvenience in having to type a zero before a single-digit
 458      * character code.
 459      */
 460     if (event->type == GDK_KEY_RELEASE &&
 461         (event->keyval == GDK_Meta_L || event->keyval == GDK_Alt_L ||
 462          event->keyval == GDK_Meta_R || event->keyval == GDK_Alt_R) &&
 463         inst->alt_keycode >= 0 && inst->alt_digits > 1) {
 464 #ifdef KEY_DEBUGGING
 465         printf("Alt key up, keycode = %d\n", inst->alt_keycode);
 466 #endif
 467         output[0] = inst->alt_keycode;
 468         end = 1;
 469         goto done;
 470     }
 471
 472     if (event->type == GDK_KEY_PRESS) {
 473 #ifdef KEY_DEBUGGING
 474         {
 475             int i;
 476             printf("keypress: keyval = %04x, state = %08x; string =",
 477                    event->keyval, event->state);
 478             for (i = 0; event->string[i]; i++)
 479                 printf(" %02x", (unsigned char) event->string[i]);
 480             printf("\n");
 481         }
 482 #endif
 483
 484         /*
 485          * NYI: Compose key (!!! requires Unicode faff before even trying)
 486          */
 487
 488         /*
 489          * If Alt has just been pressed, we start potentially
 490          * accumulating an Alt+numberpad code. We do this by
 491          * setting alt_keycode to -1 (nothing yet but plausible).
 492          */
 493         if ((event->keyval == GDK_Meta_L || event->keyval == GDK_Alt_L ||
 494              event->keyval == GDK_Meta_R || event->keyval == GDK_Alt_R)) {
 495             inst->alt_keycode = -1;
 496             inst->alt_digits = 0;
 497             goto done;                 /* this generates nothing else */
 498         }
 499
 500         /*
 501          * If we're seeing a numberpad key press with Mod1 down,
 502          * consider adding it to alt_keycode if that's sensible.
 503          * Anything _else_ with Mod1 down cancels any possibility
 504          * of an ALT keycode: we set alt_keycode to -2.
 505          */
 506         if ((event->state & GDK_MOD1_MASK) && inst->alt_keycode != -2) {
 507             int digit = -1;
 508             switch (event->keyval) {
 509               case GDK_KP_0: case GDK_KP_Insert: digit = 0; break;
 510               case GDK_KP_1: case GDK_KP_End: digit = 1; break;
 511               case GDK_KP_2: case GDK_KP_Down: digit = 2; break;
 512               case GDK_KP_3: case GDK_KP_Page_Down: digit = 3; break;
 513               case GDK_KP_4: case GDK_KP_Left: digit = 4; break;
 514               case GDK_KP_5: case GDK_KP_Begin: digit = 5; break;
 515               case GDK_KP_6: case GDK_KP_Right: digit = 6; break;
 516               case GDK_KP_7: case GDK_KP_Home: digit = 7; break;
 517               case GDK_KP_8: case GDK_KP_Up: digit = 8; break;
 518               case GDK_KP_9: case GDK_KP_Page_Up: digit = 9; break;
 519             }
 520             if (digit < 0)
 521                 inst->alt_keycode = -2;   /* it's invalid */
 522             else {
 523 #ifdef KEY_DEBUGGING
 524                 printf("Adding digit %d to keycode %d", digit,
 525                        inst->alt_keycode);
 526 #endif
 527                 if (inst->alt_keycode == -1)
 528                     inst->alt_keycode = digit;   /* one-digit code */
 529                 else
 530                     inst->alt_keycode = inst->alt_keycode * 10 + digit;
 531                 inst->alt_digits++;
 532 #ifdef KEY_DEBUGGING
 533                 printf(" gives new code %d\n", inst->alt_keycode);
 534 #endif
 535                 /* Having used this digit, we now do nothing more with it. */
 536                 goto done;
 537             }
 538         }
 539
 540         /*
 541          * Shift-PgUp and Shift-PgDn don't even generate keystrokes
 542          * at all.
 543          */
 544         if (event->keyval == GDK_Page_Up && (event->state & GDK_SHIFT_MASK)) {
 545             term_scroll(inst->term, 0, -inst->cfg.height/2);
 546             return TRUE;
 547         }
 548         if (event->keyval == GDK_Page_Up && (event->state & GDK_CONTROL_MASK)) {
 549             term_scroll(inst->term, 0, -1);
 550             return TRUE;
 551         }
 552         if (event->keyval == GDK_Page_Down && (event->state & GDK_SHIFT_MASK)) {
 553             term_scroll(inst->term, 0, +inst->cfg.height/2);
 554             return TRUE;
 555         }
 556         if (event->keyval == GDK_Page_Down && (event->state & GDK_CONTROL_MASK)) {
 557             term_scroll(inst->term, 0, +1);
 558             return TRUE;
 559         }
 560
 561         /*
 562          * Neither does Shift-Ins.
 563          */
 564         if (event->keyval == GDK_Insert && (event->state & GDK_SHIFT_MASK)) {
 565             request_paste(inst);
 566             return TRUE;
 567         }
 568
 569         special = FALSE;
 570         use_ucsoutput = FALSE;
 571
 572         /* ALT+things gives leading Escape. */
 573         output[0] = '\033';
 574         strncpy(output+1, event->string, 31);
 575         if (!*event->string &&
 576             (ucsval = keysym_to_unicode(event->keyval)) >= 0) {
 577             ucsoutput[0] = '\033';
 578             ucsoutput[1] = ucsval;
 579             use_ucsoutput = TRUE;
 580             end = 2;
 581         } else {
 582             output[31] = '\0';
 583             end = strlen(output);
 584         }
 585         if (event->state & GDK_MOD1_MASK) {
 586             start = 0;
 587             if (end == 1) end = 0;
 588         } else
 589             start = 1;
 590
 591         /* Control-` is the same as Control-\ (unless gtk has a better idea) */
 592         if (!event->string[0] && event->keyval == '`' &&
 593             (event->state & GDK_CONTROL_MASK)) {
 594             output[1] = '\x1C';
 595             use_ucsoutput = FALSE;
 596             end = 2;
 597         }
 598
 599         /* Control-Break is the same as Control-C */
 600         if (event->keyval == GDK_Break &&
 601             (event->state & GDK_CONTROL_MASK)) {
 602             output[1] = '\003';
 603             use_ucsoutput = FALSE;
 604             end = 2;
 605             special = TRUE;
 606         }
 607
 608         /* We handle Return ourselves, because it needs to be flagged as
 609          * special to ldisc. */
 610         if (event->keyval == GDK_Return) {
 611             output[1] = '\015';
 612             use_ucsoutput = FALSE;
 613             end = 2;
 614             special = TRUE;
 615         }
 616
 617         /* Control-2, Control-Space and Control-@ are NUL */
 618         if (!event->string[0] &&
 619             (event->keyval == ' ' || event->keyval == '2' ||
 620              event->keyval == '@') &&
 621             (event->state & (GDK_SHIFT_MASK |
 622                              GDK_CONTROL_MASK)) == GDK_CONTROL_MASK) {
 623             output[1] = '\0';
 624             use_ucsoutput = FALSE;
 625             end = 2;
 626         }
 627
 628         /* Control-Shift-Space is 160 (ISO8859 nonbreaking space) */
 629         if (!event->string[0] && event->keyval == ' ' &&
 630             (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) ==
 631             (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) {
 632             output[1] = '\240';
 633             use_ucsoutput = FALSE;
 634             end = 2;
 635         }
 636
 637         /* We don't let GTK tell us what Backspace is! We know better. */
 638         if (event->keyval == GDK_BackSpace &&
 639             !(event->state & GDK_SHIFT_MASK)) {
 640             output[1] = inst->cfg.bksp_is_delete ? '\x7F' : '\x08';
 641             use_ucsoutput = FALSE;
 642             end = 2;
 643             special = TRUE;
 644         }
 645         /* For Shift Backspace, do opposite of what is configured. */
 646         if (event->keyval == GDK_BackSpace &&
 647             (event->state & GDK_SHIFT_MASK)) {
 648             output[1] = inst->cfg.bksp_is_delete ? '\x08' : '\x7F';
 649             use_ucsoutput = FALSE;
 650             end = 2;
 651             special = TRUE;
 652         }
 653
 654         /* Shift-Tab is ESC [ Z */
 655         if (event->keyval == GDK_ISO_Left_Tab ||
 656             (event->keyval == GDK_Tab && (event->state & GDK_SHIFT_MASK))) {
 657             end = 1 + sprintf(output+1, "\033[Z");
 658             use_ucsoutput = FALSE;
 659         }
 660
 661         /*
 662          * NetHack keypad mode.
 663          */
 664         if (inst->cfg.nethack_keypad) {
 665             char *keys = NULL;
 666             switch (event->keyval) {
 667               case GDK_KP_1: case GDK_KP_End: keys = "bB"; break;
 668               case GDK_KP_2: case GDK_KP_Down: keys = "jJ"; break;
 669               case GDK_KP_3: case GDK_KP_Page_Down: keys = "nN"; break;
 670               case GDK_KP_4: case GDK_KP_Left: keys = "hH"; break;
 671               case GDK_KP_5: case GDK_KP_Begin: keys = ".."; break;
 672               case GDK_KP_6: case GDK_KP_Right: keys = "lL"; break;
 673               case GDK_KP_7: case GDK_KP_Home: keys = "yY"; break;
 674               case GDK_KP_8: case GDK_KP_Up: keys = "kK"; break;
 675               case GDK_KP_9: case GDK_KP_Page_Up: keys = "uU"; break;
 676             }
 677             if (keys) {
 678                 end = 2;
 679                 if (event->state & GDK_SHIFT_MASK)
 680                     output[1] = keys[1];
 681                 else
 682                     output[1] = keys[0];
 683                 use_ucsoutput = FALSE;
 684                 goto done;
 685             }
 686         }
 687
 688         /*
 689          * Application keypad mode.
 690          */
 691         if (inst->term->app_keypad_keys && !inst->cfg.no_applic_k) {
 692             int xkey = 0;
 693             switch (event->keyval) {
 694               case GDK_Num_Lock: xkey = 'P'; break;
 695               case GDK_KP_Divide: xkey = 'Q'; break;
 696               case GDK_KP_Multiply: xkey = 'R'; break;
 697               case GDK_KP_Subtract: xkey = 'S'; break;
 698                 /*
 699                  * Keypad + is tricky. It covers a space that would
 700                  * be taken up on the VT100 by _two_ keys; so we
 701                  * let Shift select between the two. Worse still,
 702                  * in xterm function key mode we change which two...
 703                  */
 704               case GDK_KP_Add:
 705                 if (inst->cfg.funky_type == 2) {
 706                     if (event->state & GDK_SHIFT_MASK)
 707                         xkey = 'l';
 708                     else
 709                         xkey = 'k';
 710                 } else if (event->state & GDK_SHIFT_MASK)
 711                         xkey = 'm';
 712                 else
 713                     xkey = 'l';
 714                 break;
 715               case GDK_KP_Enter: xkey = 'M'; break;
 716               case GDK_KP_0: case GDK_KP_Insert: xkey = 'p'; break;
 717               case GDK_KP_1: case GDK_KP_End: xkey = 'q'; break;
 718               case GDK_KP_2: case GDK_KP_Down: xkey = 'r'; break;
 719               case GDK_KP_3: case GDK_KP_Page_Down: xkey = 's'; break;
 720               case GDK_KP_4: case GDK_KP_Left: xkey = 't'; break;
 721               case GDK_KP_5: case GDK_KP_Begin: xkey = 'u'; break;
 722               case GDK_KP_6: case GDK_KP_Right: xkey = 'v'; break;
 723               case GDK_KP_7: case GDK_KP_Home: xkey = 'w'; break;
 724               case GDK_KP_8: case GDK_KP_Up: xkey = 'x'; break;
 725               case GDK_KP_9: case GDK_KP_Page_Up: xkey = 'y'; break;
 726               case GDK_KP_Decimal: case GDK_KP_Delete: xkey = 'n'; break;
 727             }
 728             if (xkey) {
 729                 if (inst->term->vt52_mode) {
 730                     if (xkey >= 'P' && xkey <= 'S')
 731                         end = 1 + sprintf(output+1, "\033%c", xkey);
 732                     else
 733                         end = 1 + sprintf(output+1, "\033?%c", xkey);
 734                 } else
 735                     end = 1 + sprintf(output+1, "\033O%c", xkey);
 736                 use_ucsoutput = FALSE;
 737                 goto done;
 738             }
 739         }
 740
 741         /*
 742          * Next, all the keys that do tilde codes. (ESC '[' nn '~',
 743          * for integer decimal nn.)
 744          *
 745          * We also deal with the weird ones here. Linux VCs replace F1
 746          * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
 747          * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
 748          * respectively.
 749          */
 750         {
 751             int code = 0;
 752             switch (event->keyval) {
 753               case GDK_F1:
 754                 code = (event->state & GDK_SHIFT_MASK ? 23 : 11);
 755                 break;
 756               case GDK_F2:
 757                 code = (event->state & GDK_SHIFT_MASK ? 24 : 12);
 758                 break;
 759               case GDK_F3:
 760                 code = (event->state & GDK_SHIFT_MASK ? 25 : 13);
 761                 break;
 762               case GDK_F4:
 763                 code = (event->state & GDK_SHIFT_MASK ? 26 : 14);
 764                 break;
 765               case GDK_F5:
 766                 code = (event->state & GDK_SHIFT_MASK ? 28 : 15);
 767                 break;
 768               case GDK_F6:
 769                 code = (event->state & GDK_SHIFT_MASK ? 29 : 17);
 770                 break;
 771               case GDK_F7:
 772                 code = (event->state & GDK_SHIFT_MASK ? 31 : 18);
 773                 break;
 774               case GDK_F8:
 775                 code = (event->state & GDK_SHIFT_MASK ? 32 : 19);
 776                 break;
 777               case GDK_F9:
 778                 code = (event->state & GDK_SHIFT_MASK ? 33 : 20);
 779                 break;
 780               case GDK_F10:
 781                 code = (event->state & GDK_SHIFT_MASK ? 34 : 21);
 782                 break;
 783               case GDK_F11:
 784                 code = 23;
 785                 break;
 786               case GDK_F12:
 787                 code = 24;
 788                 break;
 789               case GDK_F13:
 790                 code = 25;
 791                 break;
 792               case GDK_F14:
 793                 code = 26;
 794                 break;
 795               case GDK_F15:
 796                 code = 28;
 797                 break;
 798               case GDK_F16:
 799                 code = 29;
 800                 break;
 801               case GDK_F17:
 802                 code = 31;
 803                 break;
 804               case GDK_F18:
 805                 code = 32;
 806                 break;
 807               case GDK_F19:
 808                 code = 33;
 809                 break;
 810               case GDK_F20:
 811                 code = 34;
 812                 break;
 813             }
 814             if (!(event->state & GDK_CONTROL_MASK)) switch (event->keyval) {
 815               case GDK_Home: case GDK_KP_Home:
 816                 code = 1;
 817                 break;
 818               case GDK_Insert: case GDK_KP_Insert:
 819                 code = 2;
 820                 break;
 821               case GDK_Delete: case GDK_KP_Delete:
 822                 code = 3;
 823                 break;
 824               case GDK_End: case GDK_KP_End:
 825                 code = 4;
 826                 break;
 827               case GDK_Page_Up: case GDK_KP_Page_Up:
 828                 code = 5;
 829                 break;
 830               case GDK_Page_Down: case GDK_KP_Page_Down:
 831                 code = 6;
 832                 break;
 833             }
 834             /* Reorder edit keys to physical order */
 835             if (inst->cfg.funky_type == 3 && code <= 6)
 836                 code = "\0\2\1\4\5\3\6"[code];
 837
 838             if (inst->term->vt52_mode && code > 0 && code <= 6) {
 839                 end = 1 + sprintf(output+1, "\x1B%c", " HLMEIG"[code]);
 840                 use_ucsoutput = FALSE;
 841                 goto done;
 842             }
 843
 844             if (inst->cfg.funky_type == 5 &&     /* SCO function keys */
 845                 code >= 11 && code <= 34) {
 846                 char codes[] = "MNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@[\\]^_`{";
 847                 int index = 0;
 848                 switch (event->keyval) {
 849                   case GDK_F1: index = 0; break;
 850                   case GDK_F2: index = 1; break;
 851                   case GDK_F3: index = 2; break;
 852                   case GDK_F4: index = 3; break;
 853                   case GDK_F5: index = 4; break;
 854                   case GDK_F6: index = 5; break;
 855                   case GDK_F7: index = 6; break;
 856                   case GDK_F8: index = 7; break;
 857                   case GDK_F9: index = 8; break;
 858                   case GDK_F10: index = 9; break;
 859                   case GDK_F11: index = 10; break;
 860                   case GDK_F12: index = 11; break;
 861                 }
 862                 if (event->state & GDK_SHIFT_MASK) index += 12;
 863                 if (event->state & GDK_CONTROL_MASK) index += 24;
 864                 end = 1 + sprintf(output+1, "\x1B[%c", codes[index]);
 865                 use_ucsoutput = FALSE;
 866                 goto done;
 867             }
 868             if (inst->cfg.funky_type == 5 &&     /* SCO small keypad */
 869                 code >= 1 && code <= 6) {
 870                 char codes[] = "HL.FIG";
 871                 if (code == 3) {
 872                     output[1] = '\x7F';
 873                     end = 2;
 874                 } else {
 875                     end = 1 + sprintf(output+1, "\x1B[%c", codes[code-1]);
 876                 }
 877                 use_ucsoutput = FALSE;
 878                 goto done;
 879             }
 880             if ((inst->term->vt52_mode || inst->cfg.funky_type == 4) &&
 881                 code >= 11 && code <= 24) {
 882                 int offt = 0;
 883                 if (code > 15)
 884                     offt++;
 885                 if (code > 21)
 886                     offt++;
 887                 if (inst->term->vt52_mode)
 888                     end = 1 + sprintf(output+1,
 889                                       "\x1B%c", code + 'P' - 11 - offt);
 890                 else
 891                     end = 1 + sprintf(output+1,
 892                                       "\x1BO%c", code + 'P' - 11 - offt);
 893                 use_ucsoutput = FALSE;
 894                 goto done;
 895             }
 896             if (inst->cfg.funky_type == 1 && code >= 11 && code <= 15) {
 897                 end = 1 + sprintf(output+1, "\x1B[[%c", code + 'A' - 11);
 898                 use_ucsoutput = FALSE;
 899                 goto done;
 900             }
 901             if (inst->cfg.funky_type == 2 && code >= 11 && code <= 14) {
 902                 if (inst->term->vt52_mode)
 903                     end = 1 + sprintf(output+1, "\x1B%c", code + 'P' - 11);
 904                 else
 905                     end = 1 + sprintf(output+1, "\x1BO%c", code + 'P' - 11);
 906                 use_ucsoutput = FALSE;
 907                 goto done;
 908             }
 909             if (inst->cfg.rxvt_homeend && (code == 1 || code == 4)) {
 910                 end = 1 + sprintf(output+1, code == 1 ? "\x1B[H" : "\x1BOw");
 911                 use_ucsoutput = FALSE;
 912                 goto done;
 913             }
 914             if (code) {
 915                 end = 1 + sprintf(output+1, "\x1B[%d~", code);
 916                 use_ucsoutput = FALSE;
 917                 goto done;
 918             }
 919         }
 920
 921         /*
 922          * Cursor keys. (This includes the numberpad cursor keys,
 923          * if we haven't already done them due to app keypad mode.)
 924          *
 925          * Here we also process un-numlocked un-appkeypadded KP5,
 926          * which sends ESC [ G.
 927          */
 928         {
 929             int xkey = 0;
 930             switch (event->keyval) {
 931               case GDK_Up: case GDK_KP_Up: xkey = 'A'; break;
 932               case GDK_Down: case GDK_KP_Down: xkey = 'B'; break;
 933               case GDK_Right: case GDK_KP_Right: xkey = 'C'; break;
 934               case GDK_Left: case GDK_KP_Left: xkey = 'D'; break;
 935               case GDK_Begin: case GDK_KP_Begin: xkey = 'G'; break;
 936             }
 937             if (xkey) {
 938                 /*
 939                  * The arrow keys normally do ESC [ A and so on. In
 940                  * app cursor keys mode they do ESC O A instead.
 941                  * Ctrl toggles the two modes.
 942                  */
 943                 if (inst->term->vt52_mode) {
 944                     end = 1 + sprintf(output+1, "\033%c", xkey);
 945                 } else if (!inst->term->app_cursor_keys ^
 946                            !(event->state & GDK_CONTROL_MASK)) {
 947                     end = 1 + sprintf(output+1, "\033O%c", xkey);
 948                 } else {
 949                     end = 1 + sprintf(output+1, "\033[%c", xkey);
 950                 }
 951                 use_ucsoutput = FALSE;
 952                 goto done;
 953             }
 954         }
 955         goto done;
 956     }
 957
 958     done:
 959
 960     if (end-start > 0) {
 961 #ifdef KEY_DEBUGGING
 962         int i;
 963         printf("generating sequence:");
 964         for (i = start; i < end; i++)
 965             printf(" %02x", (unsigned char) output[i]);
 966         printf("\n");
 967 #endif
 968
 969         if (special) {
 970             /*
 971              * For special control characters, the character set
 972              * should never matter.
 973              */
 974             output[end] = '\0';        /* NUL-terminate */
 975             ldisc_send(inst->ldisc, output+start, -2, 1);
 976         } else if (!inst->direct_to_font) {
 977             if (!use_ucsoutput) {
 978                 /*
 979                  * The stuff we've just generated is assumed to be
 980                  * ISO-8859-1! This sounds insane, but `man
 981                  * XLookupString' agrees: strings of this type
 982                  * returned from the X server are hardcoded to
 983                  * 8859-1. Strictly speaking we should be doing
 984                  * this using some sort of GtkIMContext, which (if
 985                  * we're lucky) would give us our data directly in
 986                  * Unicode; but that's not supported in GTK 1.2 as
 987                  * far as I can tell, and it's poorly documented
 988                  * even in 2.0, so it'll have to wait.
 989                  */
 990                 lpage_send(inst->ldisc, CS_ISO8859_1, output+start,
 991                            end-start, 1);
 992             } else {
 993                 /*
 994                  * We generated our own Unicode key data from the
 995                  * keysym, so use that instead.
 996                  */
 997                 luni_send(inst->ldisc, ucsoutput+start, end-start, 1);
 998             }
 999         } else {
1000             /*
1001              * In direct-to-font mode, we just send the string
1002              * exactly as we received it.
1003              */
1004             ldisc_send(inst->ldisc, output+start, end-start, 1);
1005         }
1006
1007         show_mouseptr(inst, 0);
1008         term_seen_key_event(inst->term);
1009         term_out(inst->term);
1010     }
1011
1012     return TRUE;
1013 }
1014
1015 gint button_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
1016 {
1017     struct gui_data *inst = (struct gui_data *)data;
1018     int shift, ctrl, alt, x, y, button, act;
1019
1020     show_mouseptr(inst, 1);
1021
1022     if (event->button == 4 && event->type == GDK_BUTTON_PRESS) {
1023         term_scroll(inst->term, 0, -5);
1024         return TRUE;
1025     }
1026     if (event->button == 5 && event->type == GDK_BUTTON_PRESS) {
1027         term_scroll(inst->term, 0, +5);
1028         return TRUE;
1029     }
1030
1031     shift = event->state & GDK_SHIFT_MASK;
1032     ctrl = event->state & GDK_CONTROL_MASK;
1033     alt = event->state & GDK_MOD1_MASK;
1034
1035     if (event->button == 3 && ctrl) {
1036         gtk_menu_popup(GTK_MENU(inst->menu), NULL, NULL, NULL, NULL,
1037                        event->button, event->time);
1038         return TRUE;
1039     }
1040
1041     if (event->button == 1)
1042         button = MBT_LEFT;
1043     else if (event->button == 2)
1044         button = MBT_MIDDLE;
1045     else if (event->button == 3)
1046         button = MBT_RIGHT;
1047     else
1048         return FALSE;                  /* don't even know what button! */
1049
1050     switch (event->type) {
1051       case GDK_BUTTON_PRESS: act = MA_CLICK; break;
1052       case GDK_BUTTON_RELEASE: act = MA_RELEASE; break;
1053       case GDK_2BUTTON_PRESS: act = MA_2CLK; break;
1054       case GDK_3BUTTON_PRESS: act = MA_3CLK; break;
1055       default: return FALSE;           /* don't know this event type */
1056     }
1057
1058     if (send_raw_mouse && !(inst->cfg.mouse_override && shift) &&
1059         act != MA_CLICK && act != MA_RELEASE)
1060         return TRUE;                   /* we ignore these in raw mouse mode */
1061
1062     x = (event->x - inst->cfg.window_border) / inst->font_width;
1063     y = (event->y - inst->cfg.window_border) / inst->font_height;
1064
1065     term_mouse(inst->term, button, translate_button(button), act,
1066                x, y, shift, ctrl, alt);
1067
1068     return TRUE;
1069 }
1070
1071 gint motion_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)
1072 {
1073     struct gui_data *inst = (struct gui_data *)data;
1074     int shift, ctrl, alt, x, y, button;
1075
1076     show_mouseptr(inst, 1);
1077
1078     shift = event->state & GDK_SHIFT_MASK;
1079     ctrl = event->state & GDK_CONTROL_MASK;
1080     alt = event->state & GDK_MOD1_MASK;
1081     if (event->state & GDK_BUTTON1_MASK)
1082         button = MBT_LEFT;
1083     else if (event->state & GDK_BUTTON2_MASK)
1084         button = MBT_MIDDLE;
1085     else if (event->state & GDK_BUTTON3_MASK)
1086         button = MBT_RIGHT;
1087     else
1088         return FALSE;                  /* don't even know what button! */
1089
1090     x = (event->x - inst->cfg.window_border) / inst->font_width;
1091     y = (event->y - inst->cfg.window_border) / inst->font_height;
1092
1093     term_mouse(inst->term, button, translate_button(button), MA_DRAG,
1094                x, y, shift, ctrl, alt);
1095
1096     return TRUE;
1097 }
1098
1099 void frontend_keypress(void *handle)
1100 {
1101     struct gui_data *inst = (struct gui_data *)handle;
1102
1103     /*
1104      * If our child process has exited but not closed, terminate on
1105      * any keypress.
1106      */
1107     if (inst->exited)
1108         exit(0);
1109 }
1110
1111 gint timer_func(gpointer data)
1112 {
1113     struct gui_data *inst = (struct gui_data *)data;
1114     int exitcode;
1115
1116     if (!inst->exited &&
1117         (exitcode = inst->back->exitcode(inst->backhandle)) >= 0) {
1118         inst->exited = TRUE;
1119         if (inst->cfg.close_on_exit == FORCE_ON ||
1120             (inst->cfg.close_on_exit == AUTO && exitcode == 0))
1121             exit(0);                   /* just go. */
1122     }
1123
1124     term_update(inst->term);
1125     term_blink(inst->term, 0);
1126     return TRUE;
1127 }
1128
1129 void fd_input_func(gpointer data, gint sourcefd, GdkInputCondition condition)
1130 {
1131     /*
1132      * We must process exceptional notifications before ordinary
1133      * readability ones, or we may go straight past the urgent
1134      * marker.
1135      */
1136     if (condition & GDK_INPUT_EXCEPTION)
1137         select_result(sourcefd, 4);
1138     if (condition & GDK_INPUT_READ)
1139         select_result(sourcefd, 1);
1140     if (condition & GDK_INPUT_WRITE)
1141         select_result(sourcefd, 2);
1142 }
1143
1144 void destroy(GtkWidget *widget, gpointer data)
1145 {
1146     gtk_main_quit();
1147 }
1148
1149 gint focus_event(GtkWidget *widget, GdkEventFocus *event, gpointer data)
1150 {
1151     struct gui_data *inst = (struct gui_data *)data;
1152     inst->term->has_focus = event->in;
1153     term_out(inst->term);
1154     term_update(inst->term);
1155     show_mouseptr(inst, 1);
1156     return FALSE;
1157 }
1158
1159 /*
1160  * set or clear the "raw mouse message" mode
1161  */
1162 void set_raw_mouse_mode(void *frontend, int activate)
1163 {
1164     struct gui_data *inst = (struct gui_data *)frontend;
1165     activate = activate && !inst->cfg.no_mouse_rep;
1166     send_raw_mouse = activate;
1167     if (send_raw_mouse)
1168         inst->currcursor = inst->rawcursor;
1169     else
1170         inst->currcursor = inst->textcursor;
1171     show_mouseptr(inst, inst->mouseptr_visible);
1172 }
1173
1174 void request_resize(void *frontend, int w, int h)
1175 {
1176     struct gui_data *inst = (struct gui_data *)frontend;
1177     int large_x, large_y;
1178     int offset_x, offset_y;
1179     int area_x, area_y;
1180     GtkRequisition inner, outer;
1181
1182     /*
1183      * This is a heinous hack dreamed up by the gnome-terminal
1184      * people to get around a limitation in gtk. The problem is
1185      * that in order to set the size correctly we really need to be
1186      * calling gtk_window_resize - but that needs to know the size
1187      * of the _whole window_, not the drawing area. So what we do
1188      * is to set an artificially huge size request on the drawing
1189      * area, recompute the resulting size request on the window,
1190      * and look at the difference between the two. That gives us
1191      * the x and y offsets we need to translate drawing area size
1192      * into window size for real, and then we call
1193      * gtk_window_resize.
1194      */
1195
1196     /*
1197      * We start by retrieving the current size of the whole window.
1198      * Adding a bit to _that_ will give us a value we can use as a
1199      * bogus size request which guarantees to be bigger than the
1200      * current size of the drawing area.
1201      */
1202     get_window_pixels(inst, &large_x, &large_y);
1203     large_x += 32;
1204     large_y += 32;
1205
1206 #if GTK_CHECK_VERSION(2,0,0)
1207     gtk_widget_set_size_request(inst->area, large_x, large_y);
1208 #else
1209     gtk_widget_set_usize(inst->area, large_x, large_y);
1210 #endif
1211     gtk_widget_size_request(inst->area, &inner);
1212     gtk_widget_size_request(inst->window, &outer);
1213
1214     offset_x = outer.width - inner.width;
1215     offset_y = outer.height - inner.height;
1216
1217     area_x = inst->font_width * w + 2*inst->cfg.window_border;
1218     area_y = inst->font_height * h + 2*inst->cfg.window_border;
1219
1220     /*
1221      * Now we must set the size request on the drawing area back to
1222      * something sensible before we commit the real resize. Best
1223      * way to do this, I think, is to set it to what the size is
1224      * really going to end up being.
1225      */
1226 #if GTK_CHECK_VERSION(2,0,0)
1227     gtk_widget_set_size_request(inst->area, area_x, area_y);
1228 #else
1229     gtk_widget_set_usize(inst->area, area_x, area_y);
1230     gtk_drawing_area_size(GTK_DRAWING_AREA(inst->area), area_x, area_y);
1231 #endif
1232
1233     gtk_container_dequeue_resize_handler(GTK_CONTAINER(inst->window));
1234
1235 #if GTK_CHECK_VERSION(2,0,0)
1236     gtk_window_resize(GTK_WINDOW(inst->window),
1237                       area_x + offset_x, area_y + offset_y);
1238 #else
1239     gdk_window_resize(inst->window->window,
1240                       area_x + offset_x, area_y + offset_y);
1241 #endif
1242 }
1243
1244 static void real_palette_set(struct gui_data *inst, int n, int r, int g, int b)
1245 {
1246     gboolean success[1];
1247
1248     inst->cols[n].red = r * 0x0101;
1249     inst->cols[n].green = g * 0x0101;
1250     inst->cols[n].blue = b * 0x0101;
1251
1252     gdk_colormap_free_colors(inst->colmap, inst->cols + n, 1);
1253     gdk_colormap_alloc_colors(inst->colmap, inst->cols + n, 1,
1254                               FALSE, FALSE, success);
1255     if (!success[0])
1256         g_error("%s: couldn't allocate colour %d (#%02x%02x%02x)\n", appname,
1257                 n, r, g, b);
1258 }
1259
1260 void set_window_background(struct gui_data *inst)
1261 {
1262     if (inst->area && inst->area->window)
1263         gdk_window_set_background(inst->area->window, &inst->cols[18]);
1264     if (inst->window && inst->window->window)
1265         gdk_window_set_background(inst->window->window, &inst->cols[18]);
1266 }
1267
1268 void palette_set(void *frontend, int n, int r, int g, int b)
1269 {
1270     struct gui_data *inst = (struct gui_data *)frontend;
1271     static const int first[21] = {
1272         0, 2, 4, 6, 8, 10, 12, 14,
1273         1, 3, 5, 7, 9, 11, 13, 15,
1274         16, 17, 18, 20, 22
1275     };
1276     real_palette_set(inst, first[n], r, g, b);
1277     if (first[n] >= 18)
1278         real_palette_set(inst, first[n] + 1, r, g, b);
1279     if (first[n] == 18)
1280         set_window_background(inst);
1281 }
1282
1283 void palette_reset(void *frontend)
1284 {
1285     struct gui_data *inst = (struct gui_data *)frontend;
1286     /* This maps colour indices in inst->cfg to those used in inst->cols. */
1287     static const int ww[] = {
1288         6, 7, 8, 9, 10, 11, 12, 13,
1289         14, 15, 16, 17, 18, 19, 20, 21,
1290         0, 1, 2, 3, 4, 5
1291     };
1292     gboolean success[NCOLOURS];
1293     int i;
1294
1295     assert(lenof(ww) == NCOLOURS);
1296
1297     if (!inst->colmap) {
1298         inst->colmap = gdk_colormap_get_system();
1299     } else {
1300         gdk_colormap_free_colors(inst->colmap, inst->cols, NCOLOURS);
1301     }
1302
1303     for (i = 0; i < NCOLOURS; i++) {
1304         inst->cols[i].red = inst->cfg.colours[ww[i]][0] * 0x0101;
1305         inst->cols[i].green = inst->cfg.colours[ww[i]][1] * 0x0101;
1306         inst->cols[i].blue = inst->cfg.colours[ww[i]][2] * 0x0101;
1307     }
1308
1309     gdk_colormap_alloc_colors(inst->colmap, inst->cols, NCOLOURS,
1310                               FALSE, FALSE, success);
1311     for (i = 0; i < NCOLOURS; i++) {
1312         if (!success[i])
1313             g_error("%s: couldn't allocate colour %d (#%02x%02x%02x)\n",
1314                     appname, i, inst->cfg.colours[i][0],
1315                     inst->cfg.colours[i][1], inst->cfg.colours[i][2]);
1316     }
1317
1318     set_window_background(inst);
1319 }
1320
1321 void write_clip(void *frontend, wchar_t * data, int len, int must_deselect)
1322 {
1323     struct gui_data *inst = (struct gui_data *)frontend;
1324     if (inst->pasteout_data)
1325         sfree(inst->pasteout_data);
1326     if (inst->pasteout_data_utf8)
1327         sfree(inst->pasteout_data_utf8);
1328
1329     /*
1330      * Set up UTF-8 paste data. This only happens if we aren't in
1331      * direct-to-font mode using the D800 hack.
1332      */
1333     if (!inst->direct_to_font) {
1334         wchar_t *tmp = data;
1335         int tmplen = len;
1336
1337         inst->pasteout_data_utf8 = snewn(len*6, char);
1338         inst->pasteout_data_utf8_len = len*6;
1339         inst->pasteout_data_utf8_len =
1340             charset_from_unicode(&tmp, &tmplen, inst->pasteout_data_utf8,
1341                                  inst->pasteout_data_utf8_len,
1342                                  CS_UTF8, NULL, NULL, 0);
1343         if (inst->pasteout_data_utf8_len == 0) {
1344             sfree(inst->pasteout_data_utf8);
1345             inst->pasteout_data_utf8 = NULL;
1346         } else {
1347             inst->pasteout_data_utf8 =
1348                 sresize(inst->pasteout_data_utf8,
1349                         inst->pasteout_data_utf8_len, char);
1350         }
1351     } else {
1352         inst->pasteout_data_utf8 = NULL;
1353         inst->pasteout_data_utf8_len = 0;
1354     }
1355
1356     inst->pasteout_data = snewn(len*6, char);
1357     inst->pasteout_data_len = len*6;
1358     inst->pasteout_data_len = wc_to_mb(inst->ucsdata.line_codepage, 0,
1359                                        data, len, inst->pasteout_data,
1360                                        inst->pasteout_data_len,
1361                                        NULL, NULL, NULL);
1362     if (inst->pasteout_data_len == 0) {
1363         sfree(inst->pasteout_data);
1364         inst->pasteout_data = NULL;
1365     } else {
1366         inst->pasteout_data =
1367             sresize(inst->pasteout_data, inst->pasteout_data_len, char);
1368     }
1369
1370     if (gtk_selection_owner_set(inst->area, GDK_SELECTION_PRIMARY,
1371                                 GDK_CURRENT_TIME)) {
1372         gtk_selection_add_target(inst->area, GDK_SELECTION_PRIMARY,
1373                                  GDK_SELECTION_TYPE_STRING, 1);
1374         gtk_selection_add_target(inst->area, GDK_SELECTION_PRIMARY,
1375                                  compound_text_atom, 1);
1376         if (inst->pasteout_data_utf8)
1377             gtk_selection_add_target(inst->area, GDK_SELECTION_PRIMARY,
1378                                      utf8_string_atom, 1);
1379     }
1380
1381     if (must_deselect)
1382         term_deselect(inst->term);
1383 }
1384
1385 void selection_get(GtkWidget *widget, GtkSelectionData *seldata,
1386                    guint info, guint time_stamp, gpointer data)
1387 {
1388     struct gui_data *inst = (struct gui_data *)data;
1389     if (seldata->target == utf8_string_atom)
1390         gtk_selection_data_set(seldata, seldata->target, 8,
1391                                inst->pasteout_data_utf8,
1392                                inst->pasteout_data_utf8_len);
1393     else
1394         gtk_selection_data_set(seldata, seldata->target, 8,
1395                                inst->pasteout_data, inst->pasteout_data_len);
1396 }
1397
1398 gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata,
1399                      gpointer data)
1400 {
1401     struct gui_data *inst = (struct gui_data *)data;
1402     term_deselect(inst->term);
1403     if (inst->pasteout_data)
1404         sfree(inst->pasteout_data);
1405     if (inst->pasteout_data_utf8)
1406         sfree(inst->pasteout_data_utf8);
1407     inst->pasteout_data = NULL;
1408     inst->pasteout_data_len = 0;
1409     inst->pasteout_data_utf8 = NULL;
1410     inst->pasteout_data_utf8_len = 0;
1411     return TRUE;
1412 }
1413
1414 void request_paste(void *frontend)
1415 {
1416     struct gui_data *inst = (struct gui_data *)frontend;
1417     /*
1418      * In Unix, pasting is asynchronous: all we can do at the
1419      * moment is to call gtk_selection_convert(), and when the data
1420      * comes back _then_ we can call term_do_paste().
1421      */
1422
1423     if (!inst->direct_to_font) {
1424         /*
1425          * First we attempt to retrieve the selection as a UTF-8
1426          * string (which we will convert to the correct code page
1427          * before sending to the session, of course). If that
1428          * fails, selection_received() will be informed and will
1429          * fall back to an ordinary string.
1430          */
1431         gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,
1432                               utf8_string_atom, GDK_CURRENT_TIME);
1433     } else {
1434         /*
1435          * If we're in direct-to-font mode, we disable UTF-8
1436          * pasting, and go straight to ordinary string data.
1437          */
1438         gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,
1439                               GDK_SELECTION_TYPE_STRING, GDK_CURRENT_TIME);
1440     }
1441 }
1442
1443 gint idle_paste_func(gpointer data);   /* forward ref */
1444
1445 void selection_received(GtkWidget *widget, GtkSelectionData *seldata,
1446                         guint time, gpointer data)
1447 {
1448     struct gui_data *inst = (struct gui_data *)data;
1449
1450     if (seldata->target == utf8_string_atom && seldata->length <= 0) {
1451         /*
1452          * Failed to get a UTF-8 selection string. Try an ordinary
1453          * string.
1454          */
1455         gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,
1456                               GDK_SELECTION_TYPE_STRING, GDK_CURRENT_TIME);
1457         return;
1458     }
1459
1460     /*
1461      * Any other failure should just go foom.
1462      */
1463     if (seldata->length <= 0 ||
1464         (seldata->type != GDK_SELECTION_TYPE_STRING &&
1465          seldata->type != utf8_string_atom))
1466         return;                        /* Nothing happens. */
1467
1468     if (inst->pastein_data)
1469         sfree(inst->pastein_data);
1470
1471     inst->pastein_data = snewn(seldata->length, wchar_t);
1472     inst->pastein_data_len = seldata->length;
1473     inst->pastein_data_len =
1474         mb_to_wc((seldata->type == utf8_string_atom ?
1475                   CS_UTF8 : inst->ucsdata.line_codepage),
1476                  0, seldata->data, seldata->length,
1477                  inst->pastein_data, inst->pastein_data_len);
1478
1479     term_do_paste(inst->term);
1480
1481     if (term_paste_pending(inst->term))
1482         inst->term_paste_idle_id = gtk_idle_add(idle_paste_func, inst);
1483 }
1484
1485 gint idle_paste_func(gpointer data)
1486 {
1487     struct gui_data *inst = (struct gui_data *)data;
1488
1489     if (term_paste_pending(inst->term))
1490         term_paste(inst->term);
1491     else
1492         gtk_idle_remove(inst->term_paste_idle_id);
1493
1494     return TRUE;
1495 }
1496
1497
1498 void get_clip(void *frontend, wchar_t ** p, int *len)
1499 {
1500     struct gui_data *inst = (struct gui_data *)frontend;
1501
1502     if (p) {
1503         *p = inst->pastein_data;
1504         *len = inst->pastein_data_len;
1505     }
1506 }
1507
1508 static void set_window_titles(struct gui_data *inst)
1509 {
1510     /*
1511      * We must always call set_icon_name after calling set_title,
1512      * since set_title will write both names. Irritating, but such
1513      * is life.
1514      */
1515     gtk_window_set_title(GTK_WINDOW(inst->window), inst->wintitle);
1516     if (!inst->cfg.win_name_always)
1517         gdk_window_set_icon_name(inst->window->window, inst->icontitle);
1518 }
1519
1520 void set_title(void *frontend, char *title)
1521 {
1522     struct gui_data *inst = (struct gui_data *)frontend;
1523     strncpy(inst->wintitle, title, lenof(inst->wintitle));
1524     inst->wintitle[lenof(inst->wintitle)-1] = '\0';
1525     set_window_titles(inst);
1526 }
1527
1528 void set_icon(void *frontend, char *title)
1529 {
1530     struct gui_data *inst = (struct gui_data *)frontend;
1531     strncpy(inst->icontitle, title, lenof(inst->icontitle));
1532     inst->icontitle[lenof(inst->icontitle)-1] = '\0';
1533     set_window_titles(inst);
1534 }
1535
1536 void set_sbar(void *frontend, int total, int start, int page)
1537 {
1538     struct gui_data *inst = (struct gui_data *)frontend;
1539     if (!inst->cfg.scrollbar)
1540         return;
1541     inst->sbar_adjust->lower = 0;
1542     inst->sbar_adjust->upper = total;
1543     inst->sbar_adjust->value = start;
1544     inst->sbar_adjust->page_size = page;
1545     inst->sbar_adjust->step_increment = 1;
1546     inst->sbar_adjust->page_increment = page/2;
1547     inst->ignore_sbar = TRUE;
1548     gtk_adjustment_changed(inst->sbar_adjust);
1549     inst->ignore_sbar = FALSE;
1550 }
1551
1552 void scrollbar_moved(GtkAdjustment *adj, gpointer data)
1553 {
1554     struct gui_data *inst = (struct gui_data *)data;
1555
1556     if (!inst->cfg.scrollbar)
1557         return;
1558     if (!inst->ignore_sbar)
1559         term_scroll(inst->term, 1, (int)adj->value);
1560 }
1561
1562 void sys_cursor(void *frontend, int x, int y)
1563 {
1564     /*
1565      * This is meaningless under X.
1566      */
1567 }
1568
1569 /*
1570  * This is still called when mode==BELL_VISUAL, even though the
1571  * visual bell is handled entirely within terminal.c, because we
1572  * may want to perform additional actions on any kind of bell (for
1573  * example, taskbar flashing in Windows).
1574  */
1575 void beep(void *frontend, int mode)
1576 {
1577     if (mode != BELL_VISUAL)
1578         gdk_beep();
1579 }
1580
1581 int char_width(Context ctx, int uc)
1582 {
1583     /*
1584      * Under X, any fixed-width font really _is_ fixed-width.
1585      * Double-width characters will be dealt with using a separate
1586      * font. For the moment we can simply return 1.
1587      */
1588     return 1;
1589 }
1590
1591 Context get_ctx(void *frontend)
1592 {
1593     struct gui_data *inst = (struct gui_data *)frontend;
1594     struct draw_ctx *dctx;
1595
1596     if (!inst->area->window)
1597         return NULL;
1598
1599     dctx = snew(struct draw_ctx);
1600     dctx->inst = inst;
1601     dctx->gc = gdk_gc_new(inst->area->window);
1602     return dctx;
1603 }
1604
1605 void free_ctx(Context ctx)
1606 {
1607     struct draw_ctx *dctx = (struct draw_ctx *)ctx;
1608     /* struct gui_data *inst = dctx->inst; */
1609     GdkGC *gc = dctx->gc;
1610     gdk_gc_unref(gc);
1611     sfree(dctx);
1612 }
1613
1614 /*
1615  * Draw a line of text in the window, at given character
1616  * coordinates, in given attributes.
1617  *
1618  * We are allowed to fiddle with the contents of `text'.
1619  */
1620 void do_text_internal(Context ctx, int x, int y, char *text, int len,
1621                       unsigned long attr, int lattr)
1622 {
1623     struct draw_ctx *dctx = (struct draw_ctx *)ctx;
1624     struct gui_data *inst = dctx->inst;
1625     GdkGC *gc = dctx->gc;
1626
1627     int nfg, nbg, t, fontid, shadow, rlen, widefactor;
1628
1629     nfg = ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1630     nfg = 2 * (nfg & 0xF) + (nfg & 0x10 ? 1 : 0);
1631     nbg = ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1632     nbg = 2 * (nbg & 0xF) + (nbg & 0x10 ? 1 : 0);
1633     if (attr & ATTR_REVERSE) {
1634         t = nfg;
1635         nfg = nbg;
1636         nbg = t;
1637     }
1638     if (inst->cfg.bold_colour && (attr & ATTR_BOLD))
1639         nfg |= 1;
1640     if (inst->cfg.bold_colour && (attr & ATTR_BLINK))
1641         nbg |= 1;
1642     if (attr & TATTR_ACTCURS) {
1643         nfg = NCOLOURS-2;
1644         nbg = NCOLOURS-1;
1645     }
1646
1647     fontid = shadow = 0;
1648
1649     if (attr & ATTR_WIDE) {
1650         widefactor = 2;
1651         fontid |= 2;
1652     } else {
1653         widefactor = 1;
1654     }
1655
1656     if ((attr & ATTR_BOLD) && !inst->cfg.bold_colour) {
1657         if (inst->fonts[fontid | 1])
1658             fontid |= 1;
1659         else
1660             shadow = 1;
1661     }
1662
1663     if (lattr != LATTR_NORM) {
1664         x *= 2;
1665         if (x >= inst->term->cols)
1666             return;
1667         if (x + len*2*widefactor > inst->term->cols)
1668             len = (inst->term->cols-x)/2/widefactor;/* trim to LH half */
1669         rlen = len * 2;
1670     } else
1671         rlen = len;
1672
1673     {
1674         GdkRectangle r;
1675
1676         r.x = x*inst->font_width+inst->cfg.window_border;
1677         r.y = y*inst->font_height+inst->cfg.window_border;
1678         r.width = rlen*widefactor*inst->font_width;
1679         r.height = inst->font_height;
1680         gdk_gc_set_clip_rectangle(gc, &r);
1681     }
1682
1683     gdk_gc_set_foreground(gc, &inst->cols[nbg]);
1684     gdk_draw_rectangle(inst->pixmap, gc, 1,
1685                        x*inst->font_width+inst->cfg.window_border,
1686                        y*inst->font_height+inst->cfg.window_border,
1687                        rlen*widefactor*inst->font_width, inst->font_height);
1688
1689     gdk_gc_set_foreground(gc, &inst->cols[nfg]);
1690     {
1691         GdkWChar *gwcs;
1692         gchar *gcs;
1693         wchar_t *wcs;
1694         int i;
1695
1696         wcs = snewn(len+1, wchar_t);
1697         for (i = 0; i < len; i++) {
1698             wcs[i] = (wchar_t) ((attr & CSET_MASK) + (text[i] & CHAR_MASK));
1699         }
1700
1701         if (inst->fonts[fontid] == NULL) {
1702             /*
1703              * The font for this contingency does not exist.
1704              * Typically this means we've been given ATTR_WIDE
1705              * character and have no wide font. So we display
1706              * nothing at all; such is life.
1707              */
1708         } else if (inst->fontinfo[fontid].is_wide) {
1709             /*
1710              * At least one version of gdk_draw_text_wc() has a
1711              * weird bug whereby it reads `len' elements of the
1712              * input string, but only draws `len/2'. Hence I'm
1713              * going to make its input array twice as long as it
1714              * theoretically needs to be, and pass in twice the
1715              * actual number of characters. If a fixed gdk actually
1716              * takes the doubled length seriously, then (a) the
1717              * array will stand scrutiny up to the full length, (b)
1718              * the spare elements of the array are full of zeroes
1719              * which will probably be an empty glyph in the font,
1720              * and (c) the clip rectangle should prevent it causing
1721              * trouble anyway.
1722              */
1723             gwcs = snewn(len*2+1, GdkWChar);
1724             memset(gwcs, 0, sizeof(GdkWChar) * (len*2+1));
1725             /*
1726              * FIXME: when we have a wide-char equivalent of
1727              * from_unicode, use it instead of this.
1728              */
1729             for (i = 0; i <= len; i++)
1730                 gwcs[i] = wcs[i];
1731             gdk_draw_text_wc(inst->pixmap, inst->fonts[fontid], gc,
1732                              x*inst->font_width+inst->cfg.window_border,
1733                              y*inst->font_height+inst->cfg.window_border+inst->fonts[0]->ascent,
1734                              gwcs, len*2);
1735             sfree(gwcs);
1736         } else {
1737             gcs = snewn(len+1, gchar);
1738             wc_to_mb(inst->fontinfo[fontid].charset, 0,
1739                      wcs, len, gcs, len, ".", NULL, NULL);
1740             gdk_draw_text(inst->pixmap, inst->fonts[fontid], gc,
1741                           x*inst->font_width+inst->cfg.window_border,
1742                           y*inst->font_height+inst->cfg.window_border+inst->fonts[0]->ascent,
1743                           gcs, len);
1744             sfree(gcs);
1745         }
1746         sfree(wcs);
1747     }
1748
1749     if (shadow) {
1750         gdk_draw_text(inst->pixmap, inst->fonts[fontid], gc,
1751                       x*inst->font_width+inst->cfg.window_border + inst->cfg.shadowboldoffset,
1752                       y*inst->font_height+inst->cfg.window_border+inst->fonts[0]->ascent,
1753                       text, len);
1754     }
1755
1756     if (attr & ATTR_UNDER) {
1757         int uheight = inst->fonts[0]->ascent + 1;
1758         if (uheight >= inst->font_height)
1759             uheight = inst->font_height - 1;
1760         gdk_draw_line(inst->pixmap, gc, x*inst->font_width+inst->cfg.window_border,
1761                       y*inst->font_height + uheight + inst->cfg.window_border,
1762                       (x+len)*widefactor*inst->font_width-1+inst->cfg.window_border,
1763                       y*inst->font_height + uheight + inst->cfg.window_border);
1764     }
1765
1766     if (lattr != LATTR_NORM) {
1767         /*
1768          * I can't find any plausible StretchBlt equivalent in the
1769          * X server, so I'm going to do this the slow and painful
1770          * way. This will involve repeated calls to
1771          * gdk_draw_pixmap() to stretch the text horizontally. It's
1772          * O(N^2) in time and O(N) in network bandwidth, but you
1773          * try thinking of a better way. :-(
1774          */
1775         int i;
1776         for (i = 0; i < len * widefactor * inst->font_width; i++) {
1777             gdk_draw_pixmap(inst->pixmap, gc, inst->pixmap,
1778                             x*inst->font_width+inst->cfg.window_border + 2*i,
1779                             y*inst->font_height+inst->cfg.window_border,
1780                             x*inst->font_width+inst->cfg.window_border + 2*i+1,
1781                             y*inst->font_height+inst->cfg.window_border,
1782                             len * inst->font_width - i, inst->font_height);
1783         }
1784         len *= 2;
1785         if (lattr != LATTR_WIDE) {
1786             int dt, db;
1787             /* Now stretch vertically, in the same way. */
1788             if (lattr == LATTR_BOT)
1789                 dt = 0, db = 1;
1790             else
1791                 dt = 1, db = 0;
1792             for (i = 0; i < inst->font_height; i+=2) {
1793                 gdk_draw_pixmap(inst->pixmap, gc, inst->pixmap,
1794                                 x*inst->font_width+inst->cfg.window_border,
1795                                 y*inst->font_height+inst->cfg.window_border+dt*i+db,
1796                                 x*widefactor*inst->font_width+inst->cfg.window_border,
1797                                 y*inst->font_height+inst->cfg.window_border+dt*(i+1),
1798                                 len * inst->font_width, inst->font_height-i-1);
1799             }
1800         }
1801     }
1802 }
1803
1804 void do_text(Context ctx, int x, int y, char *text, int len,
1805              unsigned long attr, int lattr)
1806 {
1807     struct draw_ctx *dctx = (struct draw_ctx *)ctx;
1808     struct gui_data *inst = dctx->inst;
1809     GdkGC *gc = dctx->gc;
1810     int widefactor;
1811
1812     do_text_internal(ctx, x, y, text, len, attr, lattr);
1813
1814     if (attr & ATTR_WIDE) {
1815         widefactor = 2;
1816     } else {
1817         widefactor = 1;
1818     }
1819
1820     if (lattr != LATTR_NORM) {
1821         x *= 2;
1822         if (x >= inst->term->cols)
1823             return;
1824         if (x + len*2*widefactor > inst->term->cols)
1825             len = (inst->term->cols-x)/2/widefactor;/* trim to LH half */
1826         len *= 2;
1827     }
1828
1829     gdk_draw_pixmap(inst->area->window, gc, inst->pixmap,
1830                     x*inst->font_width+inst->cfg.window_border,
1831                     y*inst->font_height+inst->cfg.window_border,
1832                     x*inst->font_width+inst->cfg.window_border,
1833                     y*inst->font_height+inst->cfg.window_border,
1834                     len*widefactor*inst->font_width, inst->font_height);
1835 }
1836
1837 void do_cursor(Context ctx, int x, int y, char *text, int len,
1838                unsigned long attr, int lattr)
1839 {
1840     struct draw_ctx *dctx = (struct draw_ctx *)ctx;
1841     struct gui_data *inst = dctx->inst;
1842     GdkGC *gc = dctx->gc;
1843
1844     int passive, widefactor;
1845
1846     if (attr & TATTR_PASCURS) {
1847         attr &= ~TATTR_PASCURS;
1848         passive = 1;
1849     } else
1850         passive = 0;
1851     if ((attr & TATTR_ACTCURS) && inst->cfg.cursor_type != 0) {
1852         attr &= ~TATTR_ACTCURS;
1853     }
1854     do_text_internal(ctx, x, y, text, len, attr, lattr);
1855
1856     if (attr & ATTR_WIDE) {
1857         widefactor = 2;
1858     } else {
1859         widefactor = 1;
1860     }
1861
1862     if (lattr != LATTR_NORM) {
1863         x *= 2;
1864         if (x >= inst->term->cols)
1865             return;
1866         if (x + len*2*widefactor > inst->term->cols)
1867             len = (inst->term->cols-x)/2/widefactor;/* trim to LH half */
1868         len *= 2;
1869     }
1870
1871     if (inst->cfg.cursor_type == 0) {
1872         /*
1873          * An active block cursor will already have been done by
1874          * the above do_text call, so we only need to do anything
1875          * if it's passive.
1876          */
1877         if (passive) {
1878             gdk_gc_set_foreground(gc, &inst->cols[NCOLOURS-1]);
1879             gdk_draw_rectangle(inst->pixmap, gc, 0,
1880                                x*inst->font_width+inst->cfg.window_border,
1881                                y*inst->font_height+inst->cfg.window_border,
1882                                len*inst->font_width-1, inst->font_height-1);
1883         }
1884     } else {
1885         int uheight;
1886         int startx, starty, dx, dy, length, i;
1887
1888         int char_width;
1889
1890         if ((attr & ATTR_WIDE) || lattr != LATTR_NORM)
1891             char_width = 2*inst->font_width;
1892         else
1893             char_width = inst->font_width;
1894
1895         if (inst->cfg.cursor_type == 1) {
1896             uheight = inst->fonts[0]->ascent + 1;
1897             if (uheight >= inst->font_height)
1898                 uheight = inst->font_height - 1;
1899
1900             startx = x * inst->font_width + inst->cfg.window_border;
1901             starty = y * inst->font_height + inst->cfg.window_border + uheight;
1902             dx = 1;
1903             dy = 0;
1904             length = len * char_width;
1905         } else {
1906             int xadjust = 0;
1907             if (attr & TATTR_RIGHTCURS)
1908                 xadjust = char_width - 1;
1909             startx = x * inst->font_width + inst->cfg.window_border + xadjust;
1910             starty = y * inst->font_height + inst->cfg.window_border;
1911             dx = 0;
1912             dy = 1;
1913             length = inst->font_height;
1914         }
1915
1916         gdk_gc_set_foreground(gc, &inst->cols[NCOLOURS-1]);
1917         if (passive) {
1918             for (i = 0; i < length; i++) {
1919                 if (i % 2 == 0) {
1920                     gdk_draw_point(inst->pixmap, gc, startx, starty);
1921                 }
1922                 startx += dx;
1923                 starty += dy;
1924             }
1925         } else {
1926             gdk_draw_line(inst->pixmap, gc, startx, starty,
1927                           startx + (length-1) * dx, starty + (length-1) * dy);
1928         }
1929     }
1930
1931     gdk_draw_pixmap(inst->area->window, gc, inst->pixmap,
1932                     x*inst->font_width+inst->cfg.window_border,
1933                     y*inst->font_height+inst->cfg.window_border,
1934                     x*inst->font_width+inst->cfg.window_border,
1935                     y*inst->font_height+inst->cfg.window_border,
1936                     len*widefactor*inst->font_width, inst->font_height);
1937 }
1938
1939 GdkCursor *make_mouse_ptr(struct gui_data *inst, int cursor_val)
1940 {
1941     /*
1942      * Truly hideous hack: GTK doesn't allow us to set the mouse
1943      * cursor foreground and background colours unless we've _also_
1944      * created our own cursor from bitmaps. Therefore, I need to
1945      * load the `cursor' font and draw glyphs from it on to
1946      * pixmaps, in order to construct my cursors with the fg and bg
1947      * I want. This is a gross hack, but it's more self-contained
1948      * than linking in Xlib to find the X window handle to
1949      * inst->area and calling XRecolorCursor, and it's more
1950      * futureproof than hard-coding the shapes as bitmap arrays.
1951      */
1952     static GdkFont *cursor_font = NULL;
1953     GdkPixmap *source, *mask;
1954     GdkGC *gc;
1955     GdkColor cfg = { 0, 65535, 65535, 65535 };
1956     GdkColor cbg = { 0, 0, 0, 0 };
1957     GdkColor dfg = { 1, 65535, 65535, 65535 };
1958     GdkColor dbg = { 0, 0, 0, 0 };
1959     GdkCursor *ret;
1960     gchar text[2];
1961     gint lb, rb, wid, asc, desc, w, h, x, y;
1962
1963     if (cursor_val == -2) {
1964         gdk_font_unref(cursor_font);
1965         return NULL;
1966     }
1967
1968     if (cursor_val >= 0 && !cursor_font)
1969         cursor_font = gdk_font_load("cursor");
1970
1971     /*
1972      * Get the text extent of the cursor in question. We use the
1973      * mask character for this, because it's typically slightly
1974      * bigger than the main character.
1975      */
1976     if (cursor_val >= 0) {
1977         text[1] = '\0';
1978         text[0] = (char)cursor_val + 1;
1979         gdk_string_extents(cursor_font, text, &lb, &rb, &wid, &asc, &desc);
1980         w = rb-lb; h = asc+desc; x = -lb; y = asc;
1981     } else {
1982         w = h = 1;
1983         x = y = 0;
1984     }
1985
1986     source = gdk_pixmap_new(NULL, w, h, 1);
1987     mask = gdk_pixmap_new(NULL, w, h, 1);
1988
1989     /*
1990      * Draw the mask character on the mask pixmap.
1991      */
1992     gc = gdk_gc_new(mask);
1993     gdk_gc_set_foreground(gc, &dbg);
1994     gdk_draw_rectangle(mask, gc, 1, 0, 0, w, h);
1995     if (cursor_val >= 0) {
1996         text[1] = '\0';
1997         text[0] = (char)cursor_val + 1;
1998         gdk_gc_set_foreground(gc, &dfg);
1999         gdk_draw_text(mask, cursor_font, gc, x, y, text, 1);
2000     }
2001     gdk_gc_unref(gc);
2002
2003     /*
2004      * Draw the main character on the source pixmap.
2005      */
2006     gc = gdk_gc_new(source);
2007     gdk_gc_set_foreground(gc, &dbg);
2008     gdk_draw_rectangle(source, gc, 1, 0, 0, w, h);
2009     if (cursor_val >= 0) {
2010         text[1] = '\0';
2011         text[0] = (char)cursor_val;
2012         gdk_gc_set_foreground(gc, &dfg);
2013         gdk_draw_text(source, cursor_font, gc, x, y, text, 1);
2014     }
2015     gdk_gc_unref(gc);
2016
2017     /*
2018      * Create the cursor.
2019      */
2020     ret = gdk_cursor_new_from_pixmap(source, mask, &cfg, &cbg, x, y);
2021
2022     /*
2023      * Clean up.
2024      */
2025     gdk_pixmap_unref(source);
2026     gdk_pixmap_unref(mask);
2027
2028     return ret;
2029 }
2030
2031 void modalfatalbox(char *p, ...)
2032 {
2033     va_list ap;
2034     fprintf(stderr, "FATAL ERROR: ");
2035     va_start(ap, p);
2036     vfprintf(stderr, p, ap);
2037     va_end(ap);
2038     fputc('\n', stderr);
2039     exit(1);
2040 }
2041
2042 void cmdline_error(char *p, ...)
2043 {
2044     va_list ap;
2045     fprintf(stderr, "%s: ", appname);
2046     va_start(ap, p);
2047     vfprintf(stderr, p, ap);
2048     va_end(ap);
2049     fputc('\n', stderr);
2050     exit(1);
2051 }
2052
2053 char *get_x_display(void *frontend)
2054 {
2055     return gdk_get_display();
2056 }
2057
2058 long get_windowid(void *frontend)
2059 {
2060     struct gui_data *inst = (struct gui_data *)frontend;
2061     return (long)GDK_WINDOW_XWINDOW(inst->area->window);
2062 }
2063
2064 static void help(FILE *fp) {
2065     if(fprintf(fp,
2066 "pterm option summary:\n"
2067 "\n"
2068 "  --display DISPLAY         Specify X display to use (note '--')\n"
2069 "  -name PREFIX              Prefix when looking up resources (default: pterm)\n"
2070 "  -fn FONT                  Normal text font\n"
2071 "  -fb FONT                  Bold text font\n"
2072 "  -geometry GEOMETRY        Position and size of window (size in characters)\n"
2073 "  -sl LINES                 Number of lines of scrollback\n"
2074 "  -fg COLOUR, -bg COLOUR    Foreground/background colour\n"
2075 "  -bfg COLOUR, -bbg COLOUR  Foreground/background bold colour\n"
2076 "  -cfg COLOUR, -bfg COLOUR  Foreground/background cursor colour\n"
2077 "  -T TITLE                  Window title\n"
2078 "  -ut, +ut                  Do(default) or do not update utmp\n"
2079 "  -ls, +ls                  Do(default) or do not make shell a login shell\n"
2080 "  -sb, +sb                  Do(default) or do not display a scrollbar\n"
2081 "  -log PATH                 Log all output to a file\n"
2082 "  -nethack                  Map numeric keypad to hjklyubn direction keys\n"
2083 "  -xrm RESOURCE-STRING      Set an X resource\n"
2084 "  -e COMMAND [ARGS...]      Execute command (consumes all remaining args)\n"
2085          ) < 0 || fflush(fp) < 0) {
2086         perror("output error");
2087         exit(1);
2088     }
2089 }
2090
2091 int do_cmdline(int argc, char **argv, int do_everything,
2092                struct gui_data *inst, Config *cfg)
2093 {
2094     int err = 0;
2095     char *val;
2096
2097     /*
2098      * Macros to make argument handling easier. Note that because
2099      * they need to call `continue', they cannot be contained in
2100      * the usual do {...} while (0) wrapper to make them
2101      * syntactically single statements; hence it is not legal to
2102      * use one of these macros as an unbraced statement between
2103      * `if' and `else'.
2104      */
2105 #define EXPECTS_ARG { \
2106     if (--argc <= 0) { \
2107         err = 1; \
2108         fprintf(stderr, "%s: %s expects an argument\n", appname, p); \
2109         continue; \
2110     } else \
2111         val = *++argv; \
2112 }
2113 #define SECOND_PASS_ONLY { if (!do_everything) continue; }
2114
2115     while (--argc > 0) {
2116         char *p = *++argv;
2117         int ret;
2118
2119         /*
2120          * Shameless cheating. Debian requires all X terminal
2121          * emulators to support `-T title'; but
2122          * cmdline_process_param will eat -T (it means no-pty) and
2123          * complain that pterm doesn't support it. So, in pterm
2124          * only, we convert -T into -title.
2125          */
2126         if ((cmdline_tooltype & TOOLTYPE_NONNETWORK) &&
2127             !strcmp(p, "-T"))
2128             p = "-title";
2129
2130         ret = cmdline_process_param(p, (argc > 1 ? argv[1] : NULL),
2131                                     do_everything ? 1 : -1, cfg);
2132
2133         if (ret == -2) {
2134             cmdline_error("option \"%s\" requires an argument", p);
2135         } else if (ret == 2) {
2136             --argc, ++argv;            /* skip next argument */
2137             continue;
2138         } else if (ret == 1) {
2139             continue;
2140         }
2141
2142         if (!strcmp(p, "-fn") || !strcmp(p, "-font")) {
2143             EXPECTS_ARG;
2144             SECOND_PASS_ONLY;
2145             strncpy(cfg->font.name, val, sizeof(cfg->font.name));
2146             cfg->font.name[sizeof(cfg->font.name)-1] = '\0';
2147
2148         } else if (!strcmp(p, "-fb")) {
2149             EXPECTS_ARG;
2150             SECOND_PASS_ONLY;
2151             strncpy(cfg->boldfont.name, val, sizeof(cfg->boldfont.name));
2152             cfg->boldfont.name[sizeof(cfg->boldfont.name)-1] = '\0';
2153
2154         } else if (!strcmp(p, "-fw")) {
2155             EXPECTS_ARG;
2156             SECOND_PASS_ONLY;
2157             strncpy(cfg->widefont.name, val, sizeof(cfg->widefont.name));
2158             cfg->widefont.name[sizeof(cfg->widefont.name)-1] = '\0';
2159
2160         } else if (!strcmp(p, "-fwb")) {
2161             EXPECTS_ARG;
2162             SECOND_PASS_ONLY;
2163             strncpy(cfg->wideboldfont.name, val, sizeof(cfg->wideboldfont.name));
2164             cfg->wideboldfont.name[sizeof(cfg->wideboldfont.name)-1] = '\0';
2165
2166         } else if (!strcmp(p, "-cs")) {
2167             EXPECTS_ARG;
2168             SECOND_PASS_ONLY;
2169             strncpy(cfg->line_codepage, val, sizeof(cfg->line_codepage));
2170             cfg->line_codepage[sizeof(cfg->line_codepage)-1] = '\0';
2171
2172         } else if (!strcmp(p, "-geometry")) {
2173             int flags, x, y, w, h;
2174             EXPECTS_ARG;
2175             SECOND_PASS_ONLY;
2176
2177             flags = XParseGeometry(val, &x, &y, &w, &h);
2178             if (flags & WidthValue)
2179                 cfg->width = w;
2180             if (flags & HeightValue)
2181                 cfg->height = h;
2182
2183             if (flags & (XValue | YValue)) {
2184                 inst->xpos = x;
2185                 inst->ypos = y;
2186                 inst->gotpos = TRUE;
2187                 inst->gravity = ((flags & XNegative ? 1 : 0) |
2188                                  (flags & YNegative ? 2 : 0));
2189             }
2190
2191         } else if (!strcmp(p, "-sl")) {
2192             EXPECTS_ARG;
2193             SECOND_PASS_ONLY;
2194             cfg->savelines = atoi(val);
2195
2196         } else if (!strcmp(p, "-fg") || !strcmp(p, "-bg") ||
2197                    !strcmp(p, "-bfg") || !strcmp(p, "-bbg") ||
2198                    !strcmp(p, "-cfg") || !strcmp(p, "-cbg")) {
2199             GdkColor col;
2200
2201             EXPECTS_ARG;
2202             SECOND_PASS_ONLY;
2203             if (!gdk_color_parse(val, &col)) {
2204                 err = 1;
2205                 fprintf(stderr, "%s: unable to parse colour \"%s\"\n",
2206                         appname, val);
2207             } else {
2208                 int index;
2209                 index = (!strcmp(p, "-fg") ? 0 :
2210                          !strcmp(p, "-bg") ? 2 :
2211                          !strcmp(p, "-bfg") ? 1 :
2212                          !strcmp(p, "-bbg") ? 3 :
2213                          !strcmp(p, "-cfg") ? 4 :
2214                          !strcmp(p, "-cbg") ? 5 : -1);
2215                 assert(index != -1);
2216                 cfg->colours[index][0] = col.red / 256;
2217                 cfg->colours[index][1] = col.green / 256;
2218                 cfg->colours[index][2] = col.blue / 256;
2219             }
2220
2221         } else if (use_pty_argv && !strcmp(p, "-e")) {
2222             /* This option swallows all further arguments. */
2223             if (!do_everything)
2224                 break;
2225
2226             if (--argc > 0) {
2227                 int i;
2228                 pty_argv = snewn(argc+1, char *);
2229                 ++argv;
2230                 for (i = 0; i < argc; i++)
2231                     pty_argv[i] = argv[i];
2232                 pty_argv[argc] = NULL;
2233                 break;                 /* finished command-line processing */
2234             } else
2235                 err = 1, fprintf(stderr, "%s: -e expects an argument\n",
2236                                  appname);
2237
2238         } else if (!strcmp(p, "-title")) {
2239             EXPECTS_ARG;
2240             SECOND_PASS_ONLY;
2241             strncpy(cfg->wintitle, val, sizeof(cfg->wintitle));
2242             cfg->wintitle[sizeof(cfg->wintitle)-1] = '\0';
2243
2244         } else if (!strcmp(p, "-log")) {
2245             EXPECTS_ARG;
2246             SECOND_PASS_ONLY;
2247             strncpy(cfg->logfilename.path, val, sizeof(cfg->logfilename.path));
2248             cfg->logfilename.path[sizeof(cfg->logfilename.path)-1] = '\0';
2249             cfg->logtype = LGTYP_DEBUG;
2250
2251         } else if (!strcmp(p, "-ut-") || !strcmp(p, "+ut")) {
2252             SECOND_PASS_ONLY;
2253             cfg->stamp_utmp = 0;
2254
2255         } else if (!strcmp(p, "-ut")) {
2256             SECOND_PASS_ONLY;
2257             cfg->stamp_utmp = 1;
2258
2259         } else if (!strcmp(p, "-ls-") || !strcmp(p, "+ls")) {
2260             SECOND_PASS_ONLY;
2261             cfg->login_shell = 0;
2262
2263         } else if (!strcmp(p, "-ls")) {
2264             SECOND_PASS_ONLY;
2265             cfg->login_shell = 1;
2266
2267         } else if (!strcmp(p, "-nethack")) {
2268             SECOND_PASS_ONLY;
2269             cfg->nethack_keypad = 1;
2270
2271         } else if (!strcmp(p, "-sb-") || !strcmp(p, "+sb")) {
2272             SECOND_PASS_ONLY;
2273             cfg->scrollbar = 0;
2274
2275         } else if (!strcmp(p, "-sb")) {
2276             SECOND_PASS_ONLY;
2277             cfg->scrollbar = 0;
2278
2279         } else if (!strcmp(p, "-name")) {
2280             EXPECTS_ARG;
2281             app_name = val;
2282
2283         } else if (!strcmp(p, "-xrm")) {
2284             EXPECTS_ARG;
2285             provide_xrm_string(val);
2286
2287         } else if(!strcmp(p, "-help") || !strcmp(p, "--help")) {
2288             help(stdout);
2289             exit(0);
2290
2291         } else if(p[0] != '-' && (!do_everything ||
2292                                   process_nonoption_arg(p, cfg))) {
2293             /* do nothing */
2294
2295         } else {
2296             err = 1;
2297             fprintf(stderr, "%s: unrecognized option '%s'\n", appname, p);
2298         }
2299     }
2300
2301     return err;
2302 }
2303
2304 static void block_signal(int sig, int block_it) {
2305   sigset_t ss;
2306
2307   sigemptyset(&ss);
2308   sigaddset(&ss, sig);
2309   if(sigprocmask(block_it ? SIG_BLOCK : SIG_UNBLOCK, &ss, 0) < 0) {
2310     perror("sigprocmask");
2311     exit(1);
2312   }
2313 }
2314
2315 /*
2316  * This function retrieves the character set encoding of a font. It
2317  * returns the character set without the X11 hack (in case the user
2318  * asks to use the font's own encoding).
2319  */
2320 static int set_font_info(struct gui_data *inst, int fontid)
2321 {
2322     GdkFont *font = inst->fonts[fontid];
2323     XFontStruct *xfs = GDK_FONT_XFONT(font);
2324     Display *disp = GDK_FONT_XDISPLAY(font);
2325     Atom charset_registry, charset_encoding;
2326     unsigned long registry_ret, encoding_ret;
2327     int retval = CS_NONE;
2328
2329     charset_registry = XInternAtom(disp, "CHARSET_REGISTRY", False);
2330     charset_encoding = XInternAtom(disp, "CHARSET_ENCODING", False);
2331     inst->fontinfo[fontid].charset = CS_NONE;
2332     inst->fontinfo[fontid].is_wide = 0;
2333     if (XGetFontProperty(xfs, charset_registry, &registry_ret) &&
2334         XGetFontProperty(xfs, charset_encoding, &encoding_ret)) {
2335         char *reg, *enc;
2336         reg = XGetAtomName(disp, (Atom)registry_ret);
2337         enc = XGetAtomName(disp, (Atom)encoding_ret);
2338         if (reg && enc) {
2339             char *encoding = dupcat(reg, "-", enc, NULL);
2340             retval = inst->fontinfo[fontid].charset =
2341                 charset_from_xenc(encoding);
2342             /* FIXME: when libcharset supports wide encodings fix this. */
2343             if (!strcasecmp(encoding, "iso10646-1")) {
2344                 inst->fontinfo[fontid].is_wide = 1;
2345                 retval = CS_UTF8;
2346             }
2347
2348             /*
2349              * Hack for X line-drawing characters: if the primary
2350              * font is encoded as ISO-8859-anything, and has valid
2351              * glyphs in the first 32 char positions, it is assumed
2352              * that those glyphs are the VT100 line-drawing
2353              * character set.
2354              *
2355              * Actually, we'll hack even harder by only checking
2356              * position 0x19 (vertical line, VT100 linedrawing
2357              * `x'). Then we can check it easily by seeing if the
2358              * ascent and descent differ.
2359              */
2360             if (inst->fontinfo[fontid].charset == CS_ISO8859_1) {
2361                 int lb, rb, wid, asc, desc;
2362                 gchar text[2];
2363
2364                 text[1] = '\0';
2365                 text[0] = '\x12';
2366                 gdk_string_extents(inst->fonts[fontid], text,
2367                                    &lb, &rb, &wid, &asc, &desc);
2368                 if (asc != desc)
2369                     inst->fontinfo[fontid].charset = CS_ISO8859_1_X11;
2370             }
2371
2372             sfree(encoding);
2373         }
2374     }
2375
2376     return retval;
2377 }
2378
2379 int uxsel_input_add(int fd, int rwx) {
2380     int flags = 0;
2381     if (rwx & 1) flags |= GDK_INPUT_READ;
2382     if (rwx & 2) flags |= GDK_INPUT_WRITE;
2383     if (rwx & 4) flags |= GDK_INPUT_EXCEPTION;
2384     return gdk_input_add(fd, flags, fd_input_func, NULL);
2385 }
2386
2387 void uxsel_input_remove(int id) {
2388     gdk_input_remove(id);
2389 }
2390
2391 void setup_fonts_ucs(struct gui_data *inst)
2392 {
2393     int font_charset;
2394
2395     if (inst->fonts[0])
2396         gdk_font_unref(inst->fonts[0]);
2397     if (inst->fonts[1])
2398         gdk_font_unref(inst->fonts[1]);
2399     if (inst->fonts[2])
2400         gdk_font_unref(inst->fonts[2]);
2401     if (inst->fonts[3])
2402         gdk_font_unref(inst->fonts[3]);
2403
2404     inst->fonts[0] = gdk_font_load(inst->cfg.font.name);
2405     if (!inst->fonts[0]) {
2406         fprintf(stderr, "%s: unable to load font \"%s\"\n", appname,
2407                 inst->cfg.font.name);
2408         exit(1);
2409     }
2410     font_charset = set_font_info(inst, 0);
2411     if (inst->cfg.boldfont.name[0]) {
2412         inst->fonts[1] = gdk_font_load(inst->cfg.boldfont.name);
2413         if (!inst->fonts[1]) {
2414             fprintf(stderr, "%s: unable to load bold font \"%s\"\n", appname,
2415                     inst->cfg.boldfont.name);
2416             exit(1);
2417         }
2418         set_font_info(inst, 1);
2419     } else
2420         inst->fonts[1] = NULL;
2421     if (inst->cfg.widefont.name[0]) {
2422         inst->fonts[2] = gdk_font_load(inst->cfg.widefont.name);
2423         if (!inst->fonts[2]) {
2424             fprintf(stderr, "%s: unable to load wide font \"%s\"\n", appname,
2425                     inst->cfg.widefont.name);
2426             exit(1);
2427         }
2428         set_font_info(inst, 2);
2429     } else
2430         inst->fonts[2] = NULL;
2431     if (inst->cfg.wideboldfont.name[0]) {
2432         inst->fonts[3] = gdk_font_load(inst->cfg.wideboldfont.name);
2433         if (!inst->fonts[3]) {
2434             fprintf(stderr, "%s: unable to load wide/bold font \"%s\"\n",
2435                     appname, inst->cfg.wideboldfont.name);
2436             exit(1);
2437         }
2438         set_font_info(inst, 3);
2439     } else
2440         inst->fonts[3] = NULL;
2441
2442     inst->font_width = gdk_char_width(inst->fonts[0], ' ');
2443     inst->font_height = inst->fonts[0]->ascent + inst->fonts[0]->descent;
2444
2445     inst->direct_to_font = init_ucs(&inst->ucsdata,
2446                                     inst->cfg.line_codepage, font_charset,
2447                                     inst->cfg.vtmode);
2448 }
2449
2450 void set_geom_hints(struct gui_data *inst)
2451 {
2452     GdkGeometry geom;
2453     geom.min_width = inst->font_width + 2*inst->cfg.window_border;
2454     geom.min_height = inst->font_height + 2*inst->cfg.window_border;
2455     geom.max_width = geom.max_height = -1;
2456     geom.base_width = 2*inst->cfg.window_border;
2457     geom.base_height = 2*inst->cfg.window_border;
2458     geom.width_inc = inst->font_width;
2459     geom.height_inc = inst->font_height;
2460     geom.min_aspect = geom.max_aspect = 0;
2461     gtk_window_set_geometry_hints(GTK_WINDOW(inst->window), inst->area, &geom,
2462                                   GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE |
2463                                   GDK_HINT_RESIZE_INC);
2464 }
2465
2466 void clear_scrollback_menuitem(GtkMenuItem *item, gpointer data)
2467 {
2468     struct gui_data *inst = (struct gui_data *)data;
2469     term_clrsb(inst->term);
2470 }
2471
2472 void reset_terminal_menuitem(GtkMenuItem *item, gpointer data)
2473 {
2474     struct gui_data *inst = (struct gui_data *)data;
2475     term_pwron(inst->term);
2476     ldisc_send(inst->ldisc, NULL, 0, 0);
2477 }
2478
2479 void copy_all_menuitem(GtkMenuItem *item, gpointer data)
2480 {
2481     struct gui_data *inst = (struct gui_data *)data;
2482     term_copyall(inst->term);
2483 }
2484
2485 void special_menuitem(GtkMenuItem *item, gpointer data)
2486 {
2487     struct gui_data *inst = (struct gui_data *)data;
2488     int code = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item),
2489                                                    "user-data"));
2490
2491     inst->back->special(inst->backhandle, code);
2492 }
2493
2494 void about_menuitem(GtkMenuItem *item, gpointer data)
2495 {
2496     struct gui_data *inst = (struct gui_data *)data;
2497     about_box(inst->window);
2498 }
2499
2500 void event_log_menuitem(GtkMenuItem *item, gpointer data)
2501 {
2502     struct gui_data *inst = (struct gui_data *)data;
2503     showeventlog(inst->eventlogstuff, inst->window);
2504 }
2505
2506 void change_settings_menuitem(GtkMenuItem *item, gpointer data)
2507 {
2508     /* This maps colour indices in inst->cfg to those used in inst->cols. */
2509     static const int ww[] = {
2510         6, 7, 8, 9, 10, 11, 12, 13,
2511         14, 15, 16, 17, 18, 19, 20, 21,
2512         0, 1, 2, 3, 4, 5
2513     };
2514     struct gui_data *inst = (struct gui_data *)data;
2515     char *title = dupcat(appname, " Reconfiguration", NULL);
2516     Config cfg2, oldcfg;
2517     int i, need_size;
2518
2519     cfg2 = inst->cfg;                  /* structure copy */
2520
2521     if (do_config_box(title, &cfg2, 1)) {
2522
2523         oldcfg = inst->cfg;            /* structure copy */
2524         inst->cfg = cfg2;              /* structure copy */
2525
2526         /* Pass new config data to the logging module */
2527         log_reconfig(inst->logctx, &cfg2);
2528         /*
2529          * Flush the line discipline's edit buffer in the case
2530          * where local editing has just been disabled.
2531          */
2532         ldisc_send(inst->ldisc, NULL, 0, 0);
2533         /* Pass new config data to the terminal */
2534         term_reconfig(inst->term, &cfg2);
2535         /* Pass new config data to the back end */
2536         inst->back->reconfig(inst->backhandle, &cfg2);
2537
2538         /*
2539          * Just setting inst->cfg is sufficient to cause colour
2540          * setting changes to appear on the next ESC]R palette
2541          * reset. But we should also check whether any colour
2542          * settings have been changed, and revert the ones that
2543          * have to the new default, on the assumption that the user
2544          * is most likely to want an immediate update.
2545          */
2546         for (i = 0; i < NCOLOURS; i++) {
2547             if (oldcfg.colours[ww[i]][0] != cfg2.colours[ww[i]][0] ||
2548                 oldcfg.colours[ww[i]][1] != cfg2.colours[ww[i]][1] ||
2549                 oldcfg.colours[ww[i]][2] != cfg2.colours[ww[i]][2])
2550                 real_palette_set(inst, i, cfg2.colours[ww[i]][0],
2551                                  cfg2.colours[ww[i]][1],
2552                                  cfg2.colours[ww[i]][2]);
2553         }
2554
2555         /*
2556          * If the scrollbar needs to be shown, hidden, or moved
2557          * from one end to the other of the window, do so now.
2558          */
2559         if (oldcfg.scrollbar != cfg2.scrollbar) {
2560             if (cfg2.scrollbar)
2561                 gtk_widget_show(inst->sbar);
2562             else
2563                 gtk_widget_hide(inst->sbar);
2564         }
2565         if (oldcfg.scrollbar_on_left != cfg2.scrollbar_on_left) {
2566             gtk_box_reorder_child(inst->hbox, inst->sbar,
2567                                   cfg2.scrollbar_on_left ? 0 : 1);
2568         }
2569
2570         /*
2571          * Change the window title, if required.
2572          */
2573         if (strcmp(oldcfg.wintitle, cfg2.wintitle))
2574             set_title(inst, cfg2.wintitle);
2575         set_window_titles(inst);
2576
2577         /*
2578          * Redo the whole tangled fonts and Unicode mess if
2579          * necessary.
2580          */
2581         if (strcmp(oldcfg.font.name, cfg2.font.name) ||
2582             strcmp(oldcfg.boldfont.name, cfg2.boldfont.name) ||
2583             strcmp(oldcfg.widefont.name, cfg2.widefont.name) ||
2584             strcmp(oldcfg.wideboldfont.name, cfg2.wideboldfont.name) ||
2585             strcmp(oldcfg.line_codepage, cfg2.line_codepage) ||
2586             oldcfg.vtmode != cfg2.vtmode) {
2587             setup_fonts_ucs(inst);
2588             need_size = 1;
2589         } else
2590             need_size = 0;
2591
2592         /*
2593          * Resize the window.
2594          */
2595         if (oldcfg.width != cfg2.width || oldcfg.height != cfg2.height ||
2596             oldcfg.window_border != cfg2.window_border || need_size) {
2597             set_geom_hints(inst);
2598             request_resize(inst, cfg2.width, cfg2.height);
2599         } else {
2600             /*
2601              * The above will have caused a call to term_size() for
2602              * us if it happened. If the user has fiddled with only
2603              * the scrollback size, the above will not have
2604              * happened and we will need an explicit term_size()
2605              * here.
2606              */
2607             if (oldcfg.savelines != cfg2.savelines)
2608                 term_size(inst->term, inst->term->rows, inst->term->cols,
2609                           cfg2.savelines);
2610         }
2611
2612         term_invalidate(inst->term);
2613     }
2614     sfree(title);
2615 }
2616
2617 void fork_and_exec_self(struct gui_data *inst, int fd_to_close, ...)
2618 {
2619     /*
2620      * Re-execing ourself is not an exact science under Unix. I do
2621      * the best I can by using /proc/self/exe if available and by
2622      * assuming argv[0] can be found on $PATH if not.
2623      *
2624      * Note that we also have to reconstruct the elements of the
2625      * original argv which gtk swallowed, since the user wants the
2626      * new session to appear on the same X display as the old one.
2627      */
2628     char **args;
2629     va_list ap;
2630     int i, n;
2631     int pid;
2632
2633     /*
2634      * Collect the arguments with which to re-exec ourself.
2635      */
2636     va_start(ap, fd_to_close);
2637     n = 2;                             /* progname and terminating NULL */
2638     n += inst->ngtkargs;
2639     while (va_arg(ap, char *) != NULL)
2640         n++;
2641     va_end(ap);
2642
2643     args = snewn(n, char *);
2644     args[0] = inst->progname;
2645     args[n-1] = NULL;
2646     for (i = 0; i < inst->ngtkargs; i++)
2647         args[i+1] = inst->gtkargvstart[i];
2648
2649     i++;
2650     va_start(ap, fd_to_close);
2651     while ((args[i++] = va_arg(ap, char *)) != NULL);
2652     va_end(ap);
2653
2654     assert(i == n);
2655
2656     /*
2657      * Do the double fork.
2658      */
2659     pid = fork();
2660     if (pid < 0) {
2661         perror("fork");
2662         return;
2663     }
2664
2665     if (pid == 0) {
2666         int pid2 = fork();
2667         if (pid2 < 0) {
2668             perror("fork");
2669             _exit(1);
2670         } else if (pid2 > 0) {
2671             /*
2672              * First child has successfully forked second child. My
2673              * Work Here Is Done. Note the use of _exit rather than
2674              * exit: the latter appears to cause destroy messages
2675              * to be sent to the X server. I suspect gtk uses
2676              * atexit.
2677              */
2678             _exit(0);
2679         }
2680
2681         /*
2682          * If we reach here, we are the second child, so we now
2683          * actually perform the exec.
2684          */
2685         if (fd_to_close >= 0)
2686             close(fd_to_close);
2687
2688         execv("/proc/self/exe", args);
2689         execvp(inst->progname, args);
2690         perror("exec");
2691         _exit(127);
2692
2693     } else {
2694         int status;
2695         waitpid(pid, &status, 0);
2696     }
2697
2698 }
2699
2700 void dup_session_menuitem(GtkMenuItem *item, gpointer gdata)
2701 {
2702     struct gui_data *inst = (struct gui_data *)gdata;
2703     /*
2704      * For this feature we must marshal cfg and (possibly) pty_argv
2705      * into a byte stream, create a pipe, and send this byte stream
2706      * to the child through the pipe.
2707      */
2708     int i, ret, size;
2709     char *data;
2710     char option[80];
2711     int pipefd[2];
2712
2713     if (pipe(pipefd) < 0) {
2714         perror("pipe");
2715         return;
2716     }
2717
2718     size = sizeof(inst->cfg);
2719     if (use_pty_argv && pty_argv) {
2720         for (i = 0; pty_argv[i]; i++)
2721             size += strlen(pty_argv[i]) + 1;
2722     }
2723
2724     data = snewn(size, char);
2725     memcpy(data, &inst->cfg, sizeof(inst->cfg));
2726     if (use_pty_argv && pty_argv) {
2727         int p = sizeof(inst->cfg);
2728         for (i = 0; pty_argv[i]; i++) {
2729             strcpy(data + p, pty_argv[i]);
2730             p += strlen(pty_argv[i]) + 1;
2731         }
2732         assert(p == size);
2733     }
2734
2735     sprintf(option, "---[%d,%d]", pipefd[0], size);
2736     fcntl(pipefd[0], F_SETFD, 0);
2737     fork_and_exec_self(inst, pipefd[1], option, NULL);
2738     close(pipefd[0]);
2739
2740     i = ret = 0;
2741     while (i < size && (ret = write(pipefd[1], data + i, size - i)) > 0)
2742         i += ret;
2743     if (ret < 0)
2744         perror("write to pipe");
2745     close(pipefd[1]);
2746     sfree(data);
2747 }
2748
2749 int read_dupsession_data(struct gui_data *inst, Config *cfg, char *arg)
2750 {
2751     int fd, i, ret, size;
2752     char *data;
2753
2754     if (sscanf(arg, "---[%d,%d]", &fd, &size) != 2) {
2755         fprintf(stderr, "%s: malformed magic argument `%s'\n", appname, arg);
2756         exit(1);
2757     }
2758
2759     data = snewn(size, char);
2760     i = ret = 0;
2761     while (i < size && (ret = read(fd, data + i, size - i)) > 0)
2762         i += ret;
2763     if (ret < 0) {
2764         perror("read from pipe");
2765         exit(1);
2766     } else if (i < size) {
2767         fprintf(stderr, "%s: unexpected EOF in Duplicate Session data\n",
2768                 appname);
2769         exit(1);
2770     }
2771
2772     memcpy(cfg, data, sizeof(Config));
2773     if (use_pty_argv && size > sizeof(Config)) {
2774         int n = 0;
2775         i = sizeof(Config);
2776         while (i < size) {
2777             while (i < size && data[i]) i++;
2778             if (i >= size) {
2779                 fprintf(stderr, "%s: malformed Duplicate Session data\n",
2780                         appname);
2781                 exit(1);
2782             }
2783             i++;
2784             n++;
2785         }
2786         pty_argv = snewn(n+1, char *);
2787         pty_argv[n] = NULL;
2788         n = 0;
2789         i = sizeof(Config);
2790         while (i < size) {
2791             char *p = data + i;
2792             while (i < size && data[i]) i++;
2793             assert(i < size);
2794             i++;
2795             pty_argv[n++] = dupstr(p);
2796         }
2797     }
2798
2799     return 0;
2800 }
2801
2802 void new_session_menuitem(GtkMenuItem *item, gpointer data)
2803 {
2804     struct gui_data *inst = (struct gui_data *)data;
2805
2806     fork_and_exec_self(inst, -1, NULL);
2807 }
2808
2809 void saved_session_menuitem(GtkMenuItem *item, gpointer data)
2810 {
2811     struct gui_data *inst = (struct gui_data *)data;
2812     char *str = (char *)gtk_object_get_data(GTK_OBJECT(item), "user-data");
2813
2814     fork_and_exec_self(inst, -1, "-load", str, NULL);
2815 }
2816
2817 void saved_session_freedata(GtkMenuItem *item, gpointer data)
2818 {
2819     char *str = (char *)gtk_object_get_data(GTK_OBJECT(item), "user-data");
2820
2821     sfree(str);
2822 }
2823
2824 void update_specials_menu(void *frontend)
2825 {
2826     struct gui_data *inst = (struct gui_data *)frontend;
2827
2828     const struct telnet_special *specials;
2829
2830     specials = inst->back->get_specials(inst->backhandle);
2831     gtk_container_foreach(GTK_CONTAINER(inst->specialsmenu),
2832                           (GtkCallback)gtk_widget_destroy, NULL);
2833     if (specials) {
2834         int i;
2835         GtkWidget *menuitem;
2836         for (i = 0; specials[i].name; i++) {
2837             if (*specials[i].name) {
2838                 menuitem = gtk_menu_item_new_with_label(specials[i].name);
2839                 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
2840                                     GINT_TO_POINTER(specials[i].code));
2841                 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
2842                                    GTK_SIGNAL_FUNC(special_menuitem), inst);
2843             } else
2844                 menuitem = gtk_menu_item_new();
2845             gtk_container_add(GTK_CONTAINER(inst->specialsmenu), menuitem);
2846             gtk_widget_show(menuitem);
2847         }
2848         gtk_widget_show(inst->specialsitem1);
2849         gtk_widget_show(inst->specialsitem2);
2850     } else {
2851         gtk_widget_hide(inst->specialsitem1);
2852         gtk_widget_hide(inst->specialsitem2);
2853     }
2854 }
2855
2856 int pt_main(int argc, char **argv)
2857 {
2858     extern Backend *select_backend(Config *cfg);
2859     extern int cfgbox(Config *cfg);
2860     struct gui_data *inst;
2861
2862     /*
2863      * Create an instance structure and initialise to zeroes
2864      */
2865     inst = snew(struct gui_data);
2866     memset(inst, 0, sizeof(*inst));
2867     inst->alt_keycode = -1;            /* this one needs _not_ to be zero */
2868
2869     /* defer any child exit handling until we're ready to deal with
2870      * it */
2871     block_signal(SIGCHLD, 1);
2872
2873     inst->progname = argv[0];
2874     /*
2875      * Copy the original argv before letting gtk_init fiddle with
2876      * it. It will be required later.
2877      */
2878     {
2879         int i, oldargc;
2880         inst->gtkargvstart = snewn(argc-1, char *);
2881         for (i = 1; i < argc; i++)
2882             inst->gtkargvstart[i-1] = dupstr(argv[i]);
2883         oldargc = argc;
2884         gtk_init(&argc, &argv);
2885         inst->ngtkargs = oldargc - argc;
2886     }
2887
2888     if (argc > 1 && !strncmp(argv[1], "---", 3)) {
2889         read_dupsession_data(inst, &inst->cfg, argv[1]);
2890         /* Splatter this argument so it doesn't clutter a ps listing */
2891         memset(argv[1], 0, strlen(argv[1]));
2892     } else {
2893         if (do_cmdline(argc, argv, 0, inst, &inst->cfg))
2894             exit(1);                   /* pre-defaults pass to get -class */
2895         do_defaults(NULL, &inst->cfg);
2896         if (do_cmdline(argc, argv, 1, inst, &inst->cfg))
2897             exit(1);                   /* post-defaults, do everything */
2898
2899         cmdline_run_saved(&inst->cfg);
2900
2901         if (!*inst->cfg.host && !cfgbox(&inst->cfg))
2902             exit(0);                   /* config box hit Cancel */
2903     }
2904
2905     if (!compound_text_atom)
2906         compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", FALSE);
2907     if (!utf8_string_atom)
2908         utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE);
2909
2910     setup_fonts_ucs(inst);
2911
2912     inst->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2913
2914     /*
2915      * Set up the colour map.
2916      */
2917     palette_reset(inst);
2918
2919     inst->width = inst->cfg.width;
2920     inst->height = inst->cfg.height;
2921
2922     inst->area = gtk_drawing_area_new();
2923     gtk_drawing_area_size(GTK_DRAWING_AREA(inst->area),
2924                           inst->font_width * inst->cfg.width + 2*inst->cfg.window_border,
2925                           inst->font_height * inst->cfg.height + 2*inst->cfg.window_border);
2926     inst->sbar_adjust = GTK_ADJUSTMENT(gtk_adjustment_new(0,0,0,0,0,0));
2927     inst->sbar = gtk_vscrollbar_new(inst->sbar_adjust);
2928     inst->hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
2929     /*
2930      * We always create the scrollbar; it remains invisible if
2931      * unwanted, so we can pop it up quickly if it suddenly becomes
2932      * desirable.
2933      */
2934     if (inst->cfg.scrollbar_on_left)
2935         gtk_box_pack_start(inst->hbox, inst->sbar, FALSE, FALSE, 0);
2936     gtk_box_pack_start(inst->hbox, inst->area, TRUE, TRUE, 0);
2937     if (!inst->cfg.scrollbar_on_left)
2938         gtk_box_pack_start(inst->hbox, inst->sbar, FALSE, FALSE, 0);
2939
2940     gtk_container_add(GTK_CONTAINER(inst->window), GTK_WIDGET(inst->hbox));
2941
2942     set_geom_hints(inst);
2943
2944     gtk_widget_show(inst->area);
2945     if (inst->cfg.scrollbar)
2946         gtk_widget_show(inst->sbar);
2947     else
2948         gtk_widget_hide(inst->sbar);
2949     gtk_widget_show(GTK_WIDGET(inst->hbox));
2950
2951     if (inst->gotpos) {
2952         int x = inst->xpos, y = inst->ypos;
2953         GtkRequisition req;
2954         gtk_widget_size_request(GTK_WIDGET(inst->window), &req);
2955         if (inst->gravity & 1) x += gdk_screen_width() - req.width;
2956         if (inst->gravity & 2) y += gdk_screen_height() - req.height;
2957         gtk_window_set_position(GTK_WINDOW(inst->window), GTK_WIN_POS_NONE);
2958         gtk_widget_set_uposition(GTK_WIDGET(inst->window), x, y);
2959     }
2960
2961     gtk_signal_connect(GTK_OBJECT(inst->window), "destroy",
2962                        GTK_SIGNAL_FUNC(destroy), inst);
2963     gtk_signal_connect(GTK_OBJECT(inst->window), "delete_event",
2964                        GTK_SIGNAL_FUNC(delete_window), inst);
2965     gtk_signal_connect(GTK_OBJECT(inst->window), "key_press_event",
2966                        GTK_SIGNAL_FUNC(key_event), inst);
2967     gtk_signal_connect(GTK_OBJECT(inst->window), "key_release_event",
2968                        GTK_SIGNAL_FUNC(key_event), inst);
2969     gtk_signal_connect(GTK_OBJECT(inst->window), "focus_in_event",
2970                        GTK_SIGNAL_FUNC(focus_event), inst);
2971     gtk_signal_connect(GTK_OBJECT(inst->window), "focus_out_event",
2972                        GTK_SIGNAL_FUNC(focus_event), inst);
2973     gtk_signal_connect(GTK_OBJECT(inst->area), "configure_event",
2974                        GTK_SIGNAL_FUNC(configure_area), inst);
2975     gtk_signal_connect(GTK_OBJECT(inst->area), "expose_event",
2976                        GTK_SIGNAL_FUNC(expose_area), inst);
2977     gtk_signal_connect(GTK_OBJECT(inst->area), "button_press_event",
2978                        GTK_SIGNAL_FUNC(button_event), inst);
2979     gtk_signal_connect(GTK_OBJECT(inst->area), "button_release_event",
2980                        GTK_SIGNAL_FUNC(button_event), inst);
2981     gtk_signal_connect(GTK_OBJECT(inst->area), "motion_notify_event",
2982                        GTK_SIGNAL_FUNC(motion_event), inst);
2983     gtk_signal_connect(GTK_OBJECT(inst->area), "selection_received",
2984                        GTK_SIGNAL_FUNC(selection_received), inst);
2985     gtk_signal_connect(GTK_OBJECT(inst->area), "selection_get",
2986                        GTK_SIGNAL_FUNC(selection_get), inst);
2987     gtk_signal_connect(GTK_OBJECT(inst->area), "selection_clear_event",
2988                        GTK_SIGNAL_FUNC(selection_clear), inst);
2989     if (inst->cfg.scrollbar)
2990         gtk_signal_connect(GTK_OBJECT(inst->sbar_adjust), "value_changed",
2991                            GTK_SIGNAL_FUNC(scrollbar_moved), inst);
2992     gtk_timeout_add(20, timer_func, inst);
2993     gtk_widget_add_events(GTK_WIDGET(inst->area),
2994                           GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK |
2995                           GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
2996                           GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK);
2997
2998     gtk_widget_show(inst->window);
2999
3000     set_window_background(inst);
3001
3002     /*
3003      * Set up the Ctrl+rightclick context menu.
3004      */
3005     {
3006         GtkWidget *menuitem;
3007         char *s;
3008         extern const int use_event_log, new_session, saved_sessions;
3009
3010         inst->menu = gtk_menu_new();
3011
3012 #define MKMENUITEM(title, func) do { \
3013     menuitem = title ? gtk_menu_item_new_with_label(title) : \
3014     gtk_menu_item_new(); \
3015     gtk_container_add(GTK_CONTAINER(inst->menu), menuitem); \
3016     gtk_widget_show(menuitem); \
3017     if (func != NULL) \
3018         gtk_signal_connect(GTK_OBJECT(menuitem), "activate", \
3019                                GTK_SIGNAL_FUNC(func), inst); \
3020 } while (0)
3021         if (new_session)
3022             MKMENUITEM("New Session", new_session_menuitem);
3023         MKMENUITEM("Duplicate Session", dup_session_menuitem);
3024         if (saved_sessions) {
3025             struct sesslist sesslist;
3026             int i;
3027
3028             inst->sessionsmenu = gtk_menu_new();
3029
3030             get_sesslist(&sesslist, TRUE);
3031             for (i = 1; i < sesslist.nsessions; i++) {
3032                 menuitem = gtk_menu_item_new_with_label(sesslist.sessions[i]);
3033                 gtk_container_add(GTK_CONTAINER(inst->sessionsmenu), menuitem);
3034                 gtk_widget_show(menuitem);
3035                 gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",
3036                                     dupstr(sesslist.sessions[i]));
3037                 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
3038                                    GTK_SIGNAL_FUNC(saved_session_menuitem),
3039                                    inst);
3040                 gtk_signal_connect(GTK_OBJECT(menuitem), "destroy",
3041                                    GTK_SIGNAL_FUNC(saved_session_freedata),
3042                                    inst);
3043             }
3044             get_sesslist(&sesslist, FALSE);
3045
3046             MKMENUITEM("Saved Sessions", NULL);
3047             gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem),
3048                                       inst->sessionsmenu);
3049         }
3050         MKMENUITEM(NULL, NULL);
3051         MKMENUITEM("Change Settings", change_settings_menuitem);
3052         MKMENUITEM(NULL, NULL);
3053         if (use_event_log)
3054             MKMENUITEM("Event Log", event_log_menuitem);
3055         MKMENUITEM("Special Commands", NULL);
3056         inst->specialsmenu = gtk_menu_new();
3057         gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), inst->specialsmenu);
3058         inst->specialsitem1 = menuitem;
3059         MKMENUITEM(NULL, NULL);
3060         inst->specialsitem2 = menuitem;
3061         MKMENUITEM("Clear Scrollback", clear_scrollback_menuitem);
3062         MKMENUITEM("Reset Terminal", reset_terminal_menuitem);
3063         MKMENUITEM("Copy All", copy_all_menuitem);
3064         MKMENUITEM(NULL, NULL);
3065         s = dupcat("About ", appname, NULL);
3066         MKMENUITEM(s, about_menuitem);
3067         sfree(s);
3068 #undef MKMENUITEM
3069     }
3070
3071     inst->textcursor = make_mouse_ptr(inst, GDK_XTERM);
3072     inst->rawcursor = make_mouse_ptr(inst, GDK_LEFT_PTR);
3073     inst->blankcursor = make_mouse_ptr(inst, -1);
3074     make_mouse_ptr(inst, -2);          /* clean up cursor font */
3075     inst->currcursor = inst->textcursor;
3076     show_mouseptr(inst, 1);
3077
3078     inst->eventlogstuff = eventlogstuff_new();
3079
3080     inst->term = term_init(&inst->cfg, &inst->ucsdata, inst);
3081     inst->logctx = log_init(inst, &inst->cfg);
3082     term_provide_logctx(inst->term, inst->logctx);
3083
3084     uxsel_init();
3085
3086     term_size(inst->term, inst->cfg.height, inst->cfg.width, inst->cfg.savelines);
3087
3088     inst->back = select_backend(&inst->cfg);
3089     {
3090         char *realhost;
3091         const char *error;
3092
3093         error = inst->back->init((void *)inst, &inst->backhandle,
3094                                  &inst->cfg, inst->cfg.host, inst->cfg.port,
3095                                  &realhost, inst->cfg.tcp_nodelay);
3096
3097         if (error) {
3098             char *msg = dupprintf("Unable to open connection to %s:\n%s",
3099                                   inst->cfg.host, error);
3100             inst->exited = TRUE;
3101             fatal_message_box(inst->window, msg);
3102             sfree(msg);
3103             return 0;
3104         }
3105
3106         if (inst->cfg.wintitle[0]) {
3107             set_title(inst, inst->cfg.wintitle);
3108             set_icon(inst, inst->cfg.wintitle);
3109         } else {
3110             char *title = make_default_wintitle(realhost);
3111             set_title(inst, title);
3112             set_icon(inst, title);
3113             sfree(title);
3114         }
3115     }
3116     inst->back->provide_logctx(inst->backhandle, inst->logctx);
3117     update_specials_menu(inst);
3118
3119     term_provide_resize_fn(inst->term, inst->back->size, inst->backhandle);
3120
3121     inst->ldisc =
3122         ldisc_create(&inst->cfg, inst->term, inst->back, inst->backhandle, inst);
3123     ldisc_send(inst->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */
3124
3125     /* now we're reday to deal with the child exit handler being
3126      * called */
3127     block_signal(SIGCHLD, 0);
3128
3129     /*
3130      * Block SIGPIPE: if we attempt Duplicate Session or similar
3131      * and it falls over in some way, we certainly don't want
3132      * SIGPIPE terminating the main pterm/PuTTY. Note that we do
3133      * this _after_ (at least pterm) forks off its child process,
3134      * since the child wants SIGPIPE handled in the usual way.
3135      */
3136     block_signal(SIGPIPE, 1);
3137
3138     inst->exited = FALSE;
3139
3140     gtk_main();
3141
3142     return 0;
3143 }