+++ /dev/null
-/*\r
- * gtkwin.c: the main code that runs a PuTTY terminal emulator and\r
- * backend in a GTK window.\r
- */\r
-\r
-#define _GNU_SOURCE\r
-\r
-#include <string.h>\r
-#include <assert.h>\r
-#include <stdlib.h>\r
-#include <string.h>\r
-#include <signal.h>\r
-#include <stdio.h>\r
-#include <time.h>\r
-#include <errno.h>\r
-#include <fcntl.h>\r
-#include <unistd.h>\r
-#include <sys/types.h>\r
-#include <sys/wait.h>\r
-#include <gtk/gtk.h>\r
-#include <gdk/gdkkeysyms.h>\r
-#include <gdk/gdkx.h>\r
-#include <X11/Xlib.h>\r
-#include <X11/Xutil.h>\r
-#include <X11/Xatom.h>\r
-\r
-#define PUTTY_DO_GLOBALS /* actually _define_ globals */\r
-\r
-#include "putty.h"\r
-#include "terminal.h"\r
-#include "gtkfont.h"\r
-\r
-#define CAT2(x,y) x ## y\r
-#define CAT(x,y) CAT2(x,y)\r
-#define ASSERT(x) enum {CAT(assertion_,__LINE__) = 1 / (x)}\r
-\r
-#if GTK_CHECK_VERSION(2,0,0)\r
-ASSERT(sizeof(long) <= sizeof(gsize));\r
-#define LONG_TO_GPOINTER(l) GSIZE_TO_POINTER(l)\r
-#define GPOINTER_TO_LONG(p) GPOINTER_TO_SIZE(p)\r
-#else /* Gtk 1.2 */\r
-ASSERT(sizeof(long) <= sizeof(gpointer));\r
-#define LONG_TO_GPOINTER(l) ((gpointer)(long)(l))\r
-#define GPOINTER_TO_LONG(p) ((long)(p))\r
-#endif\r
-\r
-/* Colours come in two flavours: configurable, and xterm-extended. */\r
-#define NCFGCOLOURS (lenof(((Config *)0)->colours))\r
-#define NEXTCOLOURS 240 /* 216 colour-cube plus 24 shades of grey */\r
-#define NALLCOLOURS (NCFGCOLOURS + NEXTCOLOURS)\r
-\r
-GdkAtom compound_text_atom, utf8_string_atom;\r
-\r
-extern char **pty_argv; /* declared in pty.c */\r
-extern int use_pty_argv;\r
-\r
-/*\r
- * Timers are global across all sessions (even if we were handling\r
- * multiple sessions, which we aren't), so the current timer ID is\r
- * a global variable.\r
- */\r
-static guint timer_id = 0;\r
-\r
-struct gui_data {\r
- GtkWidget *window, *area, *sbar;\r
- GtkBox *hbox;\r
- GtkAdjustment *sbar_adjust;\r
- GtkWidget *menu, *specialsmenu, *specialsitem1, *specialsitem2,\r
- *restartitem;\r
- GtkWidget *sessionsmenu;\r
- GdkPixmap *pixmap;\r
- unifont *fonts[4]; /* normal, bold, wide, widebold */\r
- int xpos, ypos, gotpos, gravity;\r
- GdkCursor *rawcursor, *textcursor, *blankcursor, *waitcursor, *currcursor;\r
- GdkColor cols[NALLCOLOURS];\r
- GdkColormap *colmap;\r
- wchar_t *pastein_data;\r
- int direct_to_font;\r
- int pastein_data_len;\r
- char *pasteout_data, *pasteout_data_ctext, *pasteout_data_utf8;\r
- int pasteout_data_len, pasteout_data_ctext_len, pasteout_data_utf8_len;\r
- int font_width, font_height;\r
- int width, height;\r
- int ignore_sbar;\r
- int mouseptr_visible;\r
- int busy_status;\r
- guint term_paste_idle_id;\r
- guint term_exit_idle_id;\r
- int alt_keycode;\r
- int alt_digits;\r
- char wintitle[sizeof(((Config *)0)->wintitle)];\r
- char icontitle[sizeof(((Config *)0)->wintitle)];\r
- int master_fd, master_func_id;\r
- void *ldisc;\r
- Backend *back;\r
- void *backhandle;\r
- Terminal *term;\r
- void *logctx;\r
- int exited;\r
- struct unicode_data ucsdata;\r
- Config cfg;\r
- void *eventlogstuff;\r
- char *progname, **gtkargvstart;\r
- int ngtkargs;\r
- guint32 input_event_time; /* Timestamp of the most recent input event. */\r
- int reconfiguring;\r
-};\r
-\r
-struct draw_ctx {\r
- GdkGC *gc;\r
- struct gui_data *inst;\r
-};\r
-\r
-static int send_raw_mouse;\r
-\r
-static char *app_name = "pterm";\r
-\r
-static void start_backend(struct gui_data *inst);\r
-\r
-char *x_get_default(const char *key)\r
-{\r
- return XGetDefault(GDK_DISPLAY(), app_name, key);\r
-}\r
-\r
-void connection_fatal(void *frontend, char *p, ...)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
-\r
- va_list ap;\r
- char *msg;\r
- va_start(ap, p);\r
- msg = dupvprintf(p, ap);\r
- va_end(ap);\r
- inst->exited = TRUE;\r
- fatal_message_box(inst->window, msg);\r
- sfree(msg);\r
- if (inst->cfg.close_on_exit == FORCE_ON)\r
- cleanup_exit(1);\r
-}\r
-\r
-/*\r
- * Default settings that are specific to pterm.\r
- */\r
-FontSpec platform_default_fontspec(const char *name)\r
-{\r
- FontSpec ret;\r
- if (!strcmp(name, "Font"))\r
- strcpy(ret.name, "server:fixed");\r
- else\r
- *ret.name = '\0';\r
- return ret;\r
-}\r
-\r
-Filename platform_default_filename(const char *name)\r
-{\r
- Filename ret;\r
- if (!strcmp(name, "LogFileName"))\r
- strcpy(ret.path, "putty.log");\r
- else\r
- *ret.path = '\0';\r
- return ret;\r
-}\r
-\r
-char *platform_default_s(const char *name)\r
-{\r
- if (!strcmp(name, "SerialLine"))\r
- return dupstr("/dev/ttyS0");\r
- return NULL;\r
-}\r
-\r
-int platform_default_i(const char *name, int def)\r
-{\r
- if (!strcmp(name, "CloseOnExit"))\r
- return 2; /* maps to FORCE_ON after painful rearrangement :-( */\r
- if (!strcmp(name, "WinNameAlways"))\r
- return 0; /* X natively supports icon titles, so use 'em by default */\r
- return def;\r
-}\r
-\r
-/* Dummy routine, only required in plink. */\r
-void ldisc_update(void *frontend, int echo, int edit)\r
-{\r
-}\r
-\r
-char *get_ttymode(void *frontend, const char *mode)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- return term_get_ttymode(inst->term, mode);\r
-}\r
-\r
-int from_backend(void *frontend, int is_stderr, const char *data, int len)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- return term_data(inst->term, is_stderr, data, len);\r
-}\r
-\r
-int from_backend_untrusted(void *frontend, const char *data, int len)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- return term_data_untrusted(inst->term, data, len);\r
-}\r
-\r
-int get_userpass_input(prompts_t *p, unsigned char *in, int inlen)\r
-{\r
- struct gui_data *inst = (struct gui_data *)p->frontend;\r
- int ret;\r
- ret = cmdline_get_passwd_input(p, in, inlen);\r
- if (ret == -1)\r
- ret = term_get_userpass_input(inst->term, p, in, inlen);\r
- return ret;\r
-}\r
-\r
-void logevent(void *frontend, const char *string)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
-\r
- log_eventlog(inst->logctx, string);\r
-\r
- logevent_dlg(inst->eventlogstuff, string);\r
-}\r
-\r
-int font_dimension(void *frontend, int which)/* 0 for width, 1 for height */\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
-\r
- if (which)\r
- return inst->font_height;\r
- else\r
- return inst->font_width;\r
-}\r
-\r
-/*\r
- * Translate a raw mouse button designation (LEFT, MIDDLE, RIGHT)\r
- * into a cooked one (SELECT, EXTEND, PASTE).\r
- * \r
- * In Unix, this is not configurable; the X button arrangement is\r
- * rock-solid across all applications, everyone has a three-button\r
- * mouse or a means of faking it, and there is no need to switch\r
- * buttons around at all.\r
- */\r
-static Mouse_Button translate_button(Mouse_Button button)\r
-{\r
- /* struct gui_data *inst = (struct gui_data *)frontend; */\r
-\r
- if (button == MBT_LEFT)\r
- return MBT_SELECT;\r
- if (button == MBT_MIDDLE)\r
- return MBT_PASTE;\r
- if (button == MBT_RIGHT)\r
- return MBT_EXTEND;\r
- return 0; /* shouldn't happen */\r
-}\r
-\r
-/*\r
- * Return the top-level GtkWindow associated with a particular\r
- * front end instance.\r
- */\r
-void *get_window(void *frontend)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- return inst->window;\r
-}\r
-\r
-/*\r
- * Minimise or restore the window in response to a server-side\r
- * request.\r
- */\r
-void set_iconic(void *frontend, int iconic)\r
-{\r
- /*\r
- * GTK 1.2 doesn't know how to do this.\r
- */\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- if (iconic)\r
- gtk_window_iconify(GTK_WINDOW(inst->window));\r
- else\r
- gtk_window_deiconify(GTK_WINDOW(inst->window));\r
-#endif\r
-}\r
-\r
-/*\r
- * Move the window in response to a server-side request.\r
- */\r
-void move_window(void *frontend, int x, int y)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- /*\r
- * I assume that when the GTK version of this call is available\r
- * we should use it. Not sure how it differs from the GDK one,\r
- * though.\r
- */\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- gtk_window_move(GTK_WINDOW(inst->window), x, y);\r
-#else\r
- gdk_window_move(inst->window->window, x, y);\r
-#endif\r
-}\r
-\r
-/*\r
- * Move the window to the top or bottom of the z-order in response\r
- * to a server-side request.\r
- */\r
-void set_zorder(void *frontend, int top)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- if (top)\r
- gdk_window_raise(inst->window->window);\r
- else\r
- gdk_window_lower(inst->window->window);\r
-}\r
-\r
-/*\r
- * Refresh the window in response to a server-side request.\r
- */\r
-void refresh_window(void *frontend)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- term_invalidate(inst->term);\r
-}\r
-\r
-/*\r
- * Maximise or restore the window in response to a server-side\r
- * request.\r
- */\r
-void set_zoomed(void *frontend, int zoomed)\r
-{\r
- /*\r
- * GTK 1.2 doesn't know how to do this.\r
- */\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- if (zoomed)\r
- gtk_window_maximize(GTK_WINDOW(inst->window));\r
- else\r
- gtk_window_unmaximize(GTK_WINDOW(inst->window));\r
-#endif\r
-}\r
-\r
-/*\r
- * Report whether the window is iconic, for terminal reports.\r
- */\r
-int is_iconic(void *frontend)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- return !gdk_window_is_viewable(inst->window->window);\r
-}\r
-\r
-/*\r
- * Report the window's position, for terminal reports.\r
- */\r
-void get_window_pos(void *frontend, int *x, int *y)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- /*\r
- * I assume that when the GTK version of this call is available\r
- * we should use it. Not sure how it differs from the GDK one,\r
- * though.\r
- */\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- gtk_window_get_position(GTK_WINDOW(inst->window), x, y);\r
-#else\r
- gdk_window_get_position(inst->window->window, x, y);\r
-#endif\r
-}\r
-\r
-/*\r
- * Report the window's pixel size, for terminal reports.\r
- */\r
-void get_window_pixels(void *frontend, int *x, int *y)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- /*\r
- * I assume that when the GTK version of this call is available\r
- * we should use it. Not sure how it differs from the GDK one,\r
- * though.\r
- */\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- gtk_window_get_size(GTK_WINDOW(inst->window), x, y);\r
-#else\r
- gdk_window_get_size(inst->window->window, x, y);\r
-#endif\r
-}\r
-\r
-/*\r
- * Return the window or icon title.\r
- */\r
-char *get_window_title(void *frontend, int icon)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- return icon ? inst->icontitle : inst->wintitle;\r
-}\r
-\r
-gint delete_window(GtkWidget *widget, GdkEvent *event, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- if (!inst->exited && inst->cfg.warn_on_close) {\r
- if (!reallyclose(inst))\r
- return TRUE;\r
- }\r
- return FALSE;\r
-}\r
-\r
-static void update_mouseptr(struct gui_data *inst)\r
-{\r
- switch (inst->busy_status) {\r
- case BUSY_NOT:\r
- if (!inst->mouseptr_visible) {\r
- gdk_window_set_cursor(inst->area->window, inst->blankcursor);\r
- } else if (send_raw_mouse) {\r
- gdk_window_set_cursor(inst->area->window, inst->rawcursor);\r
- } else {\r
- gdk_window_set_cursor(inst->area->window, inst->textcursor);\r
- }\r
- break;\r
- case BUSY_WAITING: /* XXX can we do better? */\r
- case BUSY_CPU:\r
- /* We always display these cursors. */\r
- gdk_window_set_cursor(inst->area->window, inst->waitcursor);\r
- break;\r
- default:\r
- assert(0);\r
- }\r
-}\r
-\r
-static void show_mouseptr(struct gui_data *inst, int show)\r
-{\r
- if (!inst->cfg.hide_mouseptr)\r
- show = 1;\r
- inst->mouseptr_visible = show;\r
- update_mouseptr(inst);\r
-}\r
-\r
-void draw_backing_rect(struct gui_data *inst)\r
-{\r
- GdkGC *gc = gdk_gc_new(inst->area->window);\r
- gdk_gc_set_foreground(gc, &inst->cols[258]); /* default background */\r
- gdk_draw_rectangle(inst->pixmap, gc, 1, 0, 0,\r
- inst->cfg.width * inst->font_width + 2*inst->cfg.window_border,\r
- inst->cfg.height * inst->font_height + 2*inst->cfg.window_border);\r
- gdk_gc_unref(gc);\r
-}\r
-\r
-gint configure_area(GtkWidget *widget, GdkEventConfigure *event, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- int w, h, need_size = 0;\r
-\r
- /*\r
- * See if the terminal size has changed, in which case we must\r
- * let the terminal know.\r
- */\r
- w = (event->width - 2*inst->cfg.window_border) / inst->font_width;\r
- h = (event->height - 2*inst->cfg.window_border) / inst->font_height;\r
- if (w != inst->width || h != inst->height) {\r
- inst->cfg.width = inst->width = w;\r
- inst->cfg.height = inst->height = h;\r
- need_size = 1;\r
- }\r
-\r
- if (inst->pixmap) {\r
- gdk_pixmap_unref(inst->pixmap);\r
- inst->pixmap = NULL;\r
- }\r
-\r
- inst->pixmap = gdk_pixmap_new(widget->window,\r
- (inst->cfg.width * inst->font_width +\r
- 2*inst->cfg.window_border),\r
- (inst->cfg.height * inst->font_height +\r
- 2*inst->cfg.window_border), -1);\r
-\r
- draw_backing_rect(inst);\r
-\r
- if (need_size && inst->term) {\r
- term_size(inst->term, h, w, inst->cfg.savelines);\r
- }\r
-\r
- if (inst->term)\r
- term_invalidate(inst->term);\r
-\r
- return TRUE;\r
-}\r
-\r
-gint expose_area(GtkWidget *widget, GdkEventExpose *event, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
-\r
- /*\r
- * Pass the exposed rectangle to terminal.c, which will call us\r
- * back to do the actual painting.\r
- */\r
- if (inst->pixmap) {\r
- gdk_draw_pixmap(widget->window,\r
- widget->style->fg_gc[GTK_WIDGET_STATE(widget)],\r
- inst->pixmap,\r
- event->area.x, event->area.y,\r
- event->area.x, event->area.y,\r
- event->area.width, event->area.height);\r
- }\r
- return TRUE;\r
-}\r
-\r
-#define KEY_PRESSED(k) \\r
- (inst->keystate[(k) / 32] & (1 << ((k) % 32)))\r
-\r
-gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- char output[256];\r
- wchar_t ucsoutput[2];\r
- int ucsval, start, end, special, output_charset, use_ucsoutput;\r
-\r
- /* Remember the timestamp. */\r
- inst->input_event_time = event->time;\r
-\r
- /* By default, nothing is generated. */\r
- end = start = 0;\r
- special = use_ucsoutput = FALSE;\r
- output_charset = CS_ISO8859_1;\r
-\r
- /*\r
- * If Alt is being released after typing an Alt+numberpad\r
- * sequence, we should generate the code that was typed.\r
- * \r
- * Note that we only do this if more than one key was actually\r
- * pressed - I don't think Alt+NumPad4 should be ^D or that\r
- * Alt+NumPad3 should be ^C, for example. There's no serious\r
- * inconvenience in having to type a zero before a single-digit\r
- * character code.\r
- */\r
- if (event->type == GDK_KEY_RELEASE &&\r
- (event->keyval == GDK_Meta_L || event->keyval == GDK_Alt_L ||\r
- event->keyval == GDK_Meta_R || event->keyval == GDK_Alt_R) &&\r
- inst->alt_keycode >= 0 && inst->alt_digits > 1) {\r
-#ifdef KEY_DEBUGGING\r
- printf("Alt key up, keycode = %d\n", inst->alt_keycode);\r
-#endif\r
- /*\r
- * FIXME: we might usefully try to do something clever here\r
- * about interpreting the generated key code in a way that's\r
- * appropriate to the line code page.\r
- */\r
- output[0] = inst->alt_keycode;\r
- end = 1;\r
- goto done;\r
- }\r
-\r
- if (event->type == GDK_KEY_PRESS) {\r
-#ifdef KEY_DEBUGGING\r
- {\r
- int i;\r
- printf("keypress: keyval = %04x, state = %08x; string =",\r
- event->keyval, event->state);\r
- for (i = 0; event->string[i]; i++)\r
- printf(" %02x", (unsigned char) event->string[i]);\r
- printf("\n");\r
- }\r
-#endif\r
-\r
- /*\r
- * NYI: Compose key (!!! requires Unicode faff before even trying)\r
- */\r
-\r
- /*\r
- * If Alt has just been pressed, we start potentially\r
- * accumulating an Alt+numberpad code. We do this by\r
- * setting alt_keycode to -1 (nothing yet but plausible).\r
- */\r
- if ((event->keyval == GDK_Meta_L || event->keyval == GDK_Alt_L ||\r
- event->keyval == GDK_Meta_R || event->keyval == GDK_Alt_R)) {\r
- inst->alt_keycode = -1;\r
- inst->alt_digits = 0;\r
- goto done; /* this generates nothing else */\r
- }\r
-\r
- /*\r
- * If we're seeing a numberpad key press with Mod1 down,\r
- * consider adding it to alt_keycode if that's sensible.\r
- * Anything _else_ with Mod1 down cancels any possibility\r
- * of an ALT keycode: we set alt_keycode to -2.\r
- */\r
- if ((event->state & GDK_MOD1_MASK) && inst->alt_keycode != -2) {\r
- int digit = -1;\r
- switch (event->keyval) {\r
- case GDK_KP_0: case GDK_KP_Insert: digit = 0; break;\r
- case GDK_KP_1: case GDK_KP_End: digit = 1; break;\r
- case GDK_KP_2: case GDK_KP_Down: digit = 2; break;\r
- case GDK_KP_3: case GDK_KP_Page_Down: digit = 3; break;\r
- case GDK_KP_4: case GDK_KP_Left: digit = 4; break;\r
- case GDK_KP_5: case GDK_KP_Begin: digit = 5; break;\r
- case GDK_KP_6: case GDK_KP_Right: digit = 6; break;\r
- case GDK_KP_7: case GDK_KP_Home: digit = 7; break;\r
- case GDK_KP_8: case GDK_KP_Up: digit = 8; break;\r
- case GDK_KP_9: case GDK_KP_Page_Up: digit = 9; break;\r
- }\r
- if (digit < 0)\r
- inst->alt_keycode = -2; /* it's invalid */\r
- else {\r
-#ifdef KEY_DEBUGGING\r
- printf("Adding digit %d to keycode %d", digit,\r
- inst->alt_keycode);\r
-#endif\r
- if (inst->alt_keycode == -1)\r
- inst->alt_keycode = digit; /* one-digit code */\r
- else\r
- inst->alt_keycode = inst->alt_keycode * 10 + digit;\r
- inst->alt_digits++;\r
-#ifdef KEY_DEBUGGING\r
- printf(" gives new code %d\n", inst->alt_keycode);\r
-#endif\r
- /* Having used this digit, we now do nothing more with it. */\r
- goto done;\r
- }\r
- }\r
-\r
- /*\r
- * Shift-PgUp and Shift-PgDn don't even generate keystrokes\r
- * at all.\r
- */\r
- if (event->keyval == GDK_Page_Up && (event->state & GDK_SHIFT_MASK)) {\r
- term_scroll(inst->term, 0, -inst->cfg.height/2);\r
- return TRUE;\r
- }\r
- if (event->keyval == GDK_Page_Up && (event->state & GDK_CONTROL_MASK)) {\r
- term_scroll(inst->term, 0, -1);\r
- return TRUE;\r
- }\r
- if (event->keyval == GDK_Page_Down && (event->state & GDK_SHIFT_MASK)) {\r
- term_scroll(inst->term, 0, +inst->cfg.height/2);\r
- return TRUE;\r
- }\r
- if (event->keyval == GDK_Page_Down && (event->state & GDK_CONTROL_MASK)) {\r
- term_scroll(inst->term, 0, +1);\r
- return TRUE;\r
- }\r
-\r
- /*\r
- * Neither does Shift-Ins.\r
- */\r
- if (event->keyval == GDK_Insert && (event->state & GDK_SHIFT_MASK)) {\r
- request_paste(inst);\r
- return TRUE;\r
- }\r
-\r
- special = FALSE;\r
- use_ucsoutput = FALSE;\r
-\r
- /* ALT+things gives leading Escape. */\r
- output[0] = '\033';\r
-#if !GTK_CHECK_VERSION(2,0,0)\r
- /*\r
- * In vanilla X, and hence also GDK 1.2, the string received\r
- * as part of a keyboard event is assumed to be in\r
- * ISO-8859-1. (Seems woefully shortsighted in i18n terms,\r
- * but it's true: see the man page for XLookupString(3) for\r
- * confirmation.)\r
- */\r
- output_charset = CS_ISO8859_1;\r
- strncpy(output+1, event->string, lenof(output)-1);\r
-#else\r
- /*\r
- * GDK 2.0 arranges to have done some translation for us: in\r
- * GDK 2.0, event->string is encoded in the current locale.\r
- *\r
- * (However, it's also deprecated; we really ought to be\r
- * using a GTKIMContext.)\r
- *\r
- * So we use the standard C library function mbstowcs() to\r
- * convert from the current locale into Unicode; from there\r
- * we can convert to whatever PuTTY is currently working in.\r
- * (In fact I convert straight back to UTF-8 from\r
- * wide-character Unicode, for the sake of simplicity: that\r
- * way we can still use exactly the same code to manipulate\r
- * the string, such as prefixing ESC.)\r
- */\r
- output_charset = CS_UTF8;\r
- {\r
- wchar_t widedata[32], *wp;\r
- int wlen;\r
- int ulen;\r
-\r
- wlen = mb_to_wc(DEFAULT_CODEPAGE, 0,\r
- event->string, strlen(event->string),\r
- widedata, lenof(widedata)-1);\r
-\r
- wp = widedata;\r
- ulen = charset_from_unicode(&wp, &wlen, output+1, lenof(output)-2,\r
- CS_UTF8, NULL, NULL, 0);\r
- output[1+ulen] = '\0';\r
- }\r
-#endif\r
-\r
- if (!output[1] &&\r
- (ucsval = keysym_to_unicode(event->keyval)) >= 0) {\r
- ucsoutput[0] = '\033';\r
- ucsoutput[1] = ucsval;\r
- use_ucsoutput = TRUE;\r
- end = 2;\r
- } else {\r
- output[lenof(output)-1] = '\0';\r
- end = strlen(output);\r
- }\r
- if (event->state & GDK_MOD1_MASK) {\r
- start = 0;\r
- if (end == 1) end = 0;\r
- } else\r
- start = 1;\r
-\r
- /* Control-` is the same as Control-\ (unless gtk has a better idea) */\r
- if (!output[1] && event->keyval == '`' &&\r
- (event->state & GDK_CONTROL_MASK)) {\r
- output[1] = '\x1C';\r
- use_ucsoutput = FALSE;\r
- end = 2;\r
- }\r
-\r
- /* Control-Break sends a Break special to the backend */\r
- if (event->keyval == GDK_Break &&\r
- (event->state & GDK_CONTROL_MASK)) {\r
- if (inst->back)\r
- inst->back->special(inst->backhandle, TS_BRK);\r
- return TRUE;\r
- }\r
-\r
- /* We handle Return ourselves, because it needs to be flagged as\r
- * special to ldisc. */\r
- if (event->keyval == GDK_Return) {\r
- output[1] = '\015';\r
- use_ucsoutput = FALSE;\r
- end = 2;\r
- special = TRUE;\r
- }\r
-\r
- /* Control-2, Control-Space and Control-@ are NUL */\r
- if (!output[1] &&\r
- (event->keyval == ' ' || event->keyval == '2' ||\r
- event->keyval == '@') &&\r
- (event->state & (GDK_SHIFT_MASK |\r
- GDK_CONTROL_MASK)) == GDK_CONTROL_MASK) {\r
- output[1] = '\0';\r
- use_ucsoutput = FALSE;\r
- end = 2;\r
- }\r
-\r
- /* Control-Shift-Space is 160 (ISO8859 nonbreaking space) */\r
- if (!output[1] && event->keyval == ' ' &&\r
- (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) ==\r
- (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) {\r
- output[1] = '\240';\r
- output_charset = CS_ISO8859_1;\r
- use_ucsoutput = FALSE;\r
- end = 2;\r
- }\r
-\r
- /* We don't let GTK tell us what Backspace is! We know better. */\r
- if (event->keyval == GDK_BackSpace &&\r
- !(event->state & GDK_SHIFT_MASK)) {\r
- output[1] = inst->cfg.bksp_is_delete ? '\x7F' : '\x08';\r
- use_ucsoutput = FALSE;\r
- end = 2;\r
- special = TRUE;\r
- }\r
- /* For Shift Backspace, do opposite of what is configured. */\r
- if (event->keyval == GDK_BackSpace &&\r
- (event->state & GDK_SHIFT_MASK)) {\r
- output[1] = inst->cfg.bksp_is_delete ? '\x08' : '\x7F';\r
- use_ucsoutput = FALSE;\r
- end = 2;\r
- special = TRUE;\r
- }\r
-\r
- /* Shift-Tab is ESC [ Z */\r
- if (event->keyval == GDK_ISO_Left_Tab ||\r
- (event->keyval == GDK_Tab && (event->state & GDK_SHIFT_MASK))) {\r
- end = 1 + sprintf(output+1, "\033[Z");\r
- use_ucsoutput = FALSE;\r
- }\r
- /* And normal Tab is Tab, if the keymap hasn't already told us.\r
- * (Curiously, at least one version of the MacOS 10.5 X server\r
- * doesn't translate Tab for us. */\r
- if (event->keyval == GDK_Tab && end <= 1) {\r
- output[1] = '\t';\r
- end = 2;\r
- }\r
-\r
- /*\r
- * NetHack keypad mode.\r
- */\r
- if (inst->cfg.nethack_keypad) {\r
- char *keys = NULL;\r
- switch (event->keyval) {\r
- case GDK_KP_1: case GDK_KP_End: keys = "bB\002"; break;\r
- case GDK_KP_2: case GDK_KP_Down: keys = "jJ\012"; break;\r
- case GDK_KP_3: case GDK_KP_Page_Down: keys = "nN\016"; break;\r
- case GDK_KP_4: case GDK_KP_Left: keys = "hH\010"; break;\r
- case GDK_KP_5: case GDK_KP_Begin: keys = "..."; break;\r
- case GDK_KP_6: case GDK_KP_Right: keys = "lL\014"; break;\r
- case GDK_KP_7: case GDK_KP_Home: keys = "yY\031"; break;\r
- case GDK_KP_8: case GDK_KP_Up: keys = "kK\013"; break;\r
- case GDK_KP_9: case GDK_KP_Page_Up: keys = "uU\025"; break;\r
- }\r
- if (keys) {\r
- end = 2;\r
- if (event->state & GDK_CONTROL_MASK)\r
- output[1] = keys[2];\r
- else if (event->state & GDK_SHIFT_MASK)\r
- output[1] = keys[1];\r
- else\r
- output[1] = keys[0];\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- }\r
-\r
- /*\r
- * Application keypad mode.\r
- */\r
- if (inst->term->app_keypad_keys && !inst->cfg.no_applic_k) {\r
- int xkey = 0;\r
- switch (event->keyval) {\r
- case GDK_Num_Lock: xkey = 'P'; break;\r
- case GDK_KP_Divide: xkey = 'Q'; break;\r
- case GDK_KP_Multiply: xkey = 'R'; break;\r
- case GDK_KP_Subtract: xkey = 'S'; break;\r
- /*\r
- * Keypad + is tricky. It covers a space that would\r
- * be taken up on the VT100 by _two_ keys; so we\r
- * let Shift select between the two. Worse still,\r
- * in xterm function key mode we change which two...\r
- */\r
- case GDK_KP_Add:\r
- if (inst->cfg.funky_type == FUNKY_XTERM) {\r
- if (event->state & GDK_SHIFT_MASK)\r
- xkey = 'l';\r
- else\r
- xkey = 'k';\r
- } else if (event->state & GDK_SHIFT_MASK)\r
- xkey = 'm';\r
- else\r
- xkey = 'l';\r
- break;\r
- case GDK_KP_Enter: xkey = 'M'; break;\r
- case GDK_KP_0: case GDK_KP_Insert: xkey = 'p'; break;\r
- case GDK_KP_1: case GDK_KP_End: xkey = 'q'; break;\r
- case GDK_KP_2: case GDK_KP_Down: xkey = 'r'; break;\r
- case GDK_KP_3: case GDK_KP_Page_Down: xkey = 's'; break;\r
- case GDK_KP_4: case GDK_KP_Left: xkey = 't'; break;\r
- case GDK_KP_5: case GDK_KP_Begin: xkey = 'u'; break;\r
- case GDK_KP_6: case GDK_KP_Right: xkey = 'v'; break;\r
- case GDK_KP_7: case GDK_KP_Home: xkey = 'w'; break;\r
- case GDK_KP_8: case GDK_KP_Up: xkey = 'x'; break;\r
- case GDK_KP_9: case GDK_KP_Page_Up: xkey = 'y'; break;\r
- case GDK_KP_Decimal: case GDK_KP_Delete: xkey = 'n'; break;\r
- }\r
- if (xkey) {\r
- if (inst->term->vt52_mode) {\r
- if (xkey >= 'P' && xkey <= 'S')\r
- end = 1 + sprintf(output+1, "\033%c", xkey);\r
- else\r
- end = 1 + sprintf(output+1, "\033?%c", xkey);\r
- } else\r
- end = 1 + sprintf(output+1, "\033O%c", xkey);\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- }\r
-\r
- /*\r
- * Next, all the keys that do tilde codes. (ESC '[' nn '~',\r
- * for integer decimal nn.)\r
- *\r
- * We also deal with the weird ones here. Linux VCs replace F1\r
- * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but\r
- * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w\r
- * respectively.\r
- */\r
- {\r
- int code = 0;\r
- switch (event->keyval) {\r
- case GDK_F1:\r
- code = (event->state & GDK_SHIFT_MASK ? 23 : 11);\r
- break;\r
- case GDK_F2:\r
- code = (event->state & GDK_SHIFT_MASK ? 24 : 12);\r
- break;\r
- case GDK_F3:\r
- code = (event->state & GDK_SHIFT_MASK ? 25 : 13);\r
- break;\r
- case GDK_F4:\r
- code = (event->state & GDK_SHIFT_MASK ? 26 : 14);\r
- break;\r
- case GDK_F5:\r
- code = (event->state & GDK_SHIFT_MASK ? 28 : 15);\r
- break;\r
- case GDK_F6:\r
- code = (event->state & GDK_SHIFT_MASK ? 29 : 17);\r
- break;\r
- case GDK_F7:\r
- code = (event->state & GDK_SHIFT_MASK ? 31 : 18);\r
- break;\r
- case GDK_F8:\r
- code = (event->state & GDK_SHIFT_MASK ? 32 : 19);\r
- break;\r
- case GDK_F9:\r
- code = (event->state & GDK_SHIFT_MASK ? 33 : 20);\r
- break;\r
- case GDK_F10:\r
- code = (event->state & GDK_SHIFT_MASK ? 34 : 21);\r
- break;\r
- case GDK_F11:\r
- code = 23;\r
- break;\r
- case GDK_F12:\r
- code = 24;\r
- break;\r
- case GDK_F13:\r
- code = 25;\r
- break;\r
- case GDK_F14:\r
- code = 26;\r
- break;\r
- case GDK_F15:\r
- code = 28;\r
- break;\r
- case GDK_F16:\r
- code = 29;\r
- break;\r
- case GDK_F17:\r
- code = 31;\r
- break;\r
- case GDK_F18:\r
- code = 32;\r
- break;\r
- case GDK_F19:\r
- code = 33;\r
- break;\r
- case GDK_F20:\r
- code = 34;\r
- break;\r
- }\r
- if (!(event->state & GDK_CONTROL_MASK)) switch (event->keyval) {\r
- case GDK_Home: case GDK_KP_Home:\r
- code = 1;\r
- break;\r
- case GDK_Insert: case GDK_KP_Insert:\r
- code = 2;\r
- break;\r
- case GDK_Delete: case GDK_KP_Delete:\r
- code = 3;\r
- break;\r
- case GDK_End: case GDK_KP_End:\r
- code = 4;\r
- break;\r
- case GDK_Page_Up: case GDK_KP_Page_Up:\r
- code = 5;\r
- break;\r
- case GDK_Page_Down: case GDK_KP_Page_Down:\r
- code = 6;\r
- break;\r
- }\r
- /* Reorder edit keys to physical order */\r
- if (inst->cfg.funky_type == FUNKY_VT400 && code <= 6)\r
- code = "\0\2\1\4\5\3\6"[code];\r
-\r
- if (inst->term->vt52_mode && code > 0 && code <= 6) {\r
- end = 1 + sprintf(output+1, "\x1B%c", " HLMEIG"[code]);\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
-\r
- if (inst->cfg.funky_type == FUNKY_SCO && /* SCO function keys */\r
- code >= 11 && code <= 34) {\r
- char codes[] = "MNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@[\\]^_`{";\r
- int index = 0;\r
- switch (event->keyval) {\r
- case GDK_F1: index = 0; break;\r
- case GDK_F2: index = 1; break;\r
- case GDK_F3: index = 2; break;\r
- case GDK_F4: index = 3; break;\r
- case GDK_F5: index = 4; break;\r
- case GDK_F6: index = 5; break;\r
- case GDK_F7: index = 6; break;\r
- case GDK_F8: index = 7; break;\r
- case GDK_F9: index = 8; break;\r
- case GDK_F10: index = 9; break;\r
- case GDK_F11: index = 10; break;\r
- case GDK_F12: index = 11; break;\r
- }\r
- if (event->state & GDK_SHIFT_MASK) index += 12;\r
- if (event->state & GDK_CONTROL_MASK) index += 24;\r
- end = 1 + sprintf(output+1, "\x1B[%c", codes[index]);\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- if (inst->cfg.funky_type == FUNKY_SCO && /* SCO small keypad */\r
- code >= 1 && code <= 6) {\r
- char codes[] = "HL.FIG";\r
- if (code == 3) {\r
- output[1] = '\x7F';\r
- end = 2;\r
- } else {\r
- end = 1 + sprintf(output+1, "\x1B[%c", codes[code-1]);\r
- }\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- if ((inst->term->vt52_mode || inst->cfg.funky_type == FUNKY_VT100P) &&\r
- code >= 11 && code <= 24) {\r
- int offt = 0;\r
- if (code > 15)\r
- offt++;\r
- if (code > 21)\r
- offt++;\r
- if (inst->term->vt52_mode)\r
- end = 1 + sprintf(output+1,\r
- "\x1B%c", code + 'P' - 11 - offt);\r
- else\r
- end = 1 + sprintf(output+1,\r
- "\x1BO%c", code + 'P' - 11 - offt);\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- if (inst->cfg.funky_type == FUNKY_LINUX && code >= 11 && code <= 15) {\r
- end = 1 + sprintf(output+1, "\x1B[[%c", code + 'A' - 11);\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- if (inst->cfg.funky_type == FUNKY_XTERM && code >= 11 && code <= 14) {\r
- if (inst->term->vt52_mode)\r
- end = 1 + sprintf(output+1, "\x1B%c", code + 'P' - 11);\r
- else\r
- end = 1 + sprintf(output+1, "\x1BO%c", code + 'P' - 11);\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- if (inst->cfg.rxvt_homeend && (code == 1 || code == 4)) {\r
- end = 1 + sprintf(output+1, code == 1 ? "\x1B[H" : "\x1BOw");\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- if (code) {\r
- end = 1 + sprintf(output+1, "\x1B[%d~", code);\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- }\r
-\r
- /*\r
- * Cursor keys. (This includes the numberpad cursor keys,\r
- * if we haven't already done them due to app keypad mode.)\r
- * \r
- * Here we also process un-numlocked un-appkeypadded KP5,\r
- * which sends ESC [ G.\r
- */\r
- {\r
- int xkey = 0;\r
- switch (event->keyval) {\r
- case GDK_Up: case GDK_KP_Up: xkey = 'A'; break;\r
- case GDK_Down: case GDK_KP_Down: xkey = 'B'; break;\r
- case GDK_Right: case GDK_KP_Right: xkey = 'C'; break;\r
- case GDK_Left: case GDK_KP_Left: xkey = 'D'; break;\r
- case GDK_Begin: case GDK_KP_Begin: xkey = 'G'; break;\r
- }\r
- if (xkey) {\r
- end = 1 + format_arrow_key(output+1, inst->term, xkey,\r
- event->state & GDK_CONTROL_MASK);\r
- use_ucsoutput = FALSE;\r
- goto done;\r
- }\r
- }\r
- goto done;\r
- }\r
-\r
- done:\r
-\r
- if (end-start > 0) {\r
-#ifdef KEY_DEBUGGING\r
- int i;\r
- printf("generating sequence:");\r
- for (i = start; i < end; i++)\r
- printf(" %02x", (unsigned char) output[i]);\r
- printf("\n");\r
-#endif\r
-\r
- if (special) {\r
- /*\r
- * For special control characters, the character set\r
- * should never matter.\r
- */\r
- output[end] = '\0'; /* NUL-terminate */\r
- if (inst->ldisc)\r
- ldisc_send(inst->ldisc, output+start, -2, 1);\r
- } else if (!inst->direct_to_font) {\r
- if (!use_ucsoutput) {\r
- if (inst->ldisc)\r
- lpage_send(inst->ldisc, output_charset, output+start,\r
- end-start, 1);\r
- } else {\r
- /*\r
- * We generated our own Unicode key data from the\r
- * keysym, so use that instead.\r
- */\r
- if (inst->ldisc)\r
- luni_send(inst->ldisc, ucsoutput+start, end-start, 1);\r
- }\r
- } else {\r
- /*\r
- * In direct-to-font mode, we just send the string\r
- * exactly as we received it.\r
- */\r
- if (inst->ldisc)\r
- ldisc_send(inst->ldisc, output+start, end-start, 1);\r
- }\r
-\r
- show_mouseptr(inst, 0);\r
- term_seen_key_event(inst->term);\r
- }\r
-\r
- return TRUE;\r
-}\r
-\r
-gboolean button_internal(struct gui_data *inst, guint32 timestamp,\r
- GdkEventType type, guint ebutton, guint state,\r
- gdouble ex, gdouble ey)\r
-{\r
- int shift, ctrl, alt, x, y, button, act;\r
-\r
- /* Remember the timestamp. */\r
- inst->input_event_time = timestamp;\r
-\r
- show_mouseptr(inst, 1);\r
-\r
- if (ebutton == 4 && type == GDK_BUTTON_PRESS) {\r
- term_scroll(inst->term, 0, -5);\r
- return TRUE;\r
- }\r
- if (ebutton == 5 && type == GDK_BUTTON_PRESS) {\r
- term_scroll(inst->term, 0, +5);\r
- return TRUE;\r
- }\r
-\r
- shift = state & GDK_SHIFT_MASK;\r
- ctrl = state & GDK_CONTROL_MASK;\r
- alt = state & GDK_MOD1_MASK;\r
-\r
- if (ebutton == 3 && ctrl) {\r
- gtk_menu_popup(GTK_MENU(inst->menu), NULL, NULL, NULL, NULL,\r
- ebutton, timestamp);\r
- return TRUE;\r
- }\r
-\r
- if (ebutton == 1)\r
- button = MBT_LEFT;\r
- else if (ebutton == 2)\r
- button = MBT_MIDDLE;\r
- else if (ebutton == 3)\r
- button = MBT_RIGHT;\r
- else\r
- return FALSE; /* don't even know what button! */\r
-\r
- switch (type) {\r
- case GDK_BUTTON_PRESS: act = MA_CLICK; break;\r
- case GDK_BUTTON_RELEASE: act = MA_RELEASE; break;\r
- case GDK_2BUTTON_PRESS: act = MA_2CLK; break;\r
- case GDK_3BUTTON_PRESS: act = MA_3CLK; break;\r
- default: return FALSE; /* don't know this event type */\r
- }\r
-\r
- if (send_raw_mouse && !(inst->cfg.mouse_override && shift) &&\r
- act != MA_CLICK && act != MA_RELEASE)\r
- return TRUE; /* we ignore these in raw mouse mode */\r
-\r
- x = (ex - inst->cfg.window_border) / inst->font_width;\r
- y = (ey - inst->cfg.window_border) / inst->font_height;\r
-\r
- term_mouse(inst->term, button, translate_button(button), act,\r
- x, y, shift, ctrl, alt);\r
-\r
- return TRUE;\r
-}\r
-\r
-gboolean button_event(GtkWidget *widget, GdkEventButton *event, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- return button_internal(inst, event->time, event->type, event->button,\r
- event->state, event->x, event->y);\r
-}\r
-\r
-#if GTK_CHECK_VERSION(2,0,0)\r
-/*\r
- * In GTK 2, mouse wheel events have become a new type of event.\r
- * This handler translates them back into button-4 and button-5\r
- * presses so that I don't have to change my old code too much :-)\r
- */\r
-gboolean scroll_event(GtkWidget *widget, GdkEventScroll *event, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- guint button;\r
-\r
- if (event->direction == GDK_SCROLL_UP)\r
- button = 4;\r
- else if (event->direction == GDK_SCROLL_DOWN)\r
- button = 5;\r
- else\r
- return FALSE;\r
-\r
- return button_internal(inst, event->time, GDK_BUTTON_PRESS,\r
- button, event->state, event->x, event->y);\r
-}\r
-#endif\r
-\r
-gint motion_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- int shift, ctrl, alt, x, y, button;\r
-\r
- /* Remember the timestamp. */\r
- inst->input_event_time = event->time;\r
-\r
- show_mouseptr(inst, 1);\r
-\r
- shift = event->state & GDK_SHIFT_MASK;\r
- ctrl = event->state & GDK_CONTROL_MASK;\r
- alt = event->state & GDK_MOD1_MASK;\r
- if (event->state & GDK_BUTTON1_MASK)\r
- button = MBT_LEFT;\r
- else if (event->state & GDK_BUTTON2_MASK)\r
- button = MBT_MIDDLE;\r
- else if (event->state & GDK_BUTTON3_MASK)\r
- button = MBT_RIGHT;\r
- else\r
- return FALSE; /* don't even know what button! */\r
-\r
- x = (event->x - inst->cfg.window_border) / inst->font_width;\r
- y = (event->y - inst->cfg.window_border) / inst->font_height;\r
-\r
- term_mouse(inst->term, button, translate_button(button), MA_DRAG,\r
- x, y, shift, ctrl, alt);\r
-\r
- return TRUE;\r
-}\r
-\r
-void frontend_keypress(void *handle)\r
-{\r
- struct gui_data *inst = (struct gui_data *)handle;\r
-\r
- /*\r
- * If our child process has exited but not closed, terminate on\r
- * any keypress.\r
- */\r
- if (inst->exited)\r
- exit(0);\r
-}\r
-\r
-static gint idle_exit_func(gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- int exitcode;\r
-\r
- if (!inst->exited &&\r
- (exitcode = inst->back->exitcode(inst->backhandle)) >= 0) {\r
- inst->exited = TRUE;\r
- if (inst->cfg.close_on_exit == FORCE_ON ||\r
- (inst->cfg.close_on_exit == AUTO && exitcode == 0))\r
- gtk_main_quit(); /* just go */\r
- if (inst->ldisc) {\r
- ldisc_free(inst->ldisc);\r
- inst->ldisc = NULL;\r
- }\r
- if (inst->back) {\r
- inst->back->free(inst->backhandle);\r
- inst->backhandle = NULL;\r
- inst->back = NULL;\r
- term_provide_resize_fn(inst->term, NULL, NULL);\r
- update_specials_menu(inst);\r
- }\r
- gtk_widget_set_sensitive(inst->restartitem, TRUE);\r
- }\r
-\r
- gtk_idle_remove(inst->term_exit_idle_id);\r
- return TRUE;\r
-}\r
-\r
-void notify_remote_exit(void *frontend)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
-\r
- inst->term_exit_idle_id = gtk_idle_add(idle_exit_func, inst);\r
-}\r
-\r
-static gint timer_trigger(gpointer data)\r
-{\r
- long now = GPOINTER_TO_LONG(data);\r
- long next;\r
- long ticks;\r
-\r
- if (run_timers(now, &next)) {\r
- ticks = next - GETTICKCOUNT();\r
- timer_id = gtk_timeout_add(ticks > 0 ? ticks : 1, timer_trigger,\r
- LONG_TO_GPOINTER(next));\r
- }\r
-\r
- /*\r
- * Never let a timer resume. If we need another one, we've\r
- * asked for it explicitly above.\r
- */\r
- return FALSE;\r
-}\r
-\r
-void timer_change_notify(long next)\r
-{\r
- long ticks;\r
-\r
- if (timer_id)\r
- gtk_timeout_remove(timer_id);\r
-\r
- ticks = next - GETTICKCOUNT();\r
- if (ticks <= 0)\r
- ticks = 1; /* just in case */\r
-\r
- timer_id = gtk_timeout_add(ticks, timer_trigger,\r
- LONG_TO_GPOINTER(next));\r
-}\r
-\r
-void fd_input_func(gpointer data, gint sourcefd, GdkInputCondition condition)\r
-{\r
- /*\r
- * We must process exceptional notifications before ordinary\r
- * readability ones, or we may go straight past the urgent\r
- * marker.\r
- */\r
- if (condition & GDK_INPUT_EXCEPTION)\r
- select_result(sourcefd, 4);\r
- if (condition & GDK_INPUT_READ)\r
- select_result(sourcefd, 1);\r
- if (condition & GDK_INPUT_WRITE)\r
- select_result(sourcefd, 2);\r
-}\r
-\r
-void destroy(GtkWidget *widget, gpointer data)\r
-{\r
- gtk_main_quit();\r
-}\r
-\r
-gint focus_event(GtkWidget *widget, GdkEventFocus *event, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- term_set_focus(inst->term, event->in);\r
- term_update(inst->term);\r
- show_mouseptr(inst, 1);\r
- return FALSE;\r
-}\r
-\r
-void set_busy_status(void *frontend, int status)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- inst->busy_status = status;\r
- update_mouseptr(inst);\r
-}\r
-\r
-/*\r
- * set or clear the "raw mouse message" mode\r
- */\r
-void set_raw_mouse_mode(void *frontend, int activate)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- activate = activate && !inst->cfg.no_mouse_rep;\r
- send_raw_mouse = activate;\r
- update_mouseptr(inst);\r
-}\r
-\r
-void request_resize(void *frontend, int w, int h)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- int large_x, large_y;\r
- int offset_x, offset_y;\r
- int area_x, area_y;\r
- GtkRequisition inner, outer;\r
-\r
- /*\r
- * This is a heinous hack dreamed up by the gnome-terminal\r
- * people to get around a limitation in gtk. The problem is\r
- * that in order to set the size correctly we really need to be\r
- * calling gtk_window_resize - but that needs to know the size\r
- * of the _whole window_, not the drawing area. So what we do\r
- * is to set an artificially huge size request on the drawing\r
- * area, recompute the resulting size request on the window,\r
- * and look at the difference between the two. That gives us\r
- * the x and y offsets we need to translate drawing area size\r
- * into window size for real, and then we call\r
- * gtk_window_resize.\r
- */\r
-\r
- /*\r
- * We start by retrieving the current size of the whole window.\r
- * Adding a bit to _that_ will give us a value we can use as a\r
- * bogus size request which guarantees to be bigger than the\r
- * current size of the drawing area.\r
- */\r
- get_window_pixels(inst, &large_x, &large_y);\r
- large_x += 32;\r
- large_y += 32;\r
-\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- gtk_widget_set_size_request(inst->area, large_x, large_y);\r
-#else\r
- gtk_widget_set_usize(inst->area, large_x, large_y);\r
-#endif\r
- gtk_widget_size_request(inst->area, &inner);\r
- gtk_widget_size_request(inst->window, &outer);\r
-\r
- offset_x = outer.width - inner.width;\r
- offset_y = outer.height - inner.height;\r
-\r
- area_x = inst->font_width * w + 2*inst->cfg.window_border;\r
- area_y = inst->font_height * h + 2*inst->cfg.window_border;\r
-\r
- /*\r
- * Now we must set the size request on the drawing area back to\r
- * something sensible before we commit the real resize. Best\r
- * way to do this, I think, is to set it to what the size is\r
- * really going to end up being.\r
- */\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- gtk_widget_set_size_request(inst->area, area_x, area_y);\r
- gtk_window_resize(GTK_WINDOW(inst->window),\r
- area_x + offset_x, area_y + offset_y);\r
-#else\r
- gtk_widget_set_usize(inst->area, area_x, area_y);\r
- gtk_drawing_area_size(GTK_DRAWING_AREA(inst->area), area_x, area_y);\r
- /*\r
- * I can no longer remember what this call to\r
- * gtk_container_dequeue_resize_handler is for. It was\r
- * introduced in r3092 with no comment, and the commit log\r
- * message was uninformative. I'm _guessing_ its purpose is to\r
- * prevent gratuitous resize processing on the window given\r
- * that we're about to resize it anyway, but I have no idea\r
- * why that's so incredibly vital.\r
- * \r
- * I've tried removing the call, and nothing seems to go\r
- * wrong. I've backtracked to r3092 and tried removing the\r
- * call there, and still nothing goes wrong. So I'm going to\r
- * adopt the working hypothesis that it's superfluous; I won't\r
- * actually remove it from the GTK 1.2 code, but I won't\r
- * attempt to replicate its functionality in the GTK 2 code\r
- * above.\r
- */\r
- gtk_container_dequeue_resize_handler(GTK_CONTAINER(inst->window));\r
- gdk_window_resize(inst->window->window,\r
- area_x + offset_x, area_y + offset_y);\r
-#endif\r
-}\r
-\r
-static void real_palette_set(struct gui_data *inst, int n, int r, int g, int b)\r
-{\r
- gboolean success[1];\r
-\r
- inst->cols[n].red = r * 0x0101;\r
- inst->cols[n].green = g * 0x0101;\r
- inst->cols[n].blue = b * 0x0101;\r
-\r
- gdk_colormap_free_colors(inst->colmap, inst->cols + n, 1);\r
- gdk_colormap_alloc_colors(inst->colmap, inst->cols + n, 1,\r
- FALSE, TRUE, success);\r
- if (!success[0])\r
- g_error("%s: couldn't allocate colour %d (#%02x%02x%02x)\n", appname,\r
- n, r, g, b);\r
-}\r
-\r
-void set_window_background(struct gui_data *inst)\r
-{\r
- if (inst->area && inst->area->window)\r
- gdk_window_set_background(inst->area->window, &inst->cols[258]);\r
- if (inst->window && inst->window->window)\r
- gdk_window_set_background(inst->window->window, &inst->cols[258]);\r
-}\r
-\r
-void palette_set(void *frontend, int n, int r, int g, int b)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- if (n >= 16)\r
- n += 256 - 16;\r
- if (n > NALLCOLOURS)\r
- return;\r
- real_palette_set(inst, n, r, g, b);\r
- if (n == 258) {\r
- /* Default Background changed. Ensure space between text area and\r
- * window border is redrawn */\r
- set_window_background(inst);\r
- draw_backing_rect(inst);\r
- gtk_widget_queue_draw(inst->area);\r
- }\r
-}\r
-\r
-void palette_reset(void *frontend)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- /* This maps colour indices in inst->cfg to those used in inst->cols. */\r
- static const int ww[] = {\r
- 256, 257, 258, 259, 260, 261,\r
- 0, 8, 1, 9, 2, 10, 3, 11,\r
- 4, 12, 5, 13, 6, 14, 7, 15\r
- };\r
- gboolean success[NALLCOLOURS];\r
- int i;\r
-\r
- assert(lenof(ww) == NCFGCOLOURS);\r
-\r
- if (!inst->colmap) {\r
- inst->colmap = gdk_colormap_get_system();\r
- } else {\r
- gdk_colormap_free_colors(inst->colmap, inst->cols, NALLCOLOURS);\r
- }\r
-\r
- for (i = 0; i < NCFGCOLOURS; i++) {\r
- inst->cols[ww[i]].red = inst->cfg.colours[i][0] * 0x0101;\r
- inst->cols[ww[i]].green = inst->cfg.colours[i][1] * 0x0101;\r
- inst->cols[ww[i]].blue = inst->cfg.colours[i][2] * 0x0101;\r
- }\r
-\r
- for (i = 0; i < NEXTCOLOURS; i++) {\r
- if (i < 216) {\r
- int r = i / 36, g = (i / 6) % 6, b = i % 6;\r
- inst->cols[i+16].red = r ? r * 0x2828 + 0x3737 : 0;\r
- inst->cols[i+16].green = g ? g * 0x2828 + 0x3737 : 0;\r
- inst->cols[i+16].blue = b ? b * 0x2828 + 0x3737 : 0;\r
- } else {\r
- int shade = i - 216;\r
- shade = shade * 0x0a0a + 0x0808;\r
- inst->cols[i+16].red = inst->cols[i+16].green =\r
- inst->cols[i+16].blue = shade;\r
- }\r
- }\r
-\r
- gdk_colormap_alloc_colors(inst->colmap, inst->cols, NALLCOLOURS,\r
- FALSE, TRUE, success);\r
- for (i = 0; i < NALLCOLOURS; i++) {\r
- if (!success[i])\r
- g_error("%s: couldn't allocate colour %d (#%02x%02x%02x)\n",\r
- appname, i, inst->cfg.colours[i][0],\r
- inst->cfg.colours[i][1], inst->cfg.colours[i][2]);\r
- }\r
-\r
- /* Since Default Background may have changed, ensure that space\r
- * between text area and window border is refreshed. */\r
- set_window_background(inst);\r
- if (inst->area && inst->area->window) {\r
- draw_backing_rect(inst);\r
- gtk_widget_queue_draw(inst->area);\r
- }\r
-}\r
-\r
-/* Ensure that all the cut buffers exist - according to the ICCCM, we must\r
- * do this before we start using cut buffers.\r
- */\r
-void init_cutbuffers()\r
-{\r
- unsigned char empty[] = "";\r
- XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),\r
- XA_CUT_BUFFER0, XA_STRING, 8, PropModeAppend, empty, 0);\r
- XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),\r
- XA_CUT_BUFFER1, XA_STRING, 8, PropModeAppend, empty, 0);\r
- XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),\r
- XA_CUT_BUFFER2, XA_STRING, 8, PropModeAppend, empty, 0);\r
- XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),\r
- XA_CUT_BUFFER3, XA_STRING, 8, PropModeAppend, empty, 0);\r
- XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),\r
- XA_CUT_BUFFER4, XA_STRING, 8, PropModeAppend, empty, 0);\r
- XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),\r
- XA_CUT_BUFFER5, XA_STRING, 8, PropModeAppend, empty, 0);\r
- XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),\r
- XA_CUT_BUFFER6, XA_STRING, 8, PropModeAppend, empty, 0);\r
- XChangeProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(),\r
- XA_CUT_BUFFER7, XA_STRING, 8, PropModeAppend, empty, 0);\r
-}\r
-\r
-/* Store the data in a cut-buffer. */\r
-void store_cutbuffer(char * ptr, int len)\r
-{\r
- /* ICCCM says we must rotate the buffers before storing to buffer 0. */\r
- XRotateBuffers(GDK_DISPLAY(), 1);\r
- XStoreBytes(GDK_DISPLAY(), ptr, len);\r
-}\r
-\r
-/* Retrieve data from a cut-buffer.\r
- * Returned data needs to be freed with XFree().\r
- */\r
-char * retrieve_cutbuffer(int * nbytes)\r
-{\r
- char * ptr;\r
- ptr = XFetchBytes(GDK_DISPLAY(), nbytes);\r
- if (*nbytes <= 0 && ptr != 0) {\r
- XFree(ptr);\r
- ptr = 0;\r
- }\r
- return ptr;\r
-}\r
-\r
-void write_clip(void *frontend, wchar_t * data, int *attr, int len, int must_deselect)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- if (inst->pasteout_data)\r
- sfree(inst->pasteout_data);\r
- if (inst->pasteout_data_ctext)\r
- sfree(inst->pasteout_data_ctext);\r
- if (inst->pasteout_data_utf8)\r
- sfree(inst->pasteout_data_utf8);\r
-\r
- /*\r
- * Set up UTF-8 and compound text paste data. This only happens\r
- * if we aren't in direct-to-font mode using the D800 hack.\r
- */\r
- if (!inst->direct_to_font) {\r
- wchar_t *tmp = data;\r
- int tmplen = len;\r
- XTextProperty tp;\r
- char *list[1];\r
-\r
- inst->pasteout_data_utf8 = snewn(len*6, char);\r
- inst->pasteout_data_utf8_len = len*6;\r
- inst->pasteout_data_utf8_len =\r
- charset_from_unicode(&tmp, &tmplen, inst->pasteout_data_utf8,\r
- inst->pasteout_data_utf8_len,\r
- CS_UTF8, NULL, NULL, 0);\r
- if (inst->pasteout_data_utf8_len == 0) {\r
- sfree(inst->pasteout_data_utf8);\r
- inst->pasteout_data_utf8 = NULL;\r
- } else {\r
- inst->pasteout_data_utf8 =\r
- sresize(inst->pasteout_data_utf8,\r
- inst->pasteout_data_utf8_len + 1, char);\r
- inst->pasteout_data_utf8[inst->pasteout_data_utf8_len] = '\0';\r
- }\r
-\r
- /*\r
- * Now let Xlib convert our UTF-8 data into compound text.\r
- */\r
- list[0] = inst->pasteout_data_utf8;\r
- if (Xutf8TextListToTextProperty(GDK_DISPLAY(), list, 1,\r
- XCompoundTextStyle, &tp) == 0) {\r
- inst->pasteout_data_ctext = snewn(tp.nitems+1, char);\r
- memcpy(inst->pasteout_data_ctext, tp.value, tp.nitems);\r
- inst->pasteout_data_ctext_len = tp.nitems;\r
- XFree(tp.value);\r
- } else {\r
- inst->pasteout_data_ctext = NULL;\r
- inst->pasteout_data_ctext_len = 0;\r
- }\r
- } else {\r
- inst->pasteout_data_utf8 = NULL;\r
- inst->pasteout_data_utf8_len = 0;\r
- inst->pasteout_data_ctext = NULL;\r
- inst->pasteout_data_ctext_len = 0;\r
- }\r
-\r
- inst->pasteout_data = snewn(len*6, char);\r
- inst->pasteout_data_len = len*6;\r
- inst->pasteout_data_len = wc_to_mb(inst->ucsdata.line_codepage, 0,\r
- data, len, inst->pasteout_data,\r
- inst->pasteout_data_len,\r
- NULL, NULL, NULL);\r
- if (inst->pasteout_data_len == 0) {\r
- sfree(inst->pasteout_data);\r
- inst->pasteout_data = NULL;\r
- } else {\r
- inst->pasteout_data =\r
- sresize(inst->pasteout_data, inst->pasteout_data_len, char);\r
- }\r
-\r
- store_cutbuffer(inst->pasteout_data, inst->pasteout_data_len);\r
-\r
- if (gtk_selection_owner_set(inst->area, GDK_SELECTION_PRIMARY,\r
- inst->input_event_time)) {\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- gtk_selection_clear_targets(inst->area, GDK_SELECTION_PRIMARY);\r
-#endif\r
- gtk_selection_add_target(inst->area, GDK_SELECTION_PRIMARY,\r
- GDK_SELECTION_TYPE_STRING, 1);\r
- if (inst->pasteout_data_ctext)\r
- gtk_selection_add_target(inst->area, GDK_SELECTION_PRIMARY,\r
- compound_text_atom, 1);\r
- if (inst->pasteout_data_utf8)\r
- gtk_selection_add_target(inst->area, GDK_SELECTION_PRIMARY,\r
- utf8_string_atom, 1);\r
- }\r
-\r
- if (must_deselect)\r
- term_deselect(inst->term);\r
-}\r
-\r
-void selection_get(GtkWidget *widget, GtkSelectionData *seldata,\r
- guint info, guint time_stamp, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- if (seldata->target == utf8_string_atom)\r
- gtk_selection_data_set(seldata, seldata->target, 8,\r
- (unsigned char *)inst->pasteout_data_utf8,\r
- inst->pasteout_data_utf8_len);\r
- else if (seldata->target == compound_text_atom)\r
- gtk_selection_data_set(seldata, seldata->target, 8,\r
- (unsigned char *)inst->pasteout_data_ctext,\r
- inst->pasteout_data_ctext_len);\r
- else\r
- gtk_selection_data_set(seldata, seldata->target, 8,\r
- (unsigned char *)inst->pasteout_data,\r
- inst->pasteout_data_len);\r
-}\r
-\r
-gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata,\r
- gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
-\r
- term_deselect(inst->term);\r
- if (inst->pasteout_data)\r
- sfree(inst->pasteout_data);\r
- if (inst->pasteout_data_ctext)\r
- sfree(inst->pasteout_data_ctext);\r
- if (inst->pasteout_data_utf8)\r
- sfree(inst->pasteout_data_utf8);\r
- inst->pasteout_data = NULL;\r
- inst->pasteout_data_len = 0;\r
- inst->pasteout_data_ctext = NULL;\r
- inst->pasteout_data_ctext_len = 0;\r
- inst->pasteout_data_utf8 = NULL;\r
- inst->pasteout_data_utf8_len = 0;\r
- return TRUE;\r
-}\r
-\r
-void request_paste(void *frontend)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- /*\r
- * In Unix, pasting is asynchronous: all we can do at the\r
- * moment is to call gtk_selection_convert(), and when the data\r
- * comes back _then_ we can call term_do_paste().\r
- */\r
-\r
- if (!inst->direct_to_font) {\r
- /*\r
- * First we attempt to retrieve the selection as a UTF-8\r
- * string (which we will convert to the correct code page\r
- * before sending to the session, of course). If that\r
- * fails, selection_received() will be informed and will\r
- * fall back to an ordinary string.\r
- */\r
- gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,\r
- utf8_string_atom,\r
- inst->input_event_time);\r
- } else {\r
- /*\r
- * If we're in direct-to-font mode, we disable UTF-8\r
- * pasting, and go straight to ordinary string data.\r
- */\r
- gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,\r
- GDK_SELECTION_TYPE_STRING,\r
- inst->input_event_time);\r
- }\r
-}\r
-\r
-gint idle_paste_func(gpointer data); /* forward ref */\r
-\r
-void selection_received(GtkWidget *widget, GtkSelectionData *seldata,\r
- guint time, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- XTextProperty tp;\r
- char **list;\r
- char *text;\r
- int length, count, ret;\r
- int free_list_required = 0;\r
- int free_required = 0;\r
- int charset;\r
-\r
- if (seldata->target == utf8_string_atom && seldata->length <= 0) {\r
- /*\r
- * Failed to get a UTF-8 selection string. Try compound\r
- * text next.\r
- */\r
- gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,\r
- compound_text_atom,\r
- inst->input_event_time);\r
- return;\r
- }\r
-\r
- if (seldata->target == compound_text_atom && seldata->length <= 0) {\r
- /*\r
- * Failed to get UTF-8 or compound text. Try an ordinary\r
- * string.\r
- */\r
- gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,\r
- GDK_SELECTION_TYPE_STRING,\r
- inst->input_event_time);\r
- return;\r
- }\r
-\r
- /*\r
- * If we have data, but it's not of a type we can deal with,\r
- * we have to ignore the data.\r
- */\r
- if (seldata->length > 0 &&\r
- seldata->type != GDK_SELECTION_TYPE_STRING &&\r
- seldata->type != compound_text_atom &&\r
- seldata->type != utf8_string_atom)\r
- return;\r
-\r
- /*\r
- * If we have no data, try looking in a cut buffer.\r
- */\r
- if (seldata->length <= 0) {\r
- text = retrieve_cutbuffer(&length);\r
- if (length == 0)\r
- return;\r
- /* Xterm is rumoured to expect Latin-1, though I havn't checked the\r
- * source, so use that as a de-facto standard. */\r
- charset = CS_ISO8859_1;\r
- free_required = 1;\r
- } else {\r
- /*\r
- * Convert COMPOUND_TEXT into UTF-8.\r
- */\r
- if (seldata->type == compound_text_atom) {\r
- tp.value = seldata->data;\r
- tp.encoding = (Atom) seldata->type;\r
- tp.format = seldata->format;\r
- tp.nitems = seldata->length;\r
- ret = Xutf8TextPropertyToTextList(GDK_DISPLAY(), &tp,\r
- &list, &count);\r
- if (ret != 0 || count != 1) {\r
- /*\r
- * Compound text failed; fall back to STRING.\r
- */\r
- gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,\r
- GDK_SELECTION_TYPE_STRING,\r
- inst->input_event_time);\r
- return;\r
- }\r
- text = list[0];\r
- length = strlen(list[0]);\r
- charset = CS_UTF8;\r
- free_list_required = 1;\r
- } else {\r
- text = (char *)seldata->data;\r
- length = seldata->length;\r
- charset = (seldata->type == utf8_string_atom ?\r
- CS_UTF8 : inst->ucsdata.line_codepage);\r
- }\r
- }\r
-\r
- if (inst->pastein_data)\r
- sfree(inst->pastein_data);\r
-\r
- inst->pastein_data = snewn(length, wchar_t);\r
- inst->pastein_data_len = length;\r
- inst->pastein_data_len =\r
- mb_to_wc(charset, 0, text, length,\r
- inst->pastein_data, inst->pastein_data_len);\r
-\r
- term_do_paste(inst->term);\r
-\r
- if (term_paste_pending(inst->term))\r
- inst->term_paste_idle_id = gtk_idle_add(idle_paste_func, inst);\r
-\r
- if (free_list_required)\r
- XFreeStringList(list);\r
- if (free_required)\r
- XFree(text);\r
-}\r
-\r
-gint idle_paste_func(gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
-\r
- if (term_paste_pending(inst->term))\r
- term_paste(inst->term);\r
- else\r
- gtk_idle_remove(inst->term_paste_idle_id);\r
-\r
- return TRUE;\r
-}\r
-\r
-\r
-void get_clip(void *frontend, wchar_t ** p, int *len)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
-\r
- if (p) {\r
- *p = inst->pastein_data;\r
- *len = inst->pastein_data_len;\r
- }\r
-}\r
-\r
-static void set_window_titles(struct gui_data *inst)\r
-{\r
- /*\r
- * We must always call set_icon_name after calling set_title,\r
- * since set_title will write both names. Irritating, but such\r
- * is life.\r
- */\r
- gtk_window_set_title(GTK_WINDOW(inst->window), inst->wintitle);\r
- if (!inst->cfg.win_name_always)\r
- gdk_window_set_icon_name(inst->window->window, inst->icontitle);\r
-}\r
-\r
-void set_title(void *frontend, char *title)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- strncpy(inst->wintitle, title, lenof(inst->wintitle));\r
- inst->wintitle[lenof(inst->wintitle)-1] = '\0';\r
- set_window_titles(inst);\r
-}\r
-\r
-void set_icon(void *frontend, char *title)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- strncpy(inst->icontitle, title, lenof(inst->icontitle));\r
- inst->icontitle[lenof(inst->icontitle)-1] = '\0';\r
- set_window_titles(inst);\r
-}\r
-\r
-void set_sbar(void *frontend, int total, int start, int page)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- if (!inst->cfg.scrollbar)\r
- return;\r
- inst->sbar_adjust->lower = 0;\r
- inst->sbar_adjust->upper = total;\r
- inst->sbar_adjust->value = start;\r
- inst->sbar_adjust->page_size = page;\r
- inst->sbar_adjust->step_increment = 1;\r
- inst->sbar_adjust->page_increment = page/2;\r
- inst->ignore_sbar = TRUE;\r
- gtk_adjustment_changed(inst->sbar_adjust);\r
- inst->ignore_sbar = FALSE;\r
-}\r
-\r
-void scrollbar_moved(GtkAdjustment *adj, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
-\r
- if (!inst->cfg.scrollbar)\r
- return;\r
- if (!inst->ignore_sbar)\r
- term_scroll(inst->term, 1, (int)adj->value);\r
-}\r
-\r
-void sys_cursor(void *frontend, int x, int y)\r
-{\r
- /*\r
- * This is meaningless under X.\r
- */\r
-}\r
-\r
-/*\r
- * This is still called when mode==BELL_VISUAL, even though the\r
- * visual bell is handled entirely within terminal.c, because we\r
- * may want to perform additional actions on any kind of bell (for\r
- * example, taskbar flashing in Windows).\r
- */\r
-void do_beep(void *frontend, int mode)\r
-{\r
- if (mode == BELL_DEFAULT)\r
- gdk_beep();\r
-}\r
-\r
-int char_width(Context ctx, int uc)\r
-{\r
- /*\r
- * Under X, any fixed-width font really _is_ fixed-width.\r
- * Double-width characters will be dealt with using a separate\r
- * font. For the moment we can simply return 1.\r
- * \r
- * FIXME: but is that also true of Pango?\r
- */\r
- return 1;\r
-}\r
-\r
-Context get_ctx(void *frontend)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- struct draw_ctx *dctx;\r
-\r
- if (!inst->area->window)\r
- return NULL;\r
-\r
- dctx = snew(struct draw_ctx);\r
- dctx->inst = inst;\r
- dctx->gc = gdk_gc_new(inst->area->window);\r
- return dctx;\r
-}\r
-\r
-void free_ctx(Context ctx)\r
-{\r
- struct draw_ctx *dctx = (struct draw_ctx *)ctx;\r
- /* struct gui_data *inst = dctx->inst; */\r
- GdkGC *gc = dctx->gc;\r
- gdk_gc_unref(gc);\r
- sfree(dctx);\r
-}\r
-\r
-/*\r
- * Draw a line of text in the window, at given character\r
- * coordinates, in given attributes.\r
- *\r
- * We are allowed to fiddle with the contents of `text'.\r
- */\r
-void do_text_internal(Context ctx, int x, int y, wchar_t *text, int len,\r
- unsigned long attr, int lattr)\r
-{\r
- struct draw_ctx *dctx = (struct draw_ctx *)ctx;\r
- struct gui_data *inst = dctx->inst;\r
- GdkGC *gc = dctx->gc;\r
- int ncombining, combining;\r
- int nfg, nbg, t, fontid, shadow, rlen, widefactor, bold;\r
- int monochrome = gtk_widget_get_visual(inst->area)->depth == 1;\r
-\r
- if (attr & TATTR_COMBINING) {\r
- ncombining = len;\r
- len = 1;\r
- } else\r
- ncombining = 1;\r
-\r
- nfg = ((monochrome ? ATTR_DEFFG : (attr & ATTR_FGMASK)) >> ATTR_FGSHIFT);\r
- nbg = ((monochrome ? ATTR_DEFBG : (attr & ATTR_BGMASK)) >> ATTR_BGSHIFT);\r
- if (!!(attr & ATTR_REVERSE) ^ (monochrome && (attr & TATTR_ACTCURS))) {\r
- t = nfg;\r
- nfg = nbg;\r
- nbg = t;\r
- }\r
- if (inst->cfg.bold_colour && (attr & ATTR_BOLD)) {\r
- if (nfg < 16) nfg |= 8;\r
- else if (nfg >= 256) nfg |= 1;\r
- }\r
- if (inst->cfg.bold_colour && (attr & ATTR_BLINK)) {\r
- if (nbg < 16) nbg |= 8;\r
- else if (nbg >= 256) nbg |= 1;\r
- }\r
- if ((attr & TATTR_ACTCURS) && !monochrome) {\r
- nfg = 260;\r
- nbg = 261;\r
- }\r
-\r
- fontid = shadow = 0;\r
-\r
- if (attr & ATTR_WIDE) {\r
- widefactor = 2;\r
- fontid |= 2;\r
- } else {\r
- widefactor = 1;\r
- }\r
-\r
- if ((attr & ATTR_BOLD) && !inst->cfg.bold_colour) {\r
- bold = 1;\r
- fontid |= 1;\r
- } else {\r
- bold = 0;\r
- }\r
-\r
- if (!inst->fonts[fontid]) {\r
- int i;\r
- /*\r
- * Fall back through font ids with subsets of this one's\r
- * set bits, in order.\r
- */\r
- for (i = fontid; i-- > 0 ;) {\r
- if (i & ~fontid)\r
- continue; /* some other bit is set */\r
- if (inst->fonts[i]) {\r
- fontid = i;\r
- break;\r
- }\r
- }\r
- assert(inst->fonts[fontid]); /* we should at least have hit zero */\r
- }\r
-\r
- if ((lattr & LATTR_MODE) != LATTR_NORM) {\r
- x *= 2;\r
- if (x >= inst->term->cols)\r
- return;\r
- if (x + len*2*widefactor > inst->term->cols)\r
- len = (inst->term->cols-x)/2/widefactor;/* trim to LH half */\r
- rlen = len * 2;\r
- } else\r
- rlen = len;\r
-\r
- {\r
- GdkRectangle r;\r
-\r
- r.x = x*inst->font_width+inst->cfg.window_border;\r
- r.y = y*inst->font_height+inst->cfg.window_border;\r
- r.width = rlen*widefactor*inst->font_width;\r
- r.height = inst->font_height;\r
- gdk_gc_set_clip_rectangle(gc, &r);\r
- }\r
-\r
- gdk_gc_set_foreground(gc, &inst->cols[nbg]);\r
- gdk_draw_rectangle(inst->pixmap, gc, 1,\r
- x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height+inst->cfg.window_border,\r
- rlen*widefactor*inst->font_width, inst->font_height);\r
-\r
- gdk_gc_set_foreground(gc, &inst->cols[nfg]);\r
- {\r
- gchar *gcs;\r
-\r
- /*\r
- * FIXME: this length is hardwired on the assumption that\r
- * conversions from wide to multibyte characters will\r
- * never generate more than 10 bytes for a single wide\r
- * character.\r
- */\r
- gcs = snewn(len*10+1, gchar);\r
-\r
- for (combining = 0; combining < ncombining; combining++) {\r
- int mblen = wc_to_mb(inst->fonts[fontid]->real_charset, 0,\r
- text + combining, len, gcs, len*10+1, ".",\r
- NULL, NULL);\r
- unifont_draw_text(inst->pixmap, gc, inst->fonts[fontid],\r
- x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height+inst->cfg.window_border+inst->fonts[0]->ascent,\r
- gcs, mblen, widefactor > 1, bold, inst->font_width);\r
- }\r
-\r
- sfree(gcs);\r
- }\r
-\r
- if (attr & ATTR_UNDER) {\r
- int uheight = inst->fonts[0]->ascent + 1;\r
- if (uheight >= inst->font_height)\r
- uheight = inst->font_height - 1;\r
- gdk_draw_line(inst->pixmap, gc, x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height + uheight + inst->cfg.window_border,\r
- (x+len)*widefactor*inst->font_width-1+inst->cfg.window_border,\r
- y*inst->font_height + uheight + inst->cfg.window_border);\r
- }\r
-\r
- if ((lattr & LATTR_MODE) != LATTR_NORM) {\r
- /*\r
- * I can't find any plausible StretchBlt equivalent in the\r
- * X server, so I'm going to do this the slow and painful\r
- * way. This will involve repeated calls to\r
- * gdk_draw_pixmap() to stretch the text horizontally. It's\r
- * O(N^2) in time and O(N) in network bandwidth, but you\r
- * try thinking of a better way. :-(\r
- */\r
- int i;\r
- for (i = 0; i < len * widefactor * inst->font_width; i++) {\r
- gdk_draw_pixmap(inst->pixmap, gc, inst->pixmap,\r
- x*inst->font_width+inst->cfg.window_border + 2*i,\r
- y*inst->font_height+inst->cfg.window_border,\r
- x*inst->font_width+inst->cfg.window_border + 2*i+1,\r
- y*inst->font_height+inst->cfg.window_border,\r
- len * widefactor * inst->font_width - i, inst->font_height);\r
- }\r
- len *= 2;\r
- if ((lattr & LATTR_MODE) != LATTR_WIDE) {\r
- int dt, db;\r
- /* Now stretch vertically, in the same way. */\r
- if ((lattr & LATTR_MODE) == LATTR_BOT)\r
- dt = 0, db = 1;\r
- else\r
- dt = 1, db = 0;\r
- for (i = 0; i < inst->font_height; i+=2) {\r
- gdk_draw_pixmap(inst->pixmap, gc, inst->pixmap,\r
- x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height+inst->cfg.window_border+dt*i+db,\r
- x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height+inst->cfg.window_border+dt*(i+1),\r
- len * widefactor * inst->font_width, inst->font_height-i-1);\r
- }\r
- }\r
- }\r
-}\r
-\r
-void do_text(Context ctx, int x, int y, wchar_t *text, int len,\r
- unsigned long attr, int lattr)\r
-{\r
- struct draw_ctx *dctx = (struct draw_ctx *)ctx;\r
- struct gui_data *inst = dctx->inst;\r
- GdkGC *gc = dctx->gc;\r
- int widefactor;\r
-\r
- do_text_internal(ctx, x, y, text, len, attr, lattr);\r
-\r
- if (attr & ATTR_WIDE) {\r
- widefactor = 2;\r
- } else {\r
- widefactor = 1;\r
- }\r
-\r
- if ((lattr & LATTR_MODE) != LATTR_NORM) {\r
- x *= 2;\r
- if (x >= inst->term->cols)\r
- return;\r
- if (x + len*2*widefactor > inst->term->cols)\r
- len = (inst->term->cols-x)/2/widefactor;/* trim to LH half */\r
- len *= 2;\r
- }\r
-\r
- gdk_draw_pixmap(inst->area->window, gc, inst->pixmap,\r
- x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height+inst->cfg.window_border,\r
- x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height+inst->cfg.window_border,\r
- len*widefactor*inst->font_width, inst->font_height);\r
-}\r
-\r
-void do_cursor(Context ctx, int x, int y, wchar_t *text, int len,\r
- unsigned long attr, int lattr)\r
-{\r
- struct draw_ctx *dctx = (struct draw_ctx *)ctx;\r
- struct gui_data *inst = dctx->inst;\r
- GdkGC *gc = dctx->gc;\r
-\r
- int active, passive, widefactor;\r
-\r
- if (attr & TATTR_PASCURS) {\r
- attr &= ~TATTR_PASCURS;\r
- passive = 1;\r
- } else\r
- passive = 0;\r
- if ((attr & TATTR_ACTCURS) && inst->cfg.cursor_type != 0) {\r
- attr &= ~TATTR_ACTCURS;\r
- active = 1;\r
- } else\r
- active = 0;\r
- do_text_internal(ctx, x, y, text, len, attr, lattr);\r
-\r
- if (attr & TATTR_COMBINING)\r
- len = 1;\r
-\r
- if (attr & ATTR_WIDE) {\r
- widefactor = 2;\r
- } else {\r
- widefactor = 1;\r
- }\r
-\r
- if ((lattr & LATTR_MODE) != LATTR_NORM) {\r
- x *= 2;\r
- if (x >= inst->term->cols)\r
- return;\r
- if (x + len*2*widefactor > inst->term->cols)\r
- len = (inst->term->cols-x)/2/widefactor;/* trim to LH half */\r
- len *= 2;\r
- }\r
-\r
- if (inst->cfg.cursor_type == 0) {\r
- /*\r
- * An active block cursor will already have been done by\r
- * the above do_text call, so we only need to do anything\r
- * if it's passive.\r
- */\r
- if (passive) {\r
- gdk_gc_set_foreground(gc, &inst->cols[261]);\r
- gdk_draw_rectangle(inst->pixmap, gc, 0,\r
- x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height+inst->cfg.window_border,\r
- len*widefactor*inst->font_width-1, inst->font_height-1);\r
- }\r
- } else {\r
- int uheight;\r
- int startx, starty, dx, dy, length, i;\r
-\r
- int char_width;\r
-\r
- if ((attr & ATTR_WIDE) || (lattr & LATTR_MODE) != LATTR_NORM)\r
- char_width = 2*inst->font_width;\r
- else\r
- char_width = inst->font_width;\r
-\r
- if (inst->cfg.cursor_type == 1) {\r
- uheight = inst->fonts[0]->ascent + 1;\r
- if (uheight >= inst->font_height)\r
- uheight = inst->font_height - 1;\r
-\r
- startx = x * inst->font_width + inst->cfg.window_border;\r
- starty = y * inst->font_height + inst->cfg.window_border + uheight;\r
- dx = 1;\r
- dy = 0;\r
- length = len * widefactor * char_width;\r
- } else {\r
- int xadjust = 0;\r
- if (attr & TATTR_RIGHTCURS)\r
- xadjust = char_width - 1;\r
- startx = x * inst->font_width + inst->cfg.window_border + xadjust;\r
- starty = y * inst->font_height + inst->cfg.window_border;\r
- dx = 0;\r
- dy = 1;\r
- length = inst->font_height;\r
- }\r
-\r
- gdk_gc_set_foreground(gc, &inst->cols[261]);\r
- if (passive) {\r
- for (i = 0; i < length; i++) {\r
- if (i % 2 == 0) {\r
- gdk_draw_point(inst->pixmap, gc, startx, starty);\r
- }\r
- startx += dx;\r
- starty += dy;\r
- }\r
- } else if (active) {\r
- gdk_draw_line(inst->pixmap, gc, startx, starty,\r
- startx + (length-1) * dx, starty + (length-1) * dy);\r
- } /* else no cursor (e.g., blinked off) */\r
- }\r
-\r
- gdk_draw_pixmap(inst->area->window, gc, inst->pixmap,\r
- x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height+inst->cfg.window_border,\r
- x*inst->font_width+inst->cfg.window_border,\r
- y*inst->font_height+inst->cfg.window_border,\r
- len*widefactor*inst->font_width, inst->font_height);\r
-}\r
-\r
-GdkCursor *make_mouse_ptr(struct gui_data *inst, int cursor_val)\r
-{\r
- /*\r
- * Truly hideous hack: GTK doesn't allow us to set the mouse\r
- * cursor foreground and background colours unless we've _also_\r
- * created our own cursor from bitmaps. Therefore, I need to\r
- * load the `cursor' font and draw glyphs from it on to\r
- * pixmaps, in order to construct my cursors with the fg and bg\r
- * I want. This is a gross hack, but it's more self-contained\r
- * than linking in Xlib to find the X window handle to\r
- * inst->area and calling XRecolorCursor, and it's more\r
- * futureproof than hard-coding the shapes as bitmap arrays.\r
- */\r
- static GdkFont *cursor_font = NULL;\r
- GdkPixmap *source, *mask;\r
- GdkGC *gc;\r
- GdkColor cfg = { 0, 65535, 65535, 65535 };\r
- GdkColor cbg = { 0, 0, 0, 0 };\r
- GdkColor dfg = { 1, 65535, 65535, 65535 };\r
- GdkColor dbg = { 0, 0, 0, 0 };\r
- GdkCursor *ret;\r
- gchar text[2];\r
- gint lb, rb, wid, asc, desc, w, h, x, y;\r
-\r
- if (cursor_val == -2) {\r
- gdk_font_unref(cursor_font);\r
- return NULL;\r
- }\r
-\r
- if (cursor_val >= 0 && !cursor_font) {\r
- cursor_font = gdk_font_load("cursor");\r
- if (cursor_font)\r
- gdk_font_ref(cursor_font);\r
- }\r
-\r
- /*\r
- * Get the text extent of the cursor in question. We use the\r
- * mask character for this, because it's typically slightly\r
- * bigger than the main character.\r
- */\r
- if (cursor_val >= 0) {\r
- text[1] = '\0';\r
- text[0] = (char)cursor_val + 1;\r
- gdk_string_extents(cursor_font, text, &lb, &rb, &wid, &asc, &desc);\r
- w = rb-lb; h = asc+desc; x = -lb; y = asc;\r
- } else {\r
- w = h = 1;\r
- x = y = 0;\r
- }\r
-\r
- source = gdk_pixmap_new(NULL, w, h, 1);\r
- mask = gdk_pixmap_new(NULL, w, h, 1);\r
-\r
- /*\r
- * Draw the mask character on the mask pixmap.\r
- */\r
- gc = gdk_gc_new(mask);\r
- gdk_gc_set_foreground(gc, &dbg);\r
- gdk_draw_rectangle(mask, gc, 1, 0, 0, w, h);\r
- if (cursor_val >= 0) {\r
- text[1] = '\0';\r
- text[0] = (char)cursor_val + 1;\r
- gdk_gc_set_foreground(gc, &dfg);\r
- gdk_draw_text(mask, cursor_font, gc, x, y, text, 1);\r
- }\r
- gdk_gc_unref(gc);\r
-\r
- /*\r
- * Draw the main character on the source pixmap.\r
- */\r
- gc = gdk_gc_new(source);\r
- gdk_gc_set_foreground(gc, &dbg);\r
- gdk_draw_rectangle(source, gc, 1, 0, 0, w, h);\r
- if (cursor_val >= 0) {\r
- text[1] = '\0';\r
- text[0] = (char)cursor_val;\r
- gdk_gc_set_foreground(gc, &dfg);\r
- gdk_draw_text(source, cursor_font, gc, x, y, text, 1);\r
- }\r
- gdk_gc_unref(gc);\r
-\r
- /*\r
- * Create the cursor.\r
- */\r
- ret = gdk_cursor_new_from_pixmap(source, mask, &cfg, &cbg, x, y);\r
-\r
- /*\r
- * Clean up.\r
- */\r
- gdk_pixmap_unref(source);\r
- gdk_pixmap_unref(mask);\r
-\r
- return ret;\r
-}\r
-\r
-void modalfatalbox(char *p, ...)\r
-{\r
- va_list ap;\r
- fprintf(stderr, "FATAL ERROR: ");\r
- va_start(ap, p);\r
- vfprintf(stderr, p, ap);\r
- va_end(ap);\r
- fputc('\n', stderr);\r
- exit(1);\r
-}\r
-\r
-void cmdline_error(char *p, ...)\r
-{\r
- va_list ap;\r
- fprintf(stderr, "%s: ", appname);\r
- va_start(ap, p);\r
- vfprintf(stderr, p, ap);\r
- va_end(ap);\r
- fputc('\n', stderr);\r
- exit(1);\r
-}\r
-\r
-char *get_x_display(void *frontend)\r
-{\r
- return gdk_get_display();\r
-}\r
-\r
-long get_windowid(void *frontend)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
- return (long)GDK_WINDOW_XWINDOW(inst->area->window);\r
-}\r
-\r
-static void help(FILE *fp) {\r
- if(fprintf(fp,\r
-"pterm option summary:\n"\r
-"\n"\r
-" --display DISPLAY Specify X display to use (note '--')\n"\r
-" -name PREFIX Prefix when looking up resources (default: pterm)\n"\r
-" -fn FONT Normal text font\n"\r
-" -fb FONT Bold text font\n"\r
-" -geometry GEOMETRY Position and size of window (size in characters)\n"\r
-" -sl LINES Number of lines of scrollback\n"\r
-" -fg COLOUR, -bg COLOUR Foreground/background colour\n"\r
-" -bfg COLOUR, -bbg COLOUR Foreground/background bold colour\n"\r
-" -cfg COLOUR, -bfg COLOUR Foreground/background cursor colour\n"\r
-" -T TITLE Window title\n"\r
-" -ut, +ut Do(default) or do not update utmp\n"\r
-" -ls, +ls Do(default) or do not make shell a login shell\n"\r
-" -sb, +sb Do(default) or do not display a scrollbar\n"\r
-" -log PATH Log all output to a file\n"\r
-" -nethack Map numeric keypad to hjklyubn direction keys\n"\r
-" -xrm RESOURCE-STRING Set an X resource\n"\r
-" -e COMMAND [ARGS...] Execute command (consumes all remaining args)\n"\r
- ) < 0 || fflush(fp) < 0) {\r
- perror("output error");\r
- exit(1);\r
- }\r
-}\r
-\r
-int do_cmdline(int argc, char **argv, int do_everything, int *allow_launch,\r
- struct gui_data *inst, Config *cfg)\r
-{\r
- int err = 0;\r
- char *val;\r
-\r
- /*\r
- * Macros to make argument handling easier. Note that because\r
- * they need to call `continue', they cannot be contained in\r
- * the usual do {...} while (0) wrapper to make them\r
- * syntactically single statements; hence it is not legal to\r
- * use one of these macros as an unbraced statement between\r
- * `if' and `else'.\r
- */\r
-#define EXPECTS_ARG { \\r
- if (--argc <= 0) { \\r
- err = 1; \\r
- fprintf(stderr, "%s: %s expects an argument\n", appname, p); \\r
- continue; \\r
- } else \\r
- val = *++argv; \\r
-}\r
-#define SECOND_PASS_ONLY { if (!do_everything) continue; }\r
-\r
- while (--argc > 0) {\r
- char *p = *++argv;\r
- int ret;\r
-\r
- /*\r
- * Shameless cheating. Debian requires all X terminal\r
- * emulators to support `-T title'; but\r
- * cmdline_process_param will eat -T (it means no-pty) and\r
- * complain that pterm doesn't support it. So, in pterm\r
- * only, we convert -T into -title.\r
- */\r
- if ((cmdline_tooltype & TOOLTYPE_NONNETWORK) &&\r
- !strcmp(p, "-T"))\r
- p = "-title";\r
-\r
- ret = cmdline_process_param(p, (argc > 1 ? argv[1] : NULL),\r
- do_everything ? 1 : -1, cfg);\r
-\r
- if (ret == -2) {\r
- cmdline_error("option \"%s\" requires an argument", p);\r
- } else if (ret == 2) {\r
- --argc, ++argv; /* skip next argument */\r
- continue;\r
- } else if (ret == 1) {\r
- continue;\r
- }\r
-\r
- if (!strcmp(p, "-fn") || !strcmp(p, "-font")) {\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
- strncpy(cfg->font.name, val, sizeof(cfg->font.name));\r
- cfg->font.name[sizeof(cfg->font.name)-1] = '\0';\r
-\r
- } else if (!strcmp(p, "-fb")) {\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
- strncpy(cfg->boldfont.name, val, sizeof(cfg->boldfont.name));\r
- cfg->boldfont.name[sizeof(cfg->boldfont.name)-1] = '\0';\r
-\r
- } else if (!strcmp(p, "-fw")) {\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
- strncpy(cfg->widefont.name, val, sizeof(cfg->widefont.name));\r
- cfg->widefont.name[sizeof(cfg->widefont.name)-1] = '\0';\r
-\r
- } else if (!strcmp(p, "-fwb")) {\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
- strncpy(cfg->wideboldfont.name, val, sizeof(cfg->wideboldfont.name));\r
- cfg->wideboldfont.name[sizeof(cfg->wideboldfont.name)-1] = '\0';\r
-\r
- } else if (!strcmp(p, "-cs")) {\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
- strncpy(cfg->line_codepage, val, sizeof(cfg->line_codepage));\r
- cfg->line_codepage[sizeof(cfg->line_codepage)-1] = '\0';\r
-\r
- } else if (!strcmp(p, "-geometry")) {\r
- int flags, x, y;\r
- unsigned int w, h;\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
-\r
- flags = XParseGeometry(val, &x, &y, &w, &h);\r
- if (flags & WidthValue)\r
- cfg->width = (int)w;\r
- if (flags & HeightValue)\r
- cfg->height = (int)h;\r
-\r
- if (flags & (XValue | YValue)) {\r
- inst->xpos = x;\r
- inst->ypos = y;\r
- inst->gotpos = TRUE;\r
- inst->gravity = ((flags & XNegative ? 1 : 0) |\r
- (flags & YNegative ? 2 : 0));\r
- }\r
-\r
- } else if (!strcmp(p, "-sl")) {\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
- cfg->savelines = atoi(val);\r
-\r
- } else if (!strcmp(p, "-fg") || !strcmp(p, "-bg") ||\r
- !strcmp(p, "-bfg") || !strcmp(p, "-bbg") ||\r
- !strcmp(p, "-cfg") || !strcmp(p, "-cbg")) {\r
- GdkColor col;\r
-\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
- if (!gdk_color_parse(val, &col)) {\r
- err = 1;\r
- fprintf(stderr, "%s: unable to parse colour \"%s\"\n",\r
- appname, val);\r
- } else {\r
- int index;\r
- index = (!strcmp(p, "-fg") ? 0 :\r
- !strcmp(p, "-bg") ? 2 :\r
- !strcmp(p, "-bfg") ? 1 :\r
- !strcmp(p, "-bbg") ? 3 :\r
- !strcmp(p, "-cfg") ? 4 :\r
- !strcmp(p, "-cbg") ? 5 : -1);\r
- assert(index != -1);\r
- cfg->colours[index][0] = col.red / 256;\r
- cfg->colours[index][1] = col.green / 256;\r
- cfg->colours[index][2] = col.blue / 256;\r
- }\r
-\r
- } else if (use_pty_argv && !strcmp(p, "-e")) {\r
- /* This option swallows all further arguments. */\r
- if (!do_everything)\r
- break;\r
-\r
- if (--argc > 0) {\r
- int i;\r
- pty_argv = snewn(argc+1, char *);\r
- ++argv;\r
- for (i = 0; i < argc; i++)\r
- pty_argv[i] = argv[i];\r
- pty_argv[argc] = NULL;\r
- break; /* finished command-line processing */\r
- } else\r
- err = 1, fprintf(stderr, "%s: -e expects an argument\n",\r
- appname);\r
-\r
- } else if (!strcmp(p, "-title")) {\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
- strncpy(cfg->wintitle, val, sizeof(cfg->wintitle));\r
- cfg->wintitle[sizeof(cfg->wintitle)-1] = '\0';\r
-\r
- } else if (!strcmp(p, "-log")) {\r
- EXPECTS_ARG;\r
- SECOND_PASS_ONLY;\r
- strncpy(cfg->logfilename.path, val, sizeof(cfg->logfilename.path));\r
- cfg->logfilename.path[sizeof(cfg->logfilename.path)-1] = '\0';\r
- cfg->logtype = LGTYP_DEBUG;\r
-\r
- } else if (!strcmp(p, "-ut-") || !strcmp(p, "+ut")) {\r
- SECOND_PASS_ONLY;\r
- cfg->stamp_utmp = 0;\r
-\r
- } else if (!strcmp(p, "-ut")) {\r
- SECOND_PASS_ONLY;\r
- cfg->stamp_utmp = 1;\r
-\r
- } else if (!strcmp(p, "-ls-") || !strcmp(p, "+ls")) {\r
- SECOND_PASS_ONLY;\r
- cfg->login_shell = 0;\r
-\r
- } else if (!strcmp(p, "-ls")) {\r
- SECOND_PASS_ONLY;\r
- cfg->login_shell = 1;\r
-\r
- } else if (!strcmp(p, "-nethack")) {\r
- SECOND_PASS_ONLY;\r
- cfg->nethack_keypad = 1;\r
-\r
- } else if (!strcmp(p, "-sb-") || !strcmp(p, "+sb")) {\r
- SECOND_PASS_ONLY;\r
- cfg->scrollbar = 0;\r
-\r
- } else if (!strcmp(p, "-sb")) {\r
- SECOND_PASS_ONLY;\r
- cfg->scrollbar = 0;\r
-\r
- } else if (!strcmp(p, "-name")) {\r
- EXPECTS_ARG;\r
- app_name = val;\r
-\r
- } else if (!strcmp(p, "-xrm")) {\r
- EXPECTS_ARG;\r
- provide_xrm_string(val);\r
-\r
- } else if(!strcmp(p, "-help") || !strcmp(p, "--help")) {\r
- help(stdout);\r
- exit(0);\r
-\r
- } else if (!strcmp(p, "-pgpfp")) {\r
- pgp_fingerprints();\r
- exit(1);\r
-\r
- } else if(p[0] != '-' && (!do_everything ||\r
- process_nonoption_arg(p, cfg,\r
- allow_launch))) {\r
- /* do nothing */\r
-\r
- } else {\r
- err = 1;\r
- fprintf(stderr, "%s: unrecognized option '%s'\n", appname, p);\r
- }\r
- }\r
-\r
- return err;\r
-}\r
-\r
-int uxsel_input_add(int fd, int rwx) {\r
- int flags = 0;\r
- if (rwx & 1) flags |= GDK_INPUT_READ;\r
- if (rwx & 2) flags |= GDK_INPUT_WRITE;\r
- if (rwx & 4) flags |= GDK_INPUT_EXCEPTION;\r
- assert(flags);\r
- return gdk_input_add(fd, flags, fd_input_func, NULL);\r
-}\r
-\r
-void uxsel_input_remove(int id) {\r
- gdk_input_remove(id);\r
-}\r
-\r
-void setup_fonts_ucs(struct gui_data *inst)\r
-{\r
- if (inst->fonts[0])\r
- unifont_destroy(inst->fonts[0]);\r
- if (inst->fonts[1])\r
- unifont_destroy(inst->fonts[1]);\r
- if (inst->fonts[2])\r
- unifont_destroy(inst->fonts[2]);\r
- if (inst->fonts[3])\r
- unifont_destroy(inst->fonts[3]);\r
-\r
- inst->fonts[0] = unifont_create(inst->area, inst->cfg.font.name,\r
- FALSE, FALSE,\r
- inst->cfg.shadowboldoffset,\r
- inst->cfg.shadowbold);\r
- if (!inst->fonts[0]) {\r
- fprintf(stderr, "%s: unable to load font \"%s\"\n", appname,\r
- inst->cfg.font.name);\r
- exit(1);\r
- }\r
-\r
- if (inst->cfg.shadowbold || !inst->cfg.boldfont.name[0]) {\r
- inst->fonts[1] = NULL;\r
- } else {\r
- inst->fonts[1] = unifont_create(inst->area, inst->cfg.boldfont.name,\r
- FALSE, TRUE,\r
- inst->cfg.shadowboldoffset,\r
- inst->cfg.shadowbold);\r
- if (!inst->fonts[1]) {\r
- fprintf(stderr, "%s: unable to load bold font \"%s\"\n", appname,\r
- inst->cfg.boldfont.name);\r
- exit(1);\r
- }\r
- }\r
-\r
- if (inst->cfg.widefont.name[0]) {\r
- inst->fonts[2] = unifont_create(inst->area, inst->cfg.widefont.name,\r
- TRUE, FALSE,\r
- inst->cfg.shadowboldoffset,\r
- inst->cfg.shadowbold);\r
- if (!inst->fonts[2]) {\r
- fprintf(stderr, "%s: unable to load wide font \"%s\"\n", appname,\r
- inst->cfg.widefont.name);\r
- exit(1);\r
- }\r
- } else {\r
- inst->fonts[2] = NULL;\r
- }\r
-\r
- if (inst->cfg.shadowbold || !inst->cfg.wideboldfont.name[0]) {\r
- inst->fonts[3] = NULL;\r
- } else {\r
- inst->fonts[3] = unifont_create(inst->area,\r
- inst->cfg.wideboldfont.name, TRUE,\r
- TRUE, inst->cfg.shadowboldoffset,\r
- inst->cfg.shadowbold);\r
- if (!inst->fonts[3]) {\r
- fprintf(stderr, "%s: unable to load wide bold font \"%s\"\n", appname,\r
- inst->cfg.boldfont.name);\r
- exit(1);\r
- }\r
- }\r
-\r
- inst->font_width = inst->fonts[0]->width;\r
- inst->font_height = inst->fonts[0]->height;\r
-\r
- inst->direct_to_font = init_ucs(&inst->ucsdata, inst->cfg.line_codepage,\r
- inst->cfg.utf8_override,\r
- inst->fonts[0]->public_charset,\r
- inst->cfg.vtmode);\r
-}\r
-\r
-void set_geom_hints(struct gui_data *inst)\r
-{\r
- GdkGeometry geom;\r
- geom.min_width = inst->font_width + 2*inst->cfg.window_border;\r
- geom.min_height = inst->font_height + 2*inst->cfg.window_border;\r
- geom.max_width = geom.max_height = -1;\r
- geom.base_width = 2*inst->cfg.window_border;\r
- geom.base_height = 2*inst->cfg.window_border;\r
- geom.width_inc = inst->font_width;\r
- geom.height_inc = inst->font_height;\r
- geom.min_aspect = geom.max_aspect = 0;\r
- gtk_window_set_geometry_hints(GTK_WINDOW(inst->window), inst->area, &geom,\r
- GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE |\r
- GDK_HINT_RESIZE_INC);\r
-}\r
-\r
-void clear_scrollback_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- term_clrsb(inst->term);\r
-}\r
-\r
-void reset_terminal_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- term_pwron(inst->term, TRUE);\r
- if (inst->ldisc)\r
- ldisc_send(inst->ldisc, NULL, 0, 0);\r
-}\r
-\r
-void copy_all_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- term_copyall(inst->term);\r
-}\r
-\r
-void special_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- int code = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item),\r
- "user-data"));\r
-\r
- if (inst->back)\r
- inst->back->special(inst->backhandle, code);\r
-}\r
-\r
-void about_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- about_box(inst->window);\r
-}\r
-\r
-void event_log_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- showeventlog(inst->eventlogstuff, inst->window);\r
-}\r
-\r
-void change_settings_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- /* This maps colour indices in inst->cfg to those used in inst->cols. */\r
- static const int ww[] = {\r
- 256, 257, 258, 259, 260, 261,\r
- 0, 8, 1, 9, 2, 10, 3, 11,\r
- 4, 12, 5, 13, 6, 14, 7, 15\r
- };\r
- struct gui_data *inst = (struct gui_data *)data;\r
- char *title = dupcat(appname, " Reconfiguration", NULL);\r
- Config cfg2, oldcfg;\r
- int i, need_size;\r
-\r
- assert(lenof(ww) == NCFGCOLOURS);\r
-\r
- if (inst->reconfiguring)\r
- return;\r
- else\r
- inst->reconfiguring = TRUE;\r
-\r
- cfg2 = inst->cfg; /* structure copy */\r
-\r
- if (do_config_box(title, &cfg2, 1,\r
- inst->back?inst->back->cfg_info(inst->backhandle):0)) {\r
-\r
- oldcfg = inst->cfg; /* structure copy */\r
- inst->cfg = cfg2; /* structure copy */\r
-\r
- /* Pass new config data to the logging module */\r
- log_reconfig(inst->logctx, &cfg2);\r
- /*\r
- * Flush the line discipline's edit buffer in the case\r
- * where local editing has just been disabled.\r
- */\r
- if (inst->ldisc)\r
- ldisc_send(inst->ldisc, NULL, 0, 0);\r
- /* Pass new config data to the terminal */\r
- term_reconfig(inst->term, &cfg2);\r
- /* Pass new config data to the back end */\r
- if (inst->back)\r
- inst->back->reconfig(inst->backhandle, &cfg2);\r
-\r
- /*\r
- * Just setting inst->cfg is sufficient to cause colour\r
- * setting changes to appear on the next ESC]R palette\r
- * reset. But we should also check whether any colour\r
- * settings have been changed, and revert the ones that\r
- * have to the new default, on the assumption that the user\r
- * is most likely to want an immediate update.\r
- */\r
- for (i = 0; i < NCFGCOLOURS; i++) {\r
- if (oldcfg.colours[i][0] != cfg2.colours[i][0] ||\r
- oldcfg.colours[i][1] != cfg2.colours[i][1] ||\r
- oldcfg.colours[i][2] != cfg2.colours[i][2]) {\r
- real_palette_set(inst, ww[i], cfg2.colours[i][0],\r
- cfg2.colours[i][1],\r
- cfg2.colours[i][2]);\r
-\r
- /*\r
- * If the default background has changed, we must\r
- * repaint the space in between the window border\r
- * and the text area.\r
- */\r
- if (i == 258) {\r
- set_window_background(inst);\r
- draw_backing_rect(inst);\r
- }\r
- }\r
- }\r
-\r
- /*\r
- * If the scrollbar needs to be shown, hidden, or moved\r
- * from one end to the other of the window, do so now.\r
- */\r
- if (oldcfg.scrollbar != cfg2.scrollbar) {\r
- if (cfg2.scrollbar)\r
- gtk_widget_show(inst->sbar);\r
- else\r
- gtk_widget_hide(inst->sbar);\r
- }\r
- if (oldcfg.scrollbar_on_left != cfg2.scrollbar_on_left) {\r
- gtk_box_reorder_child(inst->hbox, inst->sbar,\r
- cfg2.scrollbar_on_left ? 0 : 1);\r
- }\r
-\r
- /*\r
- * Change the window title, if required.\r
- */\r
- if (strcmp(oldcfg.wintitle, cfg2.wintitle))\r
- set_title(inst, cfg2.wintitle);\r
- set_window_titles(inst);\r
-\r
- /*\r
- * Redo the whole tangled fonts and Unicode mess if\r
- * necessary.\r
- */\r
- if (strcmp(oldcfg.font.name, cfg2.font.name) ||\r
- strcmp(oldcfg.boldfont.name, cfg2.boldfont.name) ||\r
- strcmp(oldcfg.widefont.name, cfg2.widefont.name) ||\r
- strcmp(oldcfg.wideboldfont.name, cfg2.wideboldfont.name) ||\r
- strcmp(oldcfg.line_codepage, cfg2.line_codepage) ||\r
- oldcfg.vtmode != cfg2.vtmode ||\r
- oldcfg.shadowbold != cfg2.shadowbold) {\r
- setup_fonts_ucs(inst);\r
- need_size = 1;\r
- } else\r
- need_size = 0;\r
-\r
- /*\r
- * Resize the window.\r
- */\r
- if (oldcfg.width != cfg2.width || oldcfg.height != cfg2.height ||\r
- oldcfg.window_border != cfg2.window_border || need_size) {\r
- set_geom_hints(inst);\r
- request_resize(inst, cfg2.width, cfg2.height);\r
- } else {\r
- /*\r
- * The above will have caused a call to term_size() for\r
- * us if it happened. If the user has fiddled with only\r
- * the scrollback size, the above will not have\r
- * happened and we will need an explicit term_size()\r
- * here.\r
- */\r
- if (oldcfg.savelines != cfg2.savelines)\r
- term_size(inst->term, inst->term->rows, inst->term->cols,\r
- cfg2.savelines);\r
- }\r
-\r
- term_invalidate(inst->term);\r
-\r
- /*\r
- * We do an explicit full redraw here to ensure the window\r
- * border has been redrawn as well as the text area.\r
- */\r
- gtk_widget_queue_draw(inst->area);\r
- }\r
- sfree(title);\r
- inst->reconfiguring = FALSE;\r
-}\r
-\r
-void fork_and_exec_self(struct gui_data *inst, int fd_to_close, ...)\r
-{\r
- /*\r
- * Re-execing ourself is not an exact science under Unix. I do\r
- * the best I can by using /proc/self/exe if available and by\r
- * assuming argv[0] can be found on $PATH if not.\r
- * \r
- * Note that we also have to reconstruct the elements of the\r
- * original argv which gtk swallowed, since the user wants the\r
- * new session to appear on the same X display as the old one.\r
- */\r
- char **args;\r
- va_list ap;\r
- int i, n;\r
- int pid;\r
-\r
- /*\r
- * Collect the arguments with which to re-exec ourself.\r
- */\r
- va_start(ap, fd_to_close);\r
- n = 2; /* progname and terminating NULL */\r
- n += inst->ngtkargs;\r
- while (va_arg(ap, char *) != NULL)\r
- n++;\r
- va_end(ap);\r
-\r
- args = snewn(n, char *);\r
- args[0] = inst->progname;\r
- args[n-1] = NULL;\r
- for (i = 0; i < inst->ngtkargs; i++)\r
- args[i+1] = inst->gtkargvstart[i];\r
-\r
- i++;\r
- va_start(ap, fd_to_close);\r
- while ((args[i++] = va_arg(ap, char *)) != NULL);\r
- va_end(ap);\r
-\r
- assert(i == n);\r
-\r
- /*\r
- * Do the double fork.\r
- */\r
- pid = fork();\r
- if (pid < 0) {\r
- perror("fork");\r
- return;\r
- }\r
-\r
- if (pid == 0) {\r
- int pid2 = fork();\r
- if (pid2 < 0) {\r
- perror("fork");\r
- _exit(1);\r
- } else if (pid2 > 0) {\r
- /*\r
- * First child has successfully forked second child. My\r
- * Work Here Is Done. Note the use of _exit rather than\r
- * exit: the latter appears to cause destroy messages\r
- * to be sent to the X server. I suspect gtk uses\r
- * atexit.\r
- */\r
- _exit(0);\r
- }\r
-\r
- /*\r
- * If we reach here, we are the second child, so we now\r
- * actually perform the exec.\r
- */\r
- if (fd_to_close >= 0)\r
- close(fd_to_close);\r
-\r
- execv("/proc/self/exe", args);\r
- execvp(inst->progname, args);\r
- perror("exec");\r
- _exit(127);\r
-\r
- } else {\r
- int status;\r
- waitpid(pid, &status, 0);\r
- }\r
-\r
-}\r
-\r
-void dup_session_menuitem(GtkMenuItem *item, gpointer gdata)\r
-{\r
- struct gui_data *inst = (struct gui_data *)gdata;\r
- /*\r
- * For this feature we must marshal cfg and (possibly) pty_argv\r
- * into a byte stream, create a pipe, and send this byte stream\r
- * to the child through the pipe.\r
- */\r
- int i, ret, size;\r
- char *data;\r
- char option[80];\r
- int pipefd[2];\r
-\r
- if (pipe(pipefd) < 0) {\r
- perror("pipe");\r
- return;\r
- }\r
-\r
- size = sizeof(inst->cfg);\r
- if (use_pty_argv && pty_argv) {\r
- for (i = 0; pty_argv[i]; i++)\r
- size += strlen(pty_argv[i]) + 1;\r
- }\r
-\r
- data = snewn(size, char);\r
- memcpy(data, &inst->cfg, sizeof(inst->cfg));\r
- if (use_pty_argv && pty_argv) {\r
- int p = sizeof(inst->cfg);\r
- for (i = 0; pty_argv[i]; i++) {\r
- strcpy(data + p, pty_argv[i]);\r
- p += strlen(pty_argv[i]) + 1;\r
- }\r
- assert(p == size);\r
- }\r
-\r
- sprintf(option, "---[%d,%d]", pipefd[0], size);\r
- fcntl(pipefd[0], F_SETFD, 0);\r
- fork_and_exec_self(inst, pipefd[1], option, NULL);\r
- close(pipefd[0]);\r
-\r
- i = ret = 0;\r
- while (i < size && (ret = write(pipefd[1], data + i, size - i)) > 0)\r
- i += ret;\r
- if (ret < 0)\r
- perror("write to pipe");\r
- close(pipefd[1]);\r
- sfree(data);\r
-}\r
-\r
-int read_dupsession_data(struct gui_data *inst, Config *cfg, char *arg)\r
-{\r
- int fd, i, ret, size;\r
- char *data;\r
-\r
- if (sscanf(arg, "---[%d,%d]", &fd, &size) != 2) {\r
- fprintf(stderr, "%s: malformed magic argument `%s'\n", appname, arg);\r
- exit(1);\r
- }\r
-\r
- data = snewn(size, char);\r
- i = ret = 0;\r
- while (i < size && (ret = read(fd, data + i, size - i)) > 0)\r
- i += ret;\r
- if (ret < 0) {\r
- perror("read from pipe");\r
- exit(1);\r
- } else if (i < size) {\r
- fprintf(stderr, "%s: unexpected EOF in Duplicate Session data\n",\r
- appname);\r
- exit(1);\r
- }\r
-\r
- memcpy(cfg, data, sizeof(Config));\r
- if (use_pty_argv && size > sizeof(Config)) {\r
- int n = 0;\r
- i = sizeof(Config);\r
- while (i < size) {\r
- while (i < size && data[i]) i++;\r
- if (i >= size) {\r
- fprintf(stderr, "%s: malformed Duplicate Session data\n",\r
- appname);\r
- exit(1);\r
- }\r
- i++;\r
- n++;\r
- }\r
- pty_argv = snewn(n+1, char *);\r
- pty_argv[n] = NULL;\r
- n = 0;\r
- i = sizeof(Config);\r
- while (i < size) {\r
- char *p = data + i;\r
- while (i < size && data[i]) i++;\r
- assert(i < size);\r
- i++;\r
- pty_argv[n++] = dupstr(p);\r
- }\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-void new_session_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
-\r
- fork_and_exec_self(inst, -1, NULL);\r
-}\r
-\r
-void restart_session_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
-\r
- if (!inst->back) {\r
- logevent(inst, "----- Session restarted -----");\r
- term_pwron(inst->term, FALSE);\r
- start_backend(inst);\r
- inst->exited = FALSE;\r
- }\r
-}\r
-\r
-void saved_session_menuitem(GtkMenuItem *item, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- char *str = (char *)gtk_object_get_data(GTK_OBJECT(item), "user-data");\r
-\r
- fork_and_exec_self(inst, -1, "-load", str, NULL);\r
-}\r
-\r
-void saved_session_freedata(GtkMenuItem *item, gpointer data)\r
-{\r
- char *str = (char *)gtk_object_get_data(GTK_OBJECT(item), "user-data");\r
-\r
- sfree(str);\r
-}\r
-\r
-static void update_savedsess_menu(GtkMenuItem *menuitem, gpointer data)\r
-{\r
- struct gui_data *inst = (struct gui_data *)data;\r
- struct sesslist sesslist;\r
- int i;\r
-\r
- gtk_container_foreach(GTK_CONTAINER(inst->sessionsmenu),\r
- (GtkCallback)gtk_widget_destroy, NULL);\r
-\r
- get_sesslist(&sesslist, TRUE);\r
- /* skip sesslist.sessions[0] == Default Settings */\r
- for (i = 1; i < sesslist.nsessions; i++) {\r
- GtkWidget *menuitem =\r
- gtk_menu_item_new_with_label(sesslist.sessions[i]);\r
- gtk_container_add(GTK_CONTAINER(inst->sessionsmenu), menuitem);\r
- gtk_widget_show(menuitem);\r
- gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",\r
- dupstr(sesslist.sessions[i]));\r
- gtk_signal_connect(GTK_OBJECT(menuitem), "activate",\r
- GTK_SIGNAL_FUNC(saved_session_menuitem),\r
- inst);\r
- gtk_signal_connect(GTK_OBJECT(menuitem), "destroy",\r
- GTK_SIGNAL_FUNC(saved_session_freedata),\r
- inst);\r
- }\r
- if (sesslist.nsessions <= 1) {\r
- GtkWidget *menuitem =\r
- gtk_menu_item_new_with_label("(No sessions)");\r
- gtk_widget_set_sensitive(menuitem, FALSE);\r
- gtk_container_add(GTK_CONTAINER(inst->sessionsmenu), menuitem);\r
- gtk_widget_show(menuitem);\r
- }\r
- get_sesslist(&sesslist, FALSE); /* free up */\r
-}\r
-\r
-void set_window_icon(GtkWidget *window, const char *const *const *icon,\r
- int n_icon)\r
-{\r
- GdkPixmap *iconpm;\r
- GdkBitmap *iconmask;\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- GList *iconlist;\r
- int n;\r
-#endif\r
-\r
- if (!n_icon)\r
- return;\r
-\r
- gtk_widget_realize(window);\r
- iconpm = gdk_pixmap_create_from_xpm_d(window->window, &iconmask,\r
- NULL, (gchar **)icon[0]);\r
- gdk_window_set_icon(window->window, NULL, iconpm, iconmask);\r
-\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- iconlist = NULL;\r
- for (n = 0; n < n_icon; n++) {\r
- iconlist =\r
- g_list_append(iconlist,\r
- gdk_pixbuf_new_from_xpm_data((const gchar **)\r
- icon[n]));\r
- }\r
- gdk_window_set_icon_list(window->window, iconlist);\r
-#endif\r
-}\r
-\r
-void update_specials_menu(void *frontend)\r
-{\r
- struct gui_data *inst = (struct gui_data *)frontend;\r
-\r
- const struct telnet_special *specials;\r
-\r
- if (inst->back)\r
- specials = inst->back->get_specials(inst->backhandle);\r
- else\r
- specials = NULL;\r
-\r
- /* I believe this disposes of submenus too. */\r
- gtk_container_foreach(GTK_CONTAINER(inst->specialsmenu),\r
- (GtkCallback)gtk_widget_destroy, NULL);\r
- if (specials) {\r
- int i;\r
- GtkWidget *menu = inst->specialsmenu;\r
- /* A lame "stack" for submenus that will do for now. */\r
- GtkWidget *saved_menu = NULL;\r
- int nesting = 1;\r
- for (i = 0; nesting > 0; i++) {\r
- GtkWidget *menuitem = NULL;\r
- switch (specials[i].code) {\r
- case TS_SUBMENU:\r
- assert (nesting < 2);\r
- saved_menu = menu; /* XXX lame stacking */\r
- menu = gtk_menu_new();\r
- menuitem = gtk_menu_item_new_with_label(specials[i].name);\r
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);\r
- gtk_container_add(GTK_CONTAINER(saved_menu), menuitem);\r
- gtk_widget_show(menuitem);\r
- menuitem = NULL;\r
- nesting++;\r
- break;\r
- case TS_EXITMENU:\r
- nesting--;\r
- if (nesting) {\r
- menu = saved_menu; /* XXX lame stacking */\r
- saved_menu = NULL;\r
- }\r
- break;\r
- case TS_SEP:\r
- menuitem = gtk_menu_item_new();\r
- break;\r
- default:\r
- menuitem = gtk_menu_item_new_with_label(specials[i].name);\r
- gtk_object_set_data(GTK_OBJECT(menuitem), "user-data",\r
- GINT_TO_POINTER(specials[i].code));\r
- gtk_signal_connect(GTK_OBJECT(menuitem), "activate",\r
- GTK_SIGNAL_FUNC(special_menuitem), inst);\r
- break;\r
- }\r
- if (menuitem) {\r
- gtk_container_add(GTK_CONTAINER(menu), menuitem);\r
- gtk_widget_show(menuitem);\r
- }\r
- }\r
- gtk_widget_show(inst->specialsitem1);\r
- gtk_widget_show(inst->specialsitem2);\r
- } else {\r
- gtk_widget_hide(inst->specialsitem1);\r
- gtk_widget_hide(inst->specialsitem2);\r
- }\r
-}\r
-\r
-static void start_backend(struct gui_data *inst)\r
-{\r
- extern Backend *select_backend(Config *cfg);\r
- char *realhost;\r
- const char *error;\r
-\r
- inst->back = select_backend(&inst->cfg);\r
-\r
- error = inst->back->init((void *)inst, &inst->backhandle,\r
- &inst->cfg, inst->cfg.host, inst->cfg.port,\r
- &realhost, inst->cfg.tcp_nodelay,\r
- inst->cfg.tcp_keepalives);\r
-\r
- if (error) {\r
- char *msg = dupprintf("Unable to open connection to %s:\n%s",\r
- inst->cfg.host, error);\r
- inst->exited = TRUE;\r
- fatal_message_box(inst->window, msg);\r
- sfree(msg);\r
- exit(0);\r
- }\r
-\r
- if (inst->cfg.wintitle[0]) {\r
- set_title(inst, inst->cfg.wintitle);\r
- set_icon(inst, inst->cfg.wintitle);\r
- } else {\r
- char *title = make_default_wintitle(realhost);\r
- set_title(inst, title);\r
- set_icon(inst, title);\r
- sfree(title);\r
- }\r
- sfree(realhost);\r
-\r
- inst->back->provide_logctx(inst->backhandle, inst->logctx);\r
-\r
- term_provide_resize_fn(inst->term, inst->back->size, inst->backhandle);\r
-\r
- inst->ldisc =\r
- ldisc_create(&inst->cfg, inst->term, inst->back, inst->backhandle,\r
- inst);\r
-\r
- gtk_widget_set_sensitive(inst->restartitem, FALSE);\r
-}\r
-\r
-int pt_main(int argc, char **argv)\r
-{\r
- extern int cfgbox(Config *cfg);\r
- struct gui_data *inst;\r
-\r
- /*\r
- * Create an instance structure and initialise to zeroes\r
- */\r
- inst = snew(struct gui_data);\r
- memset(inst, 0, sizeof(*inst));\r
- inst->alt_keycode = -1; /* this one needs _not_ to be zero */\r
- inst->busy_status = BUSY_NOT;\r
-\r
- /* defer any child exit handling until we're ready to deal with\r
- * it */\r
- block_signal(SIGCHLD, 1);\r
-\r
- inst->progname = argv[0];\r
- /*\r
- * Copy the original argv before letting gtk_init fiddle with\r
- * it. It will be required later.\r
- */\r
- {\r
- int i, oldargc;\r
- inst->gtkargvstart = snewn(argc-1, char *);\r
- for (i = 1; i < argc; i++)\r
- inst->gtkargvstart[i-1] = dupstr(argv[i]);\r
- oldargc = argc;\r
- gtk_init(&argc, &argv);\r
- inst->ngtkargs = oldargc - argc;\r
- }\r
-\r
- if (argc > 1 && !strncmp(argv[1], "---", 3)) {\r
- read_dupsession_data(inst, &inst->cfg, argv[1]);\r
- /* Splatter this argument so it doesn't clutter a ps listing */\r
- memset(argv[1], 0, strlen(argv[1]));\r
- } else {\r
- /* By default, we bring up the config dialog, rather than launching\r
- * a session. This gets set to TRUE if something happens to change\r
- * that (e.g., a hostname is specified on the command-line). */\r
- int allow_launch = FALSE;\r
- if (do_cmdline(argc, argv, 0, &allow_launch, inst, &inst->cfg))\r
- exit(1); /* pre-defaults pass to get -class */\r
- do_defaults(NULL, &inst->cfg);\r
- if (do_cmdline(argc, argv, 1, &allow_launch, inst, &inst->cfg))\r
- exit(1); /* post-defaults, do everything */\r
-\r
- cmdline_run_saved(&inst->cfg);\r
-\r
- if (loaded_session)\r
- allow_launch = TRUE;\r
-\r
- if ((!allow_launch || !cfg_launchable(&inst->cfg)) &&\r
- !cfgbox(&inst->cfg))\r
- exit(0); /* config box hit Cancel */\r
- }\r
-\r
- if (!compound_text_atom)\r
- compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", FALSE);\r
- if (!utf8_string_atom)\r
- utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE);\r
-\r
- inst->area = gtk_drawing_area_new();\r
-\r
- setup_fonts_ucs(inst);\r
- init_cutbuffers();\r
-\r
- inst->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);\r
- if (inst->cfg.winclass[0])\r
- gtk_window_set_wmclass(GTK_WINDOW(inst->window),\r
- inst->cfg.winclass, inst->cfg.winclass);\r
-\r
- /*\r
- * Set up the colour map.\r
- */\r
- palette_reset(inst);\r
-\r
- inst->width = inst->cfg.width;\r
- inst->height = inst->cfg.height;\r
-\r
- gtk_drawing_area_size(GTK_DRAWING_AREA(inst->area),\r
- inst->font_width * inst->cfg.width + 2*inst->cfg.window_border,\r
- inst->font_height * inst->cfg.height + 2*inst->cfg.window_border);\r
- inst->sbar_adjust = GTK_ADJUSTMENT(gtk_adjustment_new(0,0,0,0,0,0));\r
- inst->sbar = gtk_vscrollbar_new(inst->sbar_adjust);\r
- inst->hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));\r
- /*\r
- * We always create the scrollbar; it remains invisible if\r
- * unwanted, so we can pop it up quickly if it suddenly becomes\r
- * desirable.\r
- */\r
- if (inst->cfg.scrollbar_on_left)\r
- gtk_box_pack_start(inst->hbox, inst->sbar, FALSE, FALSE, 0);\r
- gtk_box_pack_start(inst->hbox, inst->area, TRUE, TRUE, 0);\r
- if (!inst->cfg.scrollbar_on_left)\r
- gtk_box_pack_start(inst->hbox, inst->sbar, FALSE, FALSE, 0);\r
-\r
- gtk_container_add(GTK_CONTAINER(inst->window), GTK_WIDGET(inst->hbox));\r
-\r
- set_geom_hints(inst);\r
-\r
- gtk_widget_show(inst->area);\r
- if (inst->cfg.scrollbar)\r
- gtk_widget_show(inst->sbar);\r
- else\r
- gtk_widget_hide(inst->sbar);\r
- gtk_widget_show(GTK_WIDGET(inst->hbox));\r
-\r
- if (inst->gotpos) {\r
- int x = inst->xpos, y = inst->ypos;\r
- GtkRequisition req;\r
- gtk_widget_size_request(GTK_WIDGET(inst->window), &req);\r
- if (inst->gravity & 1) x += gdk_screen_width() - req.width;\r
- if (inst->gravity & 2) y += gdk_screen_height() - req.height;\r
- gtk_window_set_position(GTK_WINDOW(inst->window), GTK_WIN_POS_NONE);\r
- gtk_widget_set_uposition(GTK_WIDGET(inst->window), x, y);\r
- }\r
-\r
- gtk_signal_connect(GTK_OBJECT(inst->window), "destroy",\r
- GTK_SIGNAL_FUNC(destroy), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->window), "delete_event",\r
- GTK_SIGNAL_FUNC(delete_window), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->window), "key_press_event",\r
- GTK_SIGNAL_FUNC(key_event), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->window), "key_release_event",\r
- GTK_SIGNAL_FUNC(key_event), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->window), "focus_in_event",\r
- GTK_SIGNAL_FUNC(focus_event), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->window), "focus_out_event",\r
- GTK_SIGNAL_FUNC(focus_event), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->area), "configure_event",\r
- GTK_SIGNAL_FUNC(configure_area), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->area), "expose_event",\r
- GTK_SIGNAL_FUNC(expose_area), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->area), "button_press_event",\r
- GTK_SIGNAL_FUNC(button_event), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->area), "button_release_event",\r
- GTK_SIGNAL_FUNC(button_event), inst);\r
-#if GTK_CHECK_VERSION(2,0,0)\r
- gtk_signal_connect(GTK_OBJECT(inst->area), "scroll_event",\r
- GTK_SIGNAL_FUNC(scroll_event), inst);\r
-#endif\r
- gtk_signal_connect(GTK_OBJECT(inst->area), "motion_notify_event",\r
- GTK_SIGNAL_FUNC(motion_event), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->area), "selection_received",\r
- GTK_SIGNAL_FUNC(selection_received), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->area), "selection_get",\r
- GTK_SIGNAL_FUNC(selection_get), inst);\r
- gtk_signal_connect(GTK_OBJECT(inst->area), "selection_clear_event",\r
- GTK_SIGNAL_FUNC(selection_clear), inst);\r
- if (inst->cfg.scrollbar)\r
- gtk_signal_connect(GTK_OBJECT(inst->sbar_adjust), "value_changed",\r
- GTK_SIGNAL_FUNC(scrollbar_moved), inst);\r
- gtk_widget_add_events(GTK_WIDGET(inst->area),\r
- GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK |\r
- GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |\r
- GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK);\r
-\r
- {\r
- extern const char *const *const main_icon[];\r
- extern const int n_main_icon;\r
- set_window_icon(inst->window, main_icon, n_main_icon);\r
- }\r
-\r
- gtk_widget_show(inst->window);\r
-\r
- set_window_background(inst);\r
-\r
- /*\r
- * Set up the Ctrl+rightclick context menu.\r
- */\r
- {\r
- GtkWidget *menuitem;\r
- char *s;\r
- extern const int use_event_log, new_session, saved_sessions;\r
-\r
- inst->menu = gtk_menu_new();\r
-\r
-#define MKMENUITEM(title, func) do \\r
- { \\r
- menuitem = gtk_menu_item_new_with_label(title); \\r
- gtk_container_add(GTK_CONTAINER(inst->menu), menuitem); \\r
- gtk_widget_show(menuitem); \\r
- gtk_signal_connect(GTK_OBJECT(menuitem), "activate", \\r
- GTK_SIGNAL_FUNC(func), inst); \\r
- } while (0)\r
-\r
-#define MKSUBMENU(title) do \\r
- { \\r
- menuitem = gtk_menu_item_new_with_label(title); \\r
- gtk_container_add(GTK_CONTAINER(inst->menu), menuitem); \\r
- gtk_widget_show(menuitem); \\r
- } while (0)\r
-\r
-#define MKSEP() do \\r
- { \\r
- menuitem = gtk_menu_item_new(); \\r
- gtk_container_add(GTK_CONTAINER(inst->menu), menuitem); \\r
- gtk_widget_show(menuitem); \\r
- } while (0)\r
-\r
- if (new_session)\r
- MKMENUITEM("New Session...", new_session_menuitem);\r
- MKMENUITEM("Restart Session", restart_session_menuitem);\r
- inst->restartitem = menuitem;\r
- gtk_widget_set_sensitive(inst->restartitem, FALSE);\r
- MKMENUITEM("Duplicate Session", dup_session_menuitem);\r
- if (saved_sessions) {\r
- inst->sessionsmenu = gtk_menu_new();\r
- /* sessionsmenu will be updated when it's invoked */\r
- /* XXX is this the right way to do dynamic menus in Gtk? */\r
- MKMENUITEM("Saved Sessions", update_savedsess_menu);\r
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem),\r
- inst->sessionsmenu);\r
- }\r
- MKSEP();\r
- MKMENUITEM("Change Settings...", change_settings_menuitem);\r
- MKSEP();\r
- if (use_event_log)\r
- MKMENUITEM("Event Log", event_log_menuitem);\r
- MKSUBMENU("Special Commands");\r
- inst->specialsmenu = gtk_menu_new();\r
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), inst->specialsmenu);\r
- inst->specialsitem1 = menuitem;\r
- MKSEP();\r
- inst->specialsitem2 = menuitem;\r
- gtk_widget_hide(inst->specialsitem1);\r
- gtk_widget_hide(inst->specialsitem2);\r
- MKMENUITEM("Clear Scrollback", clear_scrollback_menuitem);\r
- MKMENUITEM("Reset Terminal", reset_terminal_menuitem);\r
- MKMENUITEM("Copy All", copy_all_menuitem);\r
- MKSEP();\r
- s = dupcat("About ", appname, NULL);\r
- MKMENUITEM(s, about_menuitem);\r
- sfree(s);\r
-#undef MKMENUITEM\r
-#undef MKSUBMENU\r
-#undef MKSEP\r
- }\r
-\r
- inst->textcursor = make_mouse_ptr(inst, GDK_XTERM);\r
- inst->rawcursor = make_mouse_ptr(inst, GDK_LEFT_PTR);\r
- inst->waitcursor = make_mouse_ptr(inst, GDK_WATCH);\r
- inst->blankcursor = make_mouse_ptr(inst, -1);\r
- make_mouse_ptr(inst, -2); /* clean up cursor font */\r
- inst->currcursor = inst->textcursor;\r
- show_mouseptr(inst, 1);\r
-\r
- inst->eventlogstuff = eventlogstuff_new();\r
-\r
- inst->term = term_init(&inst->cfg, &inst->ucsdata, inst);\r
- inst->logctx = log_init(inst, &inst->cfg);\r
- term_provide_logctx(inst->term, inst->logctx);\r
-\r
- uxsel_init();\r
-\r
- term_size(inst->term, inst->cfg.height, inst->cfg.width, inst->cfg.savelines);\r
-\r
- start_backend(inst);\r
-\r
- ldisc_send(inst->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */\r
-\r
- /* now we're reday to deal with the child exit handler being\r
- * called */\r
- block_signal(SIGCHLD, 0);\r
-\r
- /*\r
- * Block SIGPIPE: if we attempt Duplicate Session or similar\r
- * and it falls over in some way, we certainly don't want\r
- * SIGPIPE terminating the main pterm/PuTTY. Note that we do\r
- * this _after_ (at least pterm) forks off its child process,\r
- * since the child wants SIGPIPE handled in the usual way.\r
- */\r
- block_signal(SIGPIPE, 1);\r
-\r
- inst->exited = FALSE;\r
-\r
- gtk_main();\r
-\r
- return 0;\r
-}\r
OSDN Git Service
