+void palette_set(void *frontend, int n, int r, int g, int b)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+ static const int first[21] = {
+ 0, 2, 4, 6, 8, 10, 12, 14,
+ 1, 3, 5, 7, 9, 11, 13, 15,
+ 16, 17, 18, 20, 22
+ };
+ real_palette_set(inst, first[n], r, g, b);
+ if (first[n] >= 18)
+ real_palette_set(inst, first[n] + 1, r, g, b);
+ if (first[n] == 18)
+ set_window_background(inst);
+}
+
+void palette_reset(void *frontend)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+ /* This maps colour indices in cfg to those used in inst->cols. */
+ static const int ww[] = {
+ 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21,
+ 0, 1, 2, 3, 4, 5
+ };
+ gboolean success[NCOLOURS];
+ int i;
+
+ assert(lenof(ww) == NCOLOURS);
+
+ if (!inst->colmap) {
+ inst->colmap = gdk_colormap_get_system();
+ } else {
+ gdk_colormap_free_colors(inst->colmap, inst->cols, NCOLOURS);
+ }
+
+ for (i = 0; i < NCOLOURS; i++) {
+ inst->cols[i].red = cfg.colours[ww[i]][0] * 0x0101;
+ inst->cols[i].green = cfg.colours[ww[i]][1] * 0x0101;
+ inst->cols[i].blue = cfg.colours[ww[i]][2] * 0x0101;
+ }
+
+ gdk_colormap_alloc_colors(inst->colmap, inst->cols, NCOLOURS,
+ FALSE, FALSE, success);
+ for (i = 0; i < NCOLOURS; i++) {
+ if (!success[i])
+ g_error("pterm: couldn't allocate colour %d (#%02x%02x%02x)\n",
+ i, cfg.colours[i][0], cfg.colours[i][1], cfg.colours[i][2]);
+ }
+
+ set_window_background(inst);
+}
+
+void write_clip(void *frontend, wchar_t * data, int len, int must_deselect)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+ if (inst->pasteout_data)
+ sfree(inst->pasteout_data);
+ if (inst->pasteout_data_utf8)
+ sfree(inst->pasteout_data_utf8);
+
+ inst->pasteout_data_utf8 = smalloc(len*6);
+ inst->pasteout_data_utf8_len = len*6;
+ {
+ wchar_t *tmp = data;
+ int tmplen = len;
+ inst->pasteout_data_utf8_len =
+ charset_from_unicode(&tmp, &tmplen, inst->pasteout_data_utf8,
+ inst->pasteout_data_utf8_len,
+ CS_UTF8, NULL, NULL, 0);
+ inst->pasteout_data_utf8 =
+ srealloc(inst->pasteout_data_utf8, inst->pasteout_data_utf8_len);
+ }
+
+ inst->pasteout_data = smalloc(len);
+ inst->pasteout_data_len = len;
+ wc_to_mb(line_codepage, 0, data, len,
+ inst->pasteout_data, inst->pasteout_data_len,
+ NULL, NULL);
+
+ if (gtk_selection_owner_set(inst->area, GDK_SELECTION_PRIMARY,
+ GDK_CURRENT_TIME)) {
+ gtk_selection_add_target(inst->area, GDK_SELECTION_PRIMARY,
+ GDK_SELECTION_TYPE_STRING, 1);
+ gtk_selection_add_target(inst->area, GDK_SELECTION_PRIMARY,
+ inst->compound_text_atom, 1);
+ gtk_selection_add_target(inst->area, GDK_SELECTION_PRIMARY,
+ inst->utf8_string_atom, 1);
+ }
+}
+
+void selection_get(GtkWidget *widget, GtkSelectionData *seldata,
+ guint info, guint time_stamp, gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+ if (seldata->target == inst->utf8_string_atom)
+ gtk_selection_data_set(seldata, seldata->target, 8,
+ inst->pasteout_data_utf8,
+ inst->pasteout_data_utf8_len);
+ else
+ gtk_selection_data_set(seldata, seldata->target, 8,
+ inst->pasteout_data, inst->pasteout_data_len);
+}
+
+gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata,
+ gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+ term_deselect(inst->term);
+ if (inst->pasteout_data)
+ sfree(inst->pasteout_data);
+ if (inst->pasteout_data_utf8)
+ sfree(inst->pasteout_data_utf8);
+ inst->pasteout_data = NULL;
+ inst->pasteout_data_len = 0;
+ inst->pasteout_data_utf8 = NULL;
+ inst->pasteout_data_utf8_len = 0;
+ return TRUE;
+}
+
+void request_paste(void *frontend)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+ /*
+ * In Unix, pasting is asynchronous: all we can do at the
+ * moment is to call gtk_selection_convert(), and when the data
+ * comes back _then_ we can call term_do_paste().
+ */
+
+ /*
+ * First we attempt to retrieve the selection as a UTF-8 string
+ * (which we will convert to the correct code page before
+ * sending to the session, of course). If that fails,
+ * selection_received() will be informed and will fall back to
+ * an ordinary string.
+ */
+ gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,
+ inst->utf8_string_atom, GDK_CURRENT_TIME);
+}
+
+gint idle_paste_func(gpointer data); /* forward ref */
+
+void selection_received(GtkWidget *widget, GtkSelectionData *seldata,
+ guint time, gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+
+ if (seldata->target == inst->utf8_string_atom && seldata->length <= 0) {
+ /*
+ * Failed to get a UTF-8 selection string. Try an ordinary
+ * string.
+ */
+ gtk_selection_convert(inst->area, GDK_SELECTION_PRIMARY,
+ GDK_SELECTION_TYPE_STRING, GDK_CURRENT_TIME);
+ return;
+ }
+
+ /*
+ * Any other failure should just go foom.
+ */
+ if (seldata->length <= 0 ||
+ (seldata->type != GDK_SELECTION_TYPE_STRING &&
+ seldata->type != inst->utf8_string_atom))
+ return; /* Nothing happens. */
+
+ if (inst->pastein_data)
+ sfree(inst->pastein_data);
+
+ inst->pastein_data = smalloc(seldata->length * sizeof(wchar_t));
+ inst->pastein_data_len = seldata->length;
+ inst->pastein_data_len =
+ mb_to_wc((seldata->type == inst->utf8_string_atom ?
+ CS_UTF8 : line_codepage),
+ 0, seldata->data, seldata->length,
+ inst->pastein_data, inst->pastein_data_len);
+
+ term_do_paste(inst->term);
+
+ if (term_paste_pending(inst->term))
+ inst->term_paste_idle_id = gtk_idle_add(idle_paste_func, inst);
+}
+
+gint idle_paste_func(gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+
+ if (term_paste_pending(inst->term))
+ term_paste(inst->term);
+ else
+ gtk_idle_remove(inst->term_paste_idle_id);
+
+ return TRUE;
+}
+
+
+void get_clip(void *frontend, wchar_t ** p, int *len)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+
+ if (p) {
+ *p = inst->pastein_data;
+ *len = inst->pastein_data_len;
+ }
+}
+
+void set_title(void *frontend, char *title)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+ strncpy(inst->wintitle, title, lenof(inst->wintitle));
+ inst->wintitle[lenof(inst->wintitle)-1] = '\0';
+ gtk_window_set_title(GTK_WINDOW(inst->window), inst->wintitle);
+}
+
+void set_icon(void *frontend, char *title)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+ strncpy(inst->icontitle, title, lenof(inst->icontitle));
+ inst->icontitle[lenof(inst->icontitle)-1] = '\0';
+ gdk_window_set_icon_name(inst->window->window, inst->icontitle);
+}
+
+void set_sbar(void *frontend, int total, int start, int page)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+ if (!cfg.scrollbar)
+ return;
+ inst->sbar_adjust->lower = 0;
+ inst->sbar_adjust->upper = total;
+ inst->sbar_adjust->value = start;
+ inst->sbar_adjust->page_size = page;
+ inst->sbar_adjust->step_increment = 1;
+ inst->sbar_adjust->page_increment = page/2;
+ inst->ignore_sbar = TRUE;
+ gtk_adjustment_changed(inst->sbar_adjust);
+ inst->ignore_sbar = FALSE;
+}
+
+void scrollbar_moved(GtkAdjustment *adj, gpointer data)
+{
+ struct gui_data *inst = (struct gui_data *)data;
+
+ if (!cfg.scrollbar)
+ return;
+ if (!inst->ignore_sbar)
+ term_scroll(inst->term, 1, (int)adj->value);
+}
+
+void sys_cursor(void *frontend, int x, int y)
+{
+ /*
+ * This is meaningless under X.
+ */
+}
+
+/*
+ * This is still called when mode==BELL_VISUAL, even though the
+ * visual bell is handled entirely within terminal.c, because we
+ * may want to perform additional actions on any kind of bell (for
+ * example, taskbar flashing in Windows).
+ */
+void beep(void *frontend, int mode)
+{
+ if (mode != BELL_VISUAL)
+ gdk_beep();
+}
+
+int char_width(Context ctx, int uc)
+{
+ /*
+ * Under X, any fixed-width font really _is_ fixed-width.
+ * Double-width characters will be dealt with using a separate
+ * font. For the moment we can simply return 1.
+ */
+ return 1;
+}
+
+Context get_ctx(void *frontend)
+{
+ struct gui_data *inst = (struct gui_data *)frontend;
+ struct draw_ctx *dctx;
+
+ if (!inst->area->window)
+ return NULL;
+
+ dctx = smalloc(sizeof(*dctx));
+ dctx->inst = inst;
+ dctx->gc = gdk_gc_new(inst->area->window);
+ return dctx;
+}
+
+void free_ctx(Context ctx)
+{
+ struct draw_ctx *dctx = (struct draw_ctx *)ctx;
+ /* struct gui_data *inst = dctx->inst; */
+ GdkGC *gc = dctx->gc;
+ gdk_gc_unref(gc);
+ sfree(dctx);
+}
+
+/*
+ * Draw a line of text in the window, at given character
+ * coordinates, in given attributes.
+ *
+ * We are allowed to fiddle with the contents of `text'.
+ */
+void do_text_internal(Context ctx, int x, int y, char *text, int len,
+ unsigned long attr, int lattr)
+{
+ struct draw_ctx *dctx = (struct draw_ctx *)ctx;
+ struct gui_data *inst = dctx->inst;
+ GdkGC *gc = dctx->gc;
+
+ int nfg, nbg, t, fontid, shadow, rlen;
+
+ /*
+ * NYI:
+ * - Unicode, code pages, and ATTR_WIDE for CJK support.
+ */
+
+ nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
+ nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
+ if (attr & ATTR_REVERSE) {
+ t = nfg;
+ nfg = nbg;
+ nbg = t;
+ }
+ if (cfg.bold_colour && (attr & ATTR_BOLD))
+ nfg++;
+ if (cfg.bold_colour && (attr & ATTR_BLINK))
+ nbg++;
+ if (attr & TATTR_ACTCURS) {
+ nfg = NCOLOURS-2;
+ nbg = NCOLOURS-1;
+ }
+
+ fontid = shadow = 0;
+ if ((attr & ATTR_BOLD) && !cfg.bold_colour) {
+ if (inst->fonts[1])
+ fontid = 1;
+ else
+ shadow = 1;
+ }
+
+ if (lattr != LATTR_NORM) {
+ x *= 2;
+ if (x >= inst->term->cols)
+ return;
+ if (x + len*2 > inst->term->cols)
+ len = (inst->term->cols-x)/2; /* trim to LH half */
+ rlen = len * 2;
+ } else
+ rlen = len;
+
+ {
+ GdkRectangle r;
+
+ r.x = x*inst->font_width+cfg.window_border;
+ r.y = y*inst->font_height+cfg.window_border;
+ r.width = rlen*inst->font_width;
+ r.height = inst->font_height;
+ gdk_gc_set_clip_rectangle(gc, &r);
+ }
+
+ gdk_gc_set_foreground(gc, &inst->cols[nbg]);
+ gdk_draw_rectangle(inst->pixmap, gc, 1,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border,
+ rlen*inst->font_width, inst->font_height);
+
+ gdk_gc_set_foreground(gc, &inst->cols[nfg]);
+ {
+ GdkWChar *gwcs;
+ gchar *gcs;
+ wchar_t *wcs;
+ int i;
+
+ wcs = smalloc(sizeof(wchar_t) * (len+1));
+ for (i = 0; i < len; i++) {
+ wcs[i] = (wchar_t) ((attr & CSET_MASK) + (text[i] & CHAR_MASK));
+ }
+
+ if (inst->fontinfo[fontid].is_wide) {
+ gwcs = smalloc(sizeof(GdkWChar) * (len+1));
+ /*
+ * FIXME: when we have a wide-char equivalent of
+ * from_unicode, use it instead of this.
+ */
+ for (i = 0; i <= len; i++)
+ gwcs[i] = wcs[i];
+ gdk_draw_text_wc(inst->pixmap, inst->fonts[fontid], gc,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border+inst->fonts[0]->ascent,
+ gwcs, len*2);
+ sfree(gwcs);
+ } else {
+ wchar_t *wcstmp = wcs;
+ int lentmp = len;
+ gcs = smalloc(sizeof(GdkWChar) * (len+1));
+ charset_from_unicode(&wcstmp, &lentmp, gcs, len,
+ inst->fontinfo[fontid].charset,
+ NULL, ".", 1);
+ gdk_draw_text(inst->pixmap, inst->fonts[fontid], gc,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border+inst->fonts[0]->ascent,
+ gcs, len);
+ sfree(gcs);
+ }
+ sfree(wcs);
+ }
+
+ if (shadow) {
+ gdk_draw_text(inst->pixmap, inst->fonts[fontid], gc,
+ x*inst->font_width+cfg.window_border + cfg.shadowboldoffset,
+ y*inst->font_height+cfg.window_border+inst->fonts[0]->ascent,
+ text, len);
+ }
+
+ if (attr & ATTR_UNDER) {
+ int uheight = inst->fonts[0]->ascent + 1;
+ if (uheight >= inst->font_height)
+ uheight = inst->font_height - 1;
+ gdk_draw_line(inst->pixmap, gc, x*inst->font_width+cfg.window_border,
+ y*inst->font_height + uheight + cfg.window_border,
+ (x+len)*inst->font_width-1+cfg.window_border,
+ y*inst->font_height + uheight + cfg.window_border);
+ }
+
+ if (lattr != LATTR_NORM) {
+ /*
+ * I can't find any plausible StretchBlt equivalent in the
+ * X server, so I'm going to do this the slow and painful
+ * way. This will involve repeated calls to
+ * gdk_draw_pixmap() to stretch the text horizontally. It's
+ * O(N^2) in time and O(N) in network bandwidth, but you
+ * try thinking of a better way. :-(
+ */
+ int i;
+ for (i = 0; i < len * inst->font_width; i++) {
+ gdk_draw_pixmap(inst->pixmap, gc, inst->pixmap,
+ x*inst->font_width+cfg.window_border + 2*i,
+ y*inst->font_height+cfg.window_border,
+ x*inst->font_width+cfg.window_border + 2*i+1,
+ y*inst->font_height+cfg.window_border,
+ len * inst->font_width - i, inst->font_height);
+ }
+ len *= 2;
+ if (lattr != LATTR_WIDE) {
+ int dt, db;
+ /* Now stretch vertically, in the same way. */
+ if (lattr == LATTR_BOT)
+ dt = 0, db = 1;
+ else
+ dt = 1, db = 0;
+ for (i = 0; i < inst->font_height; i+=2) {
+ gdk_draw_pixmap(inst->pixmap, gc, inst->pixmap,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border+dt*i+db,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border+dt*(i+1),
+ len * inst->font_width, inst->font_height-i-1);
+ }
+ }
+ }
+}
+
+void do_text(Context ctx, int x, int y, char *text, int len,
+ unsigned long attr, int lattr)
+{
+ struct draw_ctx *dctx = (struct draw_ctx *)ctx;
+ struct gui_data *inst = dctx->inst;
+ GdkGC *gc = dctx->gc;
+
+ do_text_internal(ctx, x, y, text, len, attr, lattr);
+
+ if (lattr != LATTR_NORM) {
+ x *= 2;
+ if (x >= inst->term->cols)
+ return;
+ if (x + len*2 > inst->term->cols)
+ len = (inst->term->cols-x)/2; /* trim to LH half */
+ len *= 2;
+ }
+
+ gdk_draw_pixmap(inst->area->window, gc, inst->pixmap,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border,
+ len*inst->font_width, inst->font_height);
+}
+
+void do_cursor(Context ctx, int x, int y, char *text, int len,
+ unsigned long attr, int lattr)
+{
+ struct draw_ctx *dctx = (struct draw_ctx *)ctx;
+ struct gui_data *inst = dctx->inst;
+ GdkGC *gc = dctx->gc;
+
+ int passive;
+
+ if (attr & TATTR_PASCURS) {
+ attr &= ~TATTR_PASCURS;
+ passive = 1;
+ } else
+ passive = 0;
+ if ((attr & TATTR_ACTCURS) && cfg.cursor_type != 0) {
+ attr &= ~TATTR_ACTCURS;
+ }
+ do_text_internal(ctx, x, y, text, len, attr, lattr);
+
+ if (lattr != LATTR_NORM) {
+ x *= 2;
+ if (x >= inst->term->cols)
+ return;
+ if (x + len*2 > inst->term->cols)
+ len = (inst->term->cols-x)/2; /* trim to LH half */
+ len *= 2;
+ }
+
+ if (cfg.cursor_type == 0) {
+ /*
+ * An active block cursor will already have been done by
+ * the above do_text call, so we only need to do anything
+ * if it's passive.
+ */
+ if (passive) {
+ gdk_gc_set_foreground(gc, &inst->cols[NCOLOURS-1]);
+ gdk_draw_rectangle(inst->pixmap, gc, 0,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border,
+ len*inst->font_width-1, inst->font_height-1);
+ }
+ } else {
+ int uheight;
+ int startx, starty, dx, dy, length, i;
+
+ int char_width;
+
+ if ((attr & ATTR_WIDE) || lattr != LATTR_NORM)
+ char_width = 2*inst->font_width;
+ else
+ char_width = inst->font_width;
+
+ if (cfg.cursor_type == 1) {
+ uheight = inst->fonts[0]->ascent + 1;
+ if (uheight >= inst->font_height)
+ uheight = inst->font_height - 1;
+
+ startx = x * inst->font_width + cfg.window_border;
+ starty = y * inst->font_height + cfg.window_border + uheight;
+ dx = 1;
+ dy = 0;
+ length = len * char_width;
+ } else {
+ int xadjust = 0;
+ if (attr & TATTR_RIGHTCURS)
+ xadjust = char_width - 1;
+ startx = x * inst->font_width + cfg.window_border + xadjust;
+ starty = y * inst->font_height + cfg.window_border;
+ dx = 0;
+ dy = 1;
+ length = inst->font_height;
+ }
+
+ gdk_gc_set_foreground(gc, &inst->cols[NCOLOURS-1]);
+ if (passive) {
+ for (i = 0; i < length; i++) {
+ if (i % 2 == 0) {
+ gdk_draw_point(inst->pixmap, gc, startx, starty);
+ }
+ startx += dx;
+ starty += dy;
+ }
+ } else {
+ gdk_draw_line(inst->pixmap, gc, startx, starty,
+ startx + (length-1) * dx, starty + (length-1) * dy);
+ }
+ }
+
+ gdk_draw_pixmap(inst->area->window, gc, inst->pixmap,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border,
+ x*inst->font_width+cfg.window_border,
+ y*inst->font_height+cfg.window_border,
+ len*inst->font_width, inst->font_height);
+}
+
+GdkCursor *make_mouse_ptr(struct gui_data *inst, int cursor_val)
+{
+ /*
+ * Truly hideous hack: GTK doesn't allow us to set the mouse
+ * cursor foreground and background colours unless we've _also_
+ * created our own cursor from bitmaps. Therefore, I need to
+ * load the `cursor' font and draw glyphs from it on to
+ * pixmaps, in order to construct my cursors with the fg and bg
+ * I want. This is a gross hack, but it's more self-contained
+ * than linking in Xlib to find the X window handle to
+ * inst->area and calling XRecolorCursor, and it's more
+ * futureproof than hard-coding the shapes as bitmap arrays.
+ */
+ static GdkFont *cursor_font = NULL;
+ GdkPixmap *source, *mask;
+ GdkGC *gc;
+ GdkColor cfg = { 0, 65535, 65535, 65535 };
+ GdkColor cbg = { 0, 0, 0, 0 };
+ GdkColor dfg = { 1, 65535, 65535, 65535 };
+ GdkColor dbg = { 0, 0, 0, 0 };
+ GdkCursor *ret;
+ gchar text[2];
+ gint lb, rb, wid, asc, desc, w, h, x, y;
+
+ if (cursor_val == -2) {
+ gdk_font_unref(cursor_font);
+ return NULL;
+ }
+
+ if (cursor_val >= 0 && !cursor_font)
+ cursor_font = gdk_font_load("cursor");
+
+ /*
+ * Get the text extent of the cursor in question. We use the
+ * mask character for this, because it's typically slightly
+ * bigger than the main character.
+ */
+ if (cursor_val >= 0) {
+ text[1] = '\0';
+ text[0] = (char)cursor_val + 1;
+ gdk_string_extents(cursor_font, text, &lb, &rb, &wid, &asc, &desc);
+ w = rb-lb; h = asc+desc; x = -lb; y = asc;
+ } else {
+ w = h = 1;
+ x = y = 0;
+ }
+
+ source = gdk_pixmap_new(NULL, w, h, 1);
+ mask = gdk_pixmap_new(NULL, w, h, 1);
+
+ /*
+ * Draw the mask character on the mask pixmap.
+ */
+ gc = gdk_gc_new(mask);
+ gdk_gc_set_foreground(gc, &dbg);
+ gdk_draw_rectangle(mask, gc, 1, 0, 0, w, h);
+ if (cursor_val >= 0) {
+ text[1] = '\0';
+ text[0] = (char)cursor_val + 1;
+ gdk_gc_set_foreground(gc, &dfg);
+ gdk_draw_text(mask, cursor_font, gc, x, y, text, 1);
+ }
+ gdk_gc_unref(gc);
+
+ /*
+ * Draw the main character on the source pixmap.
+ */
+ gc = gdk_gc_new(source);
+ gdk_gc_set_foreground(gc, &dbg);
+ gdk_draw_rectangle(source, gc, 1, 0, 0, w, h);
+ if (cursor_val >= 0) {
+ text[1] = '\0';
+ text[0] = (char)cursor_val;
+ gdk_gc_set_foreground(gc, &dfg);
+ gdk_draw_text(source, cursor_font, gc, x, y, text, 1);
+ }
+ gdk_gc_unref(gc);
+
+ /*
+ * Create the cursor.
+ */
+ ret = gdk_cursor_new_from_pixmap(source, mask, &cfg, &cbg, x, y);
+
+ /*
+ * Clean up.
+ */
+ gdk_pixmap_unref(source);
+ gdk_pixmap_unref(mask);
+
+ return ret;
+}
+
+void modalfatalbox(char *p, ...)
+{
+ va_list ap;
+ fprintf(stderr, "FATAL ERROR: ");
+ va_start(ap, p);
+ vfprintf(stderr, p, ap);
+ va_end(ap);
+ fputc('\n', stderr);
+ exit(1);
+}
+
+char *get_x_display(void *frontend)
+{
+ return gdk_get_display();
+}
+
+static void help(FILE *fp) {
+ if(fprintf(fp,
+"pterm option summary:\n"
+"\n"
+" --display DISPLAY Specify X display to use (note '--')\n"
+" -name PREFIX Prefix when looking up resources (default: pterm)\n"
+" -fn FONT Normal text font\n"
+" -fb FONT Bold text font\n"
+" -geometry WIDTHxHEIGHT Size of terminal in characters\n"
+" -sl LINES Number of lines of scrollback\n"
+" -fg COLOUR, -bg COLOUR Foreground/background colour\n"
+" -bfg COLOUR, -bbg COLOUR Foreground/background bold colour\n"
+" -cfg COLOUR, -bfg COLOUR Foreground/background cursor colour\n"
+" -T TITLE Window title\n"
+" -ut, +ut Do(default) or do not update utmp\n"
+" -ls, +ls Do(default) or do not make shell a login shell\n"
+" -sb, +sb Do(default) or do not display a scrollbar\n"
+" -log PATH Log all output to a file\n"
+" -nethack Map numeric keypad to hjklyubn direction keys\n"
+" -xrm RESOURCE-STRING Set an X resource\n"
+" -e COMMAND [ARGS...] Execute command (consumes all remaining args)\n"
+ ) < 0 || fflush(fp) < 0) {
+ perror("output error");
+ exit(1);
+ }
+}
+
+int do_cmdline(int argc, char **argv, int do_everything)
+{
+ int err = 0;
+ extern char **pty_argv; /* declared in pty.c */
+
+ /*
+ * Macros to make argument handling easier. Note that because
+ * they need to call `continue', they cannot be contained in
+ * the usual do {...} while (0) wrapper to make them
+ * syntactically single statements; hence it is not legal to
+ * use one of these macros as an unbraced statement between
+ * `if' and `else'.
+ */
+#define EXPECTS_ARG { \
+ if (--argc <= 0) { \
+ err = 1; \
+ fprintf(stderr, "pterm: %s expects an argument\n", p); \
+ continue; \
+ } else \
+ val = *++argv; \
+}
+#define SECOND_PASS_ONLY { if (!do_everything) continue; }
+
+ /*
+ * TODO:
+ *
+ * finish -geometry
+ */
+
+ char *val;
+ while (--argc > 0) {
+ char *p = *++argv;
+ if (!strcmp(p, "-fn") || !strcmp(p, "-font")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg.font, val, sizeof(cfg.font));
+ cfg.font[sizeof(cfg.font)-1] = '\0';
+
+ } else if (!strcmp(p, "-fb")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg.boldfont, val, sizeof(cfg.boldfont));
+ cfg.boldfont[sizeof(cfg.boldfont)-1] = '\0';
+
+ } else if (!strcmp(p, "-cs")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg.line_codepage, val, sizeof(cfg.line_codepage));
+ cfg.line_codepage[sizeof(cfg.line_codepage)-1] = '\0';
+
+ } else if (!strcmp(p, "-geometry")) {
+ int flags, x, y, w, h;
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+
+ flags = XParseGeometry(val, &x, &y, &w, &h);
+ if (flags & WidthValue)
+ cfg.width = w;
+ if (flags & HeightValue)
+ cfg.height = h;
+
+ /*
+ * Apparently setting the initial window position is
+ * difficult in GTK 1.2. Not entirely sure why this
+ * should be. 2.0 has gtk_window_parse_geometry(),
+ * which would help... For the moment, though, I can't
+ * be bothered with this.
+ */
+
+ } else if (!strcmp(p, "-sl")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ cfg.savelines = atoi(val);
+
+ } else if (!strcmp(p, "-fg") || !strcmp(p, "-bg") ||
+ !strcmp(p, "-bfg") || !strcmp(p, "-bbg") ||
+ !strcmp(p, "-cfg") || !strcmp(p, "-cbg")) {
+ GdkColor col;
+
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ if (!gdk_color_parse(val, &col)) {
+ err = 1;
+ fprintf(stderr, "pterm: unable to parse colour \"%s\"\n", val);
+ } else {
+ int index;
+ index = (!strcmp(p, "-fg") ? 0 :
+ !strcmp(p, "-bg") ? 2 :
+ !strcmp(p, "-bfg") ? 1 :
+ !strcmp(p, "-bbg") ? 3 :
+ !strcmp(p, "-cfg") ? 4 :
+ !strcmp(p, "-cbg") ? 5 : -1);
+ assert(index != -1);
+ cfg.colours[index][0] = col.red / 256;
+ cfg.colours[index][1] = col.green / 256;
+ cfg.colours[index][2] = col.blue / 256;
+ }
+
+ } else if (!strcmp(p, "-e")) {
+ /* This option swallows all further arguments. */
+ if (!do_everything)
+ break;
+
+ if (--argc > 0) {
+ int i;
+ pty_argv = smalloc((argc+1) * sizeof(char *));
+ ++argv;
+ for (i = 0; i < argc; i++)
+ pty_argv[i] = argv[i];
+ pty_argv[argc] = NULL;
+ break; /* finished command-line processing */
+ } else
+ err = 1, fprintf(stderr, "pterm: -e expects an argument\n");
+
+ } else if (!strcmp(p, "-T")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg.wintitle, val, sizeof(cfg.wintitle));
+ cfg.wintitle[sizeof(cfg.wintitle)-1] = '\0';
+
+ } else if (!strcmp(p, "-log")) {
+ EXPECTS_ARG;
+ SECOND_PASS_ONLY;
+ strncpy(cfg.logfilename, val, sizeof(cfg.logfilename));
+ cfg.logfilename[sizeof(cfg.logfilename)-1] = '\0';
+ cfg.logtype = LGTYP_DEBUG;
+
+ } else if (!strcmp(p, "-ut-") || !strcmp(p, "+ut")) {
+ SECOND_PASS_ONLY;
+ cfg.stamp_utmp = 0;
+
+ } else if (!strcmp(p, "-ut")) {
+ SECOND_PASS_ONLY;
+ cfg.stamp_utmp = 1;
+
+ } else if (!strcmp(p, "-ls-") || !strcmp(p, "+ls")) {
+ SECOND_PASS_ONLY;
+ cfg.login_shell = 0;
+
+ } else if (!strcmp(p, "-ls")) {
+ SECOND_PASS_ONLY;
+ cfg.login_shell = 1;
+
+ } else if (!strcmp(p, "-nethack")) {
+ SECOND_PASS_ONLY;
+ cfg.nethack_keypad = 1;
+
+ } else if (!strcmp(p, "-sb-") || !strcmp(p, "+sb")) {
+ SECOND_PASS_ONLY;
+ cfg.scrollbar = 0;
+
+ } else if (!strcmp(p, "-sb")) {
+ SECOND_PASS_ONLY;
+ cfg.scrollbar = 0;
+
+ } else if (!strcmp(p, "-name")) {
+ EXPECTS_ARG;
+ app_name = val;
+
+ } else if (!strcmp(p, "-xrm")) {
+ EXPECTS_ARG;
+ provide_xrm_string(val);
+
+ } else if(!strcmp(p, "-help") || !strcmp(p, "--help")) {
+ help(stdout);
+ exit(0);
+
+ } else {
+ err = 1;
+ fprintf(stderr, "pterm: unrecognized option '%s'\n", p);
+ }
+ }
+
+ return err;
+}
+
+static void block_signal(int sig, int block_it) {
+ sigset_t ss;
+
+ sigemptyset(&ss);
+ sigaddset(&ss, sig);
+ if(sigprocmask(block_it ? SIG_BLOCK : SIG_UNBLOCK, &ss, 0) < 0) {
+ perror("sigprocmask");
+ exit(1);
+ }
+}
+
+static void set_font_info(struct gui_data *inst, int fontid)
+{
+ GdkFont *font = inst->fonts[fontid];
+ XFontStruct *xfs = GDK_FONT_XFONT(font);
+ Display *disp = GDK_FONT_XDISPLAY(font);
+ Atom charset_registry, charset_encoding;
+ unsigned long registry_ret, encoding_ret;
+ charset_registry = XInternAtom(disp, "CHARSET_REGISTRY", False);
+ charset_encoding = XInternAtom(disp, "CHARSET_ENCODING", False);
+ inst->fontinfo[fontid].charset = CS_NONE;
+ inst->fontinfo[fontid].is_wide = 0;
+ if (XGetFontProperty(xfs, charset_registry, ®istry_ret) &&
+ XGetFontProperty(xfs, charset_encoding, &encoding_ret)) {
+ char *reg, *enc;
+ reg = XGetAtomName(disp, (Atom)registry_ret);
+ enc = XGetAtomName(disp, (Atom)encoding_ret);
+ if (reg && enc) {
+ char *encoding = dupcat(reg, "-", enc, NULL);
+ inst->fontinfo[fontid].charset = charset_from_xenc(encoding);
+ /* FIXME: when libcharset supports wide encodings fix this. */
+ if (!strcasecmp(encoding, "iso10646-1"))
+ inst->fontinfo[fontid].is_wide = 1;
+
+ /*
+ * Hack for X line-drawing characters: if the primary
+ * font is encoded as ISO-8859-anything, and has valid
+ * glyphs in the first 32 char positions, it is assumed
+ * that those glyphs are the VT100 line-drawing
+ * character set.
+ *
+ * Actually, we'll hack even harder by only checking
+ * position 0x19 (vertical line, VT100 linedrawing
+ * `x'). Then we can check it easily by seeing if the
+ * ascent and descent differ.
+ */
+ if (inst->fontinfo[fontid].charset == CS_ISO8859_1) {
+ int lb, rb, wid, asc, desc;
+ gchar text[2];
+
+ text[1] = '\0';
+ text[0] = '\x12';
+ gdk_string_extents(inst->fonts[fontid], text,
+ &lb, &rb, &wid, &asc, &desc);
+ if (asc != desc)
+ inst->fontinfo[fontid].charset = CS_ISO8859_1_X11;
+ }
+
+ /*
+ * FIXME: this is a hack. Currently fonts with
+ * incomprehensible encodings are dealt with by
+ * pretending they're 8859-1. It's ugly, but it's good
+ * enough to stop things crashing. Should do something
+ * better here.
+ */
+ if (inst->fontinfo[fontid].charset == CS_NONE)
+ inst->fontinfo[fontid].charset = CS_ISO8859_1;
+
+ sfree(encoding);
+ }
+ }
+}
+
+int main(int argc, char **argv)
+{
+ extern int pty_master_fd; /* declared in pty.c */
+ extern void pty_pre_init(void); /* declared in pty.c */
+ struct gui_data *inst;
+
+ /* defer any child exit handling until we're ready to deal with
+ * it */
+ block_signal(SIGCHLD, 1);
+
+ pty_pre_init();
+
+ gtk_init(&argc, &argv);
+
+ if (do_cmdline(argc, argv, 0)) /* pre-defaults pass to get -class */
+ exit(1);
+ do_defaults(NULL, &cfg);
+ if (do_cmdline(argc, argv, 1)) /* post-defaults, do everything */
+ exit(1);
+
+ /*
+ * Create an instance structure and initialise to zeroes
+ */
+ inst = smalloc(sizeof(*inst));
+ memset(inst, 0, sizeof(*inst));
+ inst->alt_keycode = -1; /* this one needs _not_ to be zero */
+
+ inst->fonts[0] = gdk_font_load(cfg.font);
+ if (!inst->fonts[0]) {
+ fprintf(stderr, "pterm: unable to load font \"%s\"\n", cfg.font);
+ exit(1);
+ }
+ set_font_info(inst, 0);
+ if (cfg.boldfont[0]) {
+ inst->fonts[1] = gdk_font_load(cfg.boldfont);
+ if (!inst->fonts[1]) {
+ fprintf(stderr, "pterm: unable to load bold font \"%s\"\n",
+ cfg.boldfont);
+ exit(1);
+ }
+ set_font_info(inst, 1);
+ } else
+ inst->fonts[1] = NULL;
+
+ inst->font_width = gdk_char_width(inst->fonts[0], ' ');
+ inst->font_height = inst->fonts[0]->ascent + inst->fonts[0]->descent;
+
+ inst->compound_text_atom = gdk_atom_intern("COMPOUND_TEXT", FALSE);
+ inst->utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE);
+
+ init_ucs();
+
+ inst->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+
+ if (cfg.wintitle[0])
+ set_title(inst, cfg.wintitle);
+ else
+ set_title(inst, "pterm");
+
+ /*
+ * Set up the colour map.
+ */
+ palette_reset(inst);
+
+ inst->area = gtk_drawing_area_new();
+ gtk_drawing_area_size(GTK_DRAWING_AREA(inst->area),
+ inst->font_width * cfg.width + 2*cfg.window_border,
+ inst->font_height * cfg.height + 2*cfg.window_border);
+ if (cfg.scrollbar) {
+ inst->sbar_adjust = GTK_ADJUSTMENT(gtk_adjustment_new(0,0,0,0,0,0));
+ inst->sbar = gtk_vscrollbar_new(inst->sbar_adjust);
+ }
+ inst->hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
+ if (cfg.scrollbar) {
+ if (cfg.scrollbar_on_left)
+ gtk_box_pack_start(inst->hbox, inst->sbar, FALSE, FALSE, 0);
+ else
+ gtk_box_pack_end(inst->hbox, inst->sbar, FALSE, FALSE, 0);
+ }
+ gtk_box_pack_start(inst->hbox, inst->area, TRUE, TRUE, 0);
+
+ gtk_container_add(GTK_CONTAINER(inst->window), GTK_WIDGET(inst->hbox));
+
+ {
+ GdkGeometry geom;
+ geom.min_width = inst->font_width + 2*cfg.window_border;
+ geom.min_height = inst->font_height + 2*cfg.window_border;
+ geom.max_width = geom.max_height = -1;
+ geom.base_width = 2*cfg.window_border;
+ geom.base_height = 2*cfg.window_border;
+ geom.width_inc = inst->font_width;
+ geom.height_inc = inst->font_height;
+ geom.min_aspect = geom.max_aspect = 0;
+ gtk_window_set_geometry_hints(GTK_WINDOW(inst->window), inst->area, &geom,
+ GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE |
+ GDK_HINT_RESIZE_INC);
+ }
+
+ gtk_signal_connect(GTK_OBJECT(inst->window), "destroy",
+ GTK_SIGNAL_FUNC(destroy), inst);
+ gtk_signal_connect(GTK_OBJECT(inst->window), "delete_event",
+ GTK_SIGNAL_FUNC(delete_window), inst);
+ gtk_signal_connect(GTK_OBJECT(inst->window), "key_press_event",
+ GTK_SIGNAL_FUNC(key_event), inst);
+ gtk_signal_connect(GTK_OBJECT(inst->window), "key_release_event",
+ GTK_SIGNAL_FUNC(key_event), inst);
+ gtk_signal_connect(GTK_OBJECT(inst->window), "focus_in_event",
+ GTK_SIGNAL_FUNC(focus_event), inst);
+ gtk_signal_connect(GTK_OBJECT(inst->window), "focus_out_event",