+void cmdline_error(char *p, ...)
+{
+ va_list ap;
+ fprintf(stderr, "%s: ", appname);
+ va_start(ap, p);
+ vfprintf(stderr, p, ap);
+ va_end(ap);
+ fputc('\n', stderr);
+ exit(1);
+}
+
+char *get_x_display(void *frontend)
+{
+ return gdk_get_display();
+}
+
+long get_windowid(void *frontend)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+ return (long)GDK_WINDOW_XWINDOW(inst->area->window);
+}
+
+static void help(FILE *fp) {
+ if(fprintf(fp,
+"pterm option summary:\n"
+"\n"
+" --display DISPLAY Specify X display to use (note '--')\n"
+" -name PREFIX Prefix when looking up resources (default: pterm)\n"
+" -fn FONT Normal text font\n"
+" -fb FONT Bold text font\n"
+" -geometry GEOMETRY Position and size of window (size in characters)\n"
+" -sl LINES Number of lines of scrollback\n"
+" -fg COLOUR, -bg COLOUR Foreground/background colour\n"
+" -bfg COLOUR, -bbg COLOUR Foreground/background bold colour\n"
+" -cfg COLOUR, -bfg COLOUR Foreground/background cursor colour\n"
+" -T TITLE Window title\n"
+" -ut, +ut Do(default) or do not update utmp\n"
+" -ls, +ls Do(default) or do not make shell a login shell\n"
+" -sb, +sb Do(default) or do not display a scrollbar\n"
+" -log PATH Log all output to a file\n"
+" -nethack Map numeric keypad to hjklyubn direction keys\n"
+" -xrm RESOURCE-STRING Set an X resource\n"
+" -e COMMAND [ARGS...] Execute command (consumes all remaining args)\n"
+ ) < 0 || fflush(fp) < 0) {
+ perror("output error");
+ exit(1);
+ }
+}
+
+int do_cmdline(int argc, char **argv, int do_everything,
+ struct gui_data *inst, Config *cfg)
+{
+ int err = 0;
+ char *val;
+
+ /*
+ * Macros to make argument handling easier. Note that because
+ * they need to call `continue', they cannot be contained in
+ * the usual do {...} while (0) wrapper to make them
+ * syntactically single statements; hence it is not legal to
+ * use one of these macros as an unbraced statement between
+ * `if' and `else'.
+ */
+#define EXPECTS_ARG { \
+ if (--argc <= 0) { \
+ err = 1; \
+ fprintf(stderr, "%s: %s expects an argument\n", appname, p); \
+ continue; \
+ } else \
+ val = *++argv; \
+}
+#define SECOND_PASS_ONLY { if (!do_everything) continue; }
+
+ while (--argc > 0) {
+ char *p = *++argv;
+ int ret;
+
+ /*
+ * Shameless cheating. Debian requires all X terminal
+ * emulators to support `-T title'; but
+ * cmdline_process_param will eat -T (it means no-pty) and
+ * complain that pterm doesn't support it. So, in pterm
+ * only, we convert -T into -title.
+ */
+ if ((cmdline_tooltype & TOOLTYPE_NONNETWORK) &&
+ !strcmp(p, "-T"))
+ p = "-title";
+
+ ret = cmdline_process_param(p, (argc > 1 ? argv[1] : NULL),
+ do_everything ? 1 : -1, cfg);
+
+ if (ret == -2) {
+ cmdline_error("option \"%s\" requires an argument", p);
+ } else if (ret == 2) {
+ --argc, ++argv; /* skip next argument */
+ continue;
+ } else if (ret == 1) {
+ continue;
+ }
+
+ if (!strcmp(p, "-fn") || !strcmp(p, "-font")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg->font.name, val, sizeof(cfg->font.name));
+ cfg->font.name[sizeof(cfg->font.name)-1] = '\0';
+
+ } else if (!strcmp(p, "-fb")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg->boldfont.name, val, sizeof(cfg->boldfont.name));
+ cfg->boldfont.name[sizeof(cfg->boldfont.name)-1] = '\0';
+
+ } else if (!strcmp(p, "-fw")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg->widefont.name, val, sizeof(cfg->widefont.name));
+ cfg->widefont.name[sizeof(cfg->widefont.name)-1] = '\0';
+
+ } else if (!strcmp(p, "-fwb")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg->wideboldfont.name, val, sizeof(cfg->wideboldfont.name));
+ cfg->wideboldfont.name[sizeof(cfg->wideboldfont.name)-1] = '\0';
+
+ } else if (!strcmp(p, "-cs")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg->line_codepage, val, sizeof(cfg->line_codepage));
+ cfg->line_codepage[sizeof(cfg->line_codepage)-1] = '\0';
+
+ } else if (!strcmp(p, "-geometry")) {
+ int flags, x, y, w, h;
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+
+ flags = XParseGeometry(val, &x, &y, &w, &h);
+ if (flags & WidthValue)
+ cfg->width = w;
+ if (flags & HeightValue)
+ cfg->height = h;
+
+ if (flags & (XValue | YValue)) {
+ inst->xpos = x;
+ inst->ypos = y;
+ inst->gotpos = TRUE;
+ inst->gravity = ((flags & XNegative ? 1 : 0) |
+ (flags & YNegative ? 2 : 0));
+ }
+
+ } else if (!strcmp(p, "-sl")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ cfg->savelines = atoi(val);
+
+ } else if (!strcmp(p, "-fg") || !strcmp(p, "-bg") ||
+ !strcmp(p, "-bfg") || !strcmp(p, "-bbg") ||
+ !strcmp(p, "-cfg") || !strcmp(p, "-cbg")) {
+ GdkColor col;
+
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ if (!gdk_color_parse(val, &col)) {
+ err = 1;
+ fprintf(stderr, "%s: unable to parse colour \"%s\"\n",
+ appname, val);
+ } else {
+ int index;
+ index = (!strcmp(p, "-fg") ? 0 :
+ !strcmp(p, "-bg") ? 2 :
+ !strcmp(p, "-bfg") ? 1 :
+ !strcmp(p, "-bbg") ? 3 :
+ !strcmp(p, "-cfg") ? 4 :
+ !strcmp(p, "-cbg") ? 5 : -1);
+ assert(index != -1);
+ cfg->colours[index][0] = col.red / 256;
+ cfg->colours[index][1] = col.green / 256;
+ cfg->colours[index][2] = col.blue / 256;
+ }
+
+ } else if (use_pty_argv && !strcmp(p, "-e")) {
+ /* This option swallows all further arguments. */
+ if (!do_everything)
+ break;
+
+ if (--argc > 0) {
+ int i;
+ pty_argv = snewn(argc+1, char *);
+ ++argv;
+ for (i = 0; i < argc; i++)
+ pty_argv[i] = argv[i];
+ pty_argv[argc] = NULL;
+ break; /* finished command-line processing */
+ } else
+ err = 1, fprintf(stderr, "%s: -e expects an argument\n",
+ appname);
+
+ } else if (!strcmp(p, "-title")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg->wintitle, val, sizeof(cfg->wintitle));
+ cfg->wintitle[sizeof(cfg->wintitle)-1] = '\0';
+
+ } else if (!strcmp(p, "-log")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg->logfilename.path, val, sizeof(cfg->logfilename.path));
+ cfg->logfilename.path[sizeof(cfg->logfilename.path)-1] = '\0';
+ cfg->logtype = LGTYP_DEBUG;
+
+ } else if (!strcmp(p, "-ut-") || !strcmp(p, "+ut")) {
+ SECOND_PASS_ONLY;
+ cfg->stamp_utmp = 0;
+
+ } else if (!strcmp(p, "-ut")) {
+ SECOND_PASS_ONLY;
+ cfg->stamp_utmp = 1;
+
+ } else if (!strcmp(p, "-ls-") || !strcmp(p, "+ls")) {
+ SECOND_PASS_ONLY;
+ cfg->login_shell = 0;
+
+ } else if (!strcmp(p, "-ls")) {
+ SECOND_PASS_ONLY;
+ cfg->login_shell = 1;
+
+ } else if (!strcmp(p, "-nethack")) {
+ SECOND_PASS_ONLY;
+ cfg->nethack_keypad = 1;
+
+ } else if (!strcmp(p, "-sb-") || !strcmp(p, "+sb")) {
+ SECOND_PASS_ONLY;
+ cfg->scrollbar = 0;
+
+ } else if (!strcmp(p, "-sb")) {
+ SECOND_PASS_ONLY;
+ cfg->scrollbar = 0;
+
+ } else if (!strcmp(p, "-name")) {
+ EXPECTS_ARG;
+ app_name = val;
+
+ } else if (!strcmp(p, "-xrm")) {
+ EXPECTS_ARG;
+ provide_xrm_string(val);
+
+ } else if(!strcmp(p, "-help") || !strcmp(p, "--help")) {
+ help(stdout);
+ exit(0);
+
+ } else if(p[0] != '-' && (!do_everything ||
+ process_nonoption_arg(p, cfg))) {
+ /* do nothing */
+
+ } else {
+ err = 1;
+ fprintf(stderr, "%s: unrecognized option '%s'\n", appname, p);
+ }
+ }
+
+ return err;
+}
+
+static void block_signal(int sig, int block_it) {
+ sigset_t ss;
+
+ sigemptyset(&ss);
+ sigaddset(&ss, sig);
+ if(sigprocmask(block_it ? SIG_BLOCK : SIG_UNBLOCK, &ss, 0) < 0) {
+ perror("sigprocmask");
+ exit(1);
+ }
+}
+
+/*
+ * This function retrieves the character set encoding of a font. It
+ * returns the character set without the X11 hack (in case the user
+ * asks to use the font's own encoding).
+ */
+static int set_font_info(struct gui_data *inst, int fontid)
+{
+ GdkFont *font = inst->fonts[fontid];
+ XFontStruct *xfs = GDK_FONT_XFONT(font);
+ Display *disp = GDK_FONT_XDISPLAY(font);
+ Atom charset_registry, charset_encoding;
+ unsigned long registry_ret, encoding_ret;
+ int retval = CS_NONE;
+
+ charset_registry = XInternAtom(disp, "CHARSET_REGISTRY", False);
+ charset_encoding = XInternAtom(disp, "CHARSET_ENCODING", False);
+ inst->fontinfo[fontid].charset = CS_NONE;
+ inst->fontinfo[fontid].is_wide = 0;
+ if (XGetFontProperty(xfs, charset_registry, ®istry_ret) &&
+ XGetFontProperty(xfs, charset_encoding, &encoding_ret)) {
+ char *reg, *enc;
+ reg = XGetAtomName(disp, (Atom)registry_ret);
+ enc = XGetAtomName(disp, (Atom)encoding_ret);
+ if (reg && enc) {
+ char *encoding = dupcat(reg, "-", enc, NULL);
+ retval = inst->fontinfo[fontid].charset =
+ charset_from_xenc(encoding);
+ /* FIXME: when libcharset supports wide encodings fix this. */
+ if (!strcasecmp(encoding, "iso10646-1")) {
+ inst->fontinfo[fontid].is_wide = 1;
+ retval = CS_UTF8;
+ }
+
+ /*
+ * Hack for X line-drawing characters: if the primary
+ * font is encoded as ISO-8859-anything, and has valid
+ * glyphs in the first 32 char positions, it is assumed
+ * that those glyphs are the VT100 line-drawing
+ * character set.
+ *
+ * Actually, we'll hack even harder by only checking
+ * position 0x19 (vertical line, VT100 linedrawing
+ * `x'). Then we can check it easily by seeing if the
+ * ascent and descent differ.
+ */
+ if (inst->fontinfo[fontid].charset == CS_ISO8859_1) {
+ int lb, rb, wid, asc, desc;
+ gchar text[2];
+
+ text[1] = '\0';
+ text[0] = '\x12';
+ gdk_string_extents(inst->fonts[fontid], text,
+ &lb, &rb, &wid, &asc, &desc);
+ if (asc != desc)
+ inst->fontinfo[fontid].charset = CS_ISO8859_1_X11;
+ }
+
+ sfree(encoding);
+ }
+ }
+
+ return retval;
+}
+
+int uxsel_input_add(int fd, int rwx) {
+ int flags = 0;
+ if (rwx & 1) flags |= GDK_INPUT_READ;
+ if (rwx & 2) flags |= GDK_INPUT_WRITE;
+ if (rwx & 4) flags |= GDK_INPUT_EXCEPTION;
+ return gdk_input_add(fd, flags, fd_input_func, NULL);
+}
+
+void uxsel_input_remove(int id) {
+ gdk_input_remove(id);
+}
+
+char *guess_derived_font_name(GdkFont *font, int bold, int wide)
+{
+ XFontStruct *xfs = GDK_FONT_XFONT(font);
+ Display *disp = GDK_FONT_XDISPLAY(font);
+ Atom fontprop = XInternAtom(disp, "FONT", False);
+ unsigned long ret;
+ if (XGetFontProperty(xfs, fontprop, &ret)) {
+ char *name = XGetAtomName(disp, (Atom)ret);
+ if (name && name[0] == '-') {
+ char *strings[13];
+ char *dupname, *extrafree = NULL, *ret;
+ char *p, *q;
+ int nstr;
+
+ p = q = dupname = dupstr(name); /* skip initial minus */
+ nstr = 0;
+
+ while (*p && nstr < lenof(strings)) {
+ if (*p == '-') {
+ *p = '\0';
+ strings[nstr++] = p+1;
+ }
+ p++;
+ }
+
+ if (nstr < lenof(strings))
+ return NULL; /* XLFD was malformed */
+
+ if (bold)
+ strings[2] = "bold";
+
+ if (wide) {
+ /* 4 is `wideness', which obviously may have changed. */
+ /* 5 is additional style, which may be e.g. `ja' or `ko'. */
+ strings[4] = strings[5] = "*";
+ strings[11] = extrafree = dupprintf("%d", 2*atoi(strings[11]));
+ }
+
+ ret = dupcat("-", strings[ 0], "-", strings[ 1], "-", strings[ 2],
+ "-", strings[ 3], "-", strings[ 4], "-", strings[ 5],
+ "-", strings[ 6], "-", strings[ 7], "-", strings[ 8],
+ "-", strings[ 9], "-", strings[10], "-", strings[11],
+ "-", strings[12], NULL);
+ sfree(extrafree);
+ sfree(dupname);
+
+ return ret;
+ }
+ }
+ return NULL;
+}
+
+void setup_fonts_ucs(struct gui_data *inst)
+{
+ int font_charset;
+ char *name;
+ int guessed;
+
+ if (inst->fonts[0])
+ gdk_font_unref(inst->fonts[0]);
+ if (inst->fonts[1])
+ gdk_font_unref(inst->fonts[1]);
+ if (inst->fonts[2])
+ gdk_font_unref(inst->fonts[2]);
+ if (inst->fonts[3])
+ gdk_font_unref(inst->fonts[3]);
+
+ inst->fonts[0] = gdk_font_load(inst->cfg.font.name);
+ if (!inst->fonts[0]) {
+ fprintf(stderr, "%s: unable to load font \"%s\"\n", appname,
+ inst->cfg.font.name);
+ exit(1);
+ }
+ font_charset = set_font_info(inst, 0);
+
+ if (inst->cfg.shadowbold) {
+ inst->fonts[1] = NULL;
+ } else {
+ if (inst->cfg.boldfont.name[0]) {
+ name = inst->cfg.boldfont.name;
+ guessed = FALSE;
+ } else {
+ name = guess_derived_font_name(inst->fonts[0], TRUE, FALSE);
+ guessed = TRUE;
+ }
+ inst->fonts[1] = name ? gdk_font_load(name) : NULL;
+ if (inst->fonts[1]) {
+ set_font_info(inst, 1);
+ } else if (!guessed) {
+ fprintf(stderr, "%s: unable to load bold font \"%s\"\n", appname,
+ inst->cfg.boldfont.name);
+ exit(1);
+ }
+ if (guessed)
+ sfree(name);
+ }
+
+ if (inst->cfg.widefont.name[0]) {
+ name = inst->cfg.widefont.name;
+ guessed = FALSE;
+ } else {
+ name = guess_derived_font_name(inst->fonts[0], FALSE, TRUE);
+ guessed = TRUE;
+ }
+ inst->fonts[2] = name ? gdk_font_load(name) : NULL;
+ if (inst->fonts[2]) {
+ set_font_info(inst, 2);
+ } else if (!guessed) {
+ fprintf(stderr, "%s: unable to load wide font \"%s\"\n", appname,
+ inst->cfg.widefont.name);
+ exit(1);
+ }
+ if (guessed)
+ sfree(name);
+
+ if (inst->cfg.shadowbold) {
+ inst->fonts[3] = NULL;
+ } else {
+ if (inst->cfg.wideboldfont.name[0]) {
+ name = inst->cfg.wideboldfont.name;
+ guessed = FALSE;
+ } else {
+ /*
+ * Here we have some choices. We can widen the bold font,
+ * bolden the wide font, or widen and bolden the standard
+ * font. Try them all, in that order!
+ */
+ if (inst->cfg.widefont.name[0])
+ name = guess_derived_font_name(inst->fonts[2], TRUE, FALSE);
+ else if (inst->cfg.boldfont.name[0])
+ name = guess_derived_font_name(inst->fonts[1], FALSE, TRUE);
+ else
+ name = guess_derived_font_name(inst->fonts[0], TRUE, TRUE);
+ guessed = TRUE;
+ }
+ inst->fonts[3] = name ? gdk_font_load(name) : NULL;
+ if (inst->fonts[3]) {
+ set_font_info(inst, 3);
+ } else if (!guessed) {
+ fprintf(stderr, "%s: unable to load wide/bold font \"%s\"\n", appname,
+ inst->cfg.wideboldfont.name);
+ exit(1);
+ }
+ if (guessed)
+ sfree(name);
+ }
+
+ inst->font_width = gdk_char_width(inst->fonts[0], ' ');
+ inst->font_height = inst->fonts[0]->ascent + inst->fonts[0]->descent;
+
+ inst->direct_to_font = init_ucs(&inst->ucsdata,
+ inst->cfg.line_codepage, font_charset,
+ inst->cfg.vtmode);
+}
+
+void set_geom_hints(struct gui_data *inst)
+{
+ GdkGeometry geom;
+ geom.min_width = inst->font_width + 2*inst->cfg.window_border;
+ geom.min_height = inst->font_height + 2*inst->cfg.window_border;
+ geom.max_width = geom.max_height = -1;
+ geom.base_width = 2*inst->cfg.window_border;
+ geom.base_height = 2*inst->cfg.window_border;
+ geom.width_inc = inst->font_width;
+ geom.height_inc = inst->font_height;
+ geom.min_aspect = geom.max_aspect = 0;
+ gtk_window_set_geometry_hints(GTK_WINDOW(inst->window), inst->area, &geom,
+ GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE |
+ GDK_HINT_RESIZE_INC);
+}
+
+void clear_scrollback_menuitem(GtkMenuItem *item, gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+ term_clrsb(inst->term);
+}
+
+void reset_terminal_menuitem(GtkMenuItem *item, gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+ term_pwron(inst->term);
+ if (inst->ldisc)
+ ldisc_send(inst->ldisc, NULL, 0, 0);
+}
+
+void copy_all_menuitem(GtkMenuItem *item, gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+ term_copyall(inst->term);
+}
+
+void special_menuitem(GtkMenuItem *item, gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+ int code = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item),
+ "user-data"));
+
+ if (inst->back)
+ inst->back->special(inst->backhandle, code);
+}
+
+void about_menuitem(GtkMenuItem *item, gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+ about_box(inst->window);
+}
+
+void event_log_menuitem(GtkMenuItem *item, gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+ showeventlog(inst->eventlogstuff, inst->window);
+}
+
+void change_settings_menuitem(GtkMenuItem *item, gpointer data)
+{
+ /* This maps colour indices in inst->cfg to those used in inst->cols. */
+ static const int ww[] = {
+ 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21,
+ 0, 1, 2, 3, 4, 5
+ };
+ struct gui_data *inst = (struct gui_data *)data;
+ char *title = dupcat(appname, " Reconfiguration", NULL);
+ Config cfg2, oldcfg;
+ int i, need_size;
+
+ cfg2 = inst->cfg; /* structure copy */
+
+ if (do_config_box(title, &cfg2, 1)) {
+
+ oldcfg = inst->cfg; /* structure copy */
+ inst->cfg = cfg2; /* structure copy */
+
+ /* Pass new config data to the logging module */
+ log_reconfig(inst->logctx, &cfg2);
+ /*
+ * Flush the line discipline's edit buffer in the case
+ * where local editing has just been disabled.
+ */
+ if (inst->ldisc)
+ ldisc_send(inst->ldisc, NULL, 0, 0);
+ /* Pass new config data to the terminal */
+ term_reconfig(inst->term, &cfg2);
+ /* Pass new config data to the back end */
+ if (inst->back)
+ inst->back->reconfig(inst->backhandle, &cfg2);
+
+ /*
+ * Just setting inst->cfg is sufficient to cause colour
+ * setting changes to appear on the next ESC]R palette
+ * reset. But we should also check whether any colour
+ * settings have been changed, and revert the ones that
+ * have to the new default, on the assumption that the user
+ * is most likely to want an immediate update.
+ */
+ for (i = 0; i < NCOLOURS; i++) {
+ if (oldcfg.colours[ww[i]][0] != cfg2.colours[ww[i]][0] ||
+ oldcfg.colours[ww[i]][1] != cfg2.colours[ww[i]][1] ||
+ oldcfg.colours[ww[i]][2] != cfg2.colours[ww[i]][2]) {
+ real_palette_set(inst, i, cfg2.colours[ww[i]][0],
+ cfg2.colours[ww[i]][1],
+ cfg2.colours[ww[i]][2]);
+
+ /*
+ * If the default background has changed, we must
+ * repaint the space in between the window border
+ * and the text area.
+ */
+ if (i == 18) {
+ set_window_background(inst);
+ draw_backing_rect(inst);
+ }
+ }
+ }
+
+ /*
+ * If the scrollbar needs to be shown, hidden, or moved
+ * from one end to the other of the window, do so now.
+ */
+ if (oldcfg.scrollbar != cfg2.scrollbar) {
+ if (cfg2.scrollbar)
+ gtk_widget_show(inst->sbar);
+ else
+ gtk_widget_hide(inst->sbar);
+ }
+ if (oldcfg.scrollbar_on_left != cfg2.scrollbar_on_left) {
+ gtk_box_reorder_child(inst->hbox, inst->sbar,
+ cfg2.scrollbar_on_left ? 0 : 1);
+ }
+
+ /*
+ * Change the window title, if required.
+ */
+ if (strcmp(oldcfg.wintitle, cfg2.wintitle))
+ set_title(inst, cfg2.wintitle);
+ set_window_titles(inst);
+
+ /*
+ * Redo the whole tangled fonts and Unicode mess if
+ * necessary.
+ */
+ if (strcmp(oldcfg.font.name, cfg2.font.name) ||
+ strcmp(oldcfg.boldfont.name, cfg2.boldfont.name) ||
+ strcmp(oldcfg.widefont.name, cfg2.widefont.name) ||
+ strcmp(oldcfg.wideboldfont.name, cfg2.wideboldfont.name) ||
+ strcmp(oldcfg.line_codepage, cfg2.line_codepage) ||
+ oldcfg.vtmode != cfg2.vtmode ||
+ oldcfg.shadowbold != cfg2.shadowbold) {
+ setup_fonts_ucs(inst);
+ need_size = 1;
+ } else
+ need_size = 0;
+
+ /*
+ * Resize the window.
+ */
+ if (oldcfg.width != cfg2.width || oldcfg.height != cfg2.height ||
+ oldcfg.window_border != cfg2.window_border || need_size) {
+ set_geom_hints(inst);
+ request_resize(inst, cfg2.width, cfg2.height);
+ } else {
+ /*
+ * The above will have caused a call to term_size() for
+ * us if it happened. If the user has fiddled with only
+ * the scrollback size, the above will not have
+ * happened and we will need an explicit term_size()
+ * here.
+ */
+ if (oldcfg.savelines != cfg2.savelines)
+ term_size(inst->term, inst->term->rows, inst->term->cols,
+ cfg2.savelines);
+ }
+
+ term_invalidate(inst->term);
+
+ /*
+ * We do an explicit full redraw here to ensure the window
+ * border has been redrawn as well as the text area.
+ */
+ gtk_widget_queue_draw(inst->area);
+ }
+ sfree(title);
+}
+
+void fork_and_exec_self(struct gui_data *inst, int fd_to_close, ...)