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