X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/60b55c0769f32d0d514db84021ab441380460933..4dc4f9c452e22fd4e424eaf3e5f44d5b659b6abc:/unix/pterm.c diff --git a/unix/pterm.c b/unix/pterm.c index 9258b613..6406c925 100644 --- a/unix/pterm.c +++ b/unix/pterm.c @@ -38,8 +38,12 @@ struct gui_data { int pasteout_data_len; int font_width, font_height; int ignore_sbar; + int mouseptr_visible; + guint term_paste_idle_id; GdkAtom compound_text_atom; + int alt_keycode; char wintitle[sizeof(((Config *)0)->wintitle)]; + char icontitle[sizeof(((Config *)0)->wintitle)]; }; static struct gui_data the_inst; @@ -76,6 +80,14 @@ void logevent(char *string) */ } +int font_dimension(int which) /* 0 for width, 1 for height */ +{ + if (which) + return inst->font_height; + else + return inst->font_width; +} + /* * Translate a raw mouse button designation (LEFT, MIDDLE, RIGHT) * into a cooked one (SELECT, EXTEND, PASTE). @@ -102,7 +114,15 @@ Mouse_Button translate_button(Mouse_Button button) */ void set_iconic(int iconic) { - /* FIXME: currently ignored */ + /* + * GTK 1.2 doesn't know how to do this. + */ +#if GTK_CHECK_VERSION(2,0,0) + if (iconic) + gtk_window_iconify(GTK_WINDOW(inst->window)); + else + gtk_window_deiconify(GTK_WINDOW(inst->window)); +#endif } /* @@ -110,7 +130,16 @@ void set_iconic(int iconic) */ void move_window(int x, int y) { - /* FIXME: currently ignored */ + /* + * I assume that when the GTK version of this call is available + * we should use it. Not sure how it differs from the GDK one, + * though. + */ +#if GTK_CHECK_VERSION(2,0,0) + gtk_window_move(GTK_WINDOW(inst->window), x, y); +#else + gdk_window_move(inst->window->window, x, y); +#endif } /* @@ -119,7 +148,10 @@ void move_window(int x, int y) */ void set_zorder(int top) { - /* FIXME: currently ignored */ + if (top) + gdk_window_raise(inst->window->window); + else + gdk_window_lower(inst->window->window); } /* @@ -127,7 +159,7 @@ void set_zorder(int top) */ void refresh_window(void) { - /* FIXME: currently ignored */ + term_invalidate(); } /* @@ -136,7 +168,15 @@ void refresh_window(void) */ void set_zoomed(int zoomed) { - /* FIXME: currently ignored */ + /* + * GTK 1.2 doesn't know how to do this. + */ +#if GTK_CHECK_VERSION(2,0,0) + if (iconic) + gtk_window_maximize(GTK_WINDOW(inst->window)); + else + gtk_window_unmaximize(GTK_WINDOW(inst->window)); +#endif } /* @@ -144,7 +184,7 @@ void set_zoomed(int zoomed) */ int is_iconic(void) { - return 0; /* FIXME */ + return !gdk_window_is_viewable(inst->window->window); } /* @@ -152,7 +192,16 @@ int is_iconic(void) */ void get_window_pos(int *x, int *y) { - *x = 3; *y = 4; /* FIXME */ + /* + * I assume that when the GTK version of this call is available + * we should use it. Not sure how it differs from the GDK one, + * though. + */ +#if GTK_CHECK_VERSION(2,0,0) + gtk_window_get_position(GTK_WINDOW(inst->window), x, y); +#else + gdk_window_get_position(inst->window->window, x, y); +#endif } /* @@ -160,7 +209,16 @@ void get_window_pos(int *x, int *y) */ void get_window_pixels(int *x, int *y) { - *x = 1; *y = 2; /* FIXME */ + /* + * I assume that when the GTK version of this call is available + * we should use it. Not sure how it differs from the GDK one, + * though. + */ +#if GTK_CHECK_VERSION(2,0,0) + gtk_window_get_size(GTK_WINDOW(inst->window), x, y); +#else + gdk_window_get_size(inst->window->window, x, y); +#endif } /* @@ -168,7 +226,7 @@ void get_window_pixels(int *x, int *y) */ char *get_window_title(int icon) { - return inst->wintitle; + return icon ? inst->wintitle : inst->icontitle; } gint delete_window(GtkWidget *widget, GdkEvent *event, gpointer data) @@ -188,6 +246,7 @@ void show_mouseptr(int show) gdk_window_set_cursor(inst->area->window, inst->currcursor); else gdk_window_set_cursor(inst->area->window, inst->blankcursor); + inst->mouseptr_visible = show; } gint configure_area(GtkWidget *widget, GdkEventConfigure *event, gpointer data) @@ -195,11 +254,6 @@ gint configure_area(GtkWidget *widget, GdkEventConfigure *event, gpointer data) struct gui_data *inst = (struct gui_data *)data; int w, h, need_size = 0; - /* - * Set up the colour map. - */ - palette_reset(); - w = (event->width - 2*cfg.window_border) / inst->font_width; h = (event->height - 2*cfg.window_border) / inst->font_height; @@ -264,6 +318,25 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data) char output[32]; int start, end; + /* By default, nothing is generated. */ + end = start = 0; + + /* + * If Alt is being released after typing an Alt+numberpad + * sequence, we should generate the code that was typed. + */ + if (event->type == GDK_KEY_RELEASE && + (event->keyval == GDK_Meta_L || event->keyval == GDK_Alt_L || + event->keyval == GDK_Meta_R || event->keyval == GDK_Alt_R) && + inst->alt_keycode >= 0) { +#ifdef KEY_DEBUGGING + printf("Alt key up, keycode = %d\n", inst->alt_keycode); +#endif + output[0] = inst->alt_keycode; + end = 1; + goto done; + } + if (event->type == GDK_KEY_PRESS) { #ifdef KEY_DEBUGGING { @@ -277,11 +350,58 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data) #endif /* - * NYI: - * - nethack mode - * - alt+numpad - * - Compose key (!!! requires Unicode faff before even trying) + * NYI: Compose key (!!! requires Unicode faff before even trying) + */ + + /* + * If Alt has just been pressed, we start potentially + * accumulating an Alt+numberpad code. We do this by + * setting alt_keycode to -1 (nothing yet but plausible). */ + if ((event->keyval == GDK_Meta_L || event->keyval == GDK_Alt_L || + event->keyval == GDK_Meta_R || event->keyval == GDK_Alt_R)) { + inst->alt_keycode = -1; + goto done; /* this generates nothing else */ + } + + /* + * If we're seeing a numberpad key press with Mod1 down, + * consider adding it to alt_keycode if that's sensible. + * Anything _else_ with Mod1 down cancels any possibility + * of an ALT keycode: we set alt_keycode to -2. + */ + if ((event->state & GDK_MOD1_MASK) && inst->alt_keycode != -2) { + int digit = -1; + switch (event->keyval) { + case GDK_KP_0: case GDK_KP_Insert: digit = 0; break; + case GDK_KP_1: case GDK_KP_End: digit = 1; break; + case GDK_KP_2: case GDK_KP_Down: digit = 2; break; + case GDK_KP_3: case GDK_KP_Page_Down: digit = 3; break; + case GDK_KP_4: case GDK_KP_Left: digit = 4; break; + case GDK_KP_5: case GDK_KP_Begin: digit = 5; break; + case GDK_KP_6: case GDK_KP_Right: digit = 6; break; + case GDK_KP_7: case GDK_KP_Home: digit = 7; break; + case GDK_KP_8: case GDK_KP_Up: digit = 8; break; + case GDK_KP_9: case GDK_KP_Page_Up: digit = 9; break; + } + if (digit < 0) + inst->alt_keycode = -2; /* it's invalid */ + else { +#ifdef KEY_DEBUGGING + printf("Adding digit %d to keycode %d", digit, + inst->alt_keycode); +#endif + if (inst->alt_keycode == -1) + inst->alt_keycode = digit; /* one-digit code */ + else + inst->alt_keycode = inst->alt_keycode * 10 + digit; +#ifdef KEY_DEBUGGING + printf(" gives new code %d\n", inst->alt_keycode); +#endif + /* Having used this digit, we now do nothing more with it. */ + goto done; + } + } /* * Shift-PgUp and Shift-PgDn don't even generate keystrokes @@ -641,23 +761,23 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data) goto done; } } + goto done; + } - done: + done: + if (end-start > 0) { #ifdef KEY_DEBUGGING - { - int i; - printf("generating sequence:"); - for (i = start; i < end; i++) - printf(" %02x", (unsigned char) output[i]); - printf("\n"); - } + int i; + printf("generating sequence:"); + for (i = start; i < end; i++) + printf(" %02x", (unsigned char) output[i]); + printf("\n"); #endif - if (end-start > 0) { - ldisc_send(output+start, end-start, 1); - show_mouseptr(0); - term_out(); - } + + ldisc_send(output+start, end-start, 1); + show_mouseptr(0); + term_out(); } return TRUE; @@ -670,6 +790,15 @@ gint button_event(GtkWidget *widget, GdkEventButton *event, gpointer data) show_mouseptr(1); + if (event->button == 4 && event->type == GDK_BUTTON_PRESS) { + term_scroll(0, -5); + return TRUE; + } + if (event->button == 5 && event->type == GDK_BUTTON_PRESS) { + term_scroll(0, +5); + return TRUE; + } + shift = event->state & GDK_SHIFT_MASK; ctrl = event->state & GDK_CONTROL_MASK; alt = event->state & GDK_MOD1_MASK; @@ -747,13 +876,7 @@ gint timer_func(gpointer data) } term_update(); - return TRUE; -} - -gint idle_func(gpointer data) -{ - /* struct gui_data *inst = (struct gui_data *)data; */ - term_paste(); + term_blink(0); return TRUE; } @@ -780,6 +903,7 @@ void pty_input_func(gpointer data, gint sourcefd, GdkInputCondition condition) } if (ret > 0) from_backend(0, buf, ret); + term_blink(1); term_out(); } @@ -808,12 +932,73 @@ void set_raw_mouse_mode(int activate) inst->currcursor = inst->rawcursor; else inst->currcursor = inst->textcursor; - show_mouseptr(1); + show_mouseptr(inst->mouseptr_visible); } void request_resize(int w, int h) { - /* FIXME: currently ignored */ + int large_x, large_y; + int offset_x, offset_y; + int area_x, area_y; + GtkRequisition inner, outer; + + /* + * This is a heinous hack dreamed up by the gnome-terminal + * people to get around a limitation in gtk. The problem is + * that in order to set the size correctly we really need to be + * calling gtk_window_resize - but that needs to know the size + * of the _whole window_, not the drawing area. So what we do + * is to set an artificially huge size request on the drawing + * area, recompute the resulting size request on the window, + * and look at the difference between the two. That gives us + * the x and y offsets we need to translate drawing area size + * into window size for real, and then we call + * gtk_window_resize. + */ + + /* + * We start by retrieving the current size of the whole window. + * Adding a bit to _that_ will give us a value we can use as a + * bogus size request which guarantees to be bigger than the + * current size of the drawing area. + */ + get_window_pixels(&large_x, &large_y); + large_x += 32; + large_y += 32; + +#if GTK_CHECK_VERSION(2,0,0) + gtk_widget_set_size_request(inst->area, large_x, large_y); +#else + gtk_widget_set_usize(inst->area, large_x, large_y); +#endif + gtk_widget_size_request(inst->area, &inner); + gtk_widget_size_request(inst->window, &outer); + + offset_x = outer.width - inner.width; + offset_y = outer.height - inner.height; + + area_x = inst->font_width * w + 2*cfg.window_border; + area_y = inst->font_height * h + 2*cfg.window_border; + + /* + * Now we must set the size request on the drawing area back to + * something sensible before we commit the real resize. Best + * way to do this, I think, is to set it to what the size is + * really going to end up being. + */ +#if GTK_CHECK_VERSION(2,0,0) + gtk_widget_set_size_request(inst->area, area_x, area_y); +#else + gtk_widget_set_usize(inst->area, area_x, area_y); +#endif + +#if GTK_CHECK_VERSION(2,0,0) + gtk_window_resize(GTK_WINDOW(inst->window), + area_x + offset_x, area_y + offset_y); +#else + gdk_window_resize(inst->window->window, + area_x + offset_x, area_y + offset_y); +#endif } void real_palette_set(int n, int r, int g, int b) @@ -924,6 +1109,8 @@ void request_paste(void) GDK_SELECTION_TYPE_STRING, GDK_CURRENT_TIME); } +gint idle_paste_func(gpointer data); /* forward ref */ + void selection_received(GtkWidget *widget, GtkSelectionData *seldata, gpointer data) { @@ -940,8 +1127,24 @@ void selection_received(GtkWidget *widget, GtkSelectionData *seldata, inst->pastein_data, inst->pastein_data_len); term_do_paste(); + + if (term_paste_pending()) + 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()) + term_paste(); + else + gtk_idle_remove(inst->term_paste_idle_id); + + return TRUE; } + void get_clip(wchar_t ** p, int *len) { if (p) { @@ -959,11 +1162,15 @@ void set_title(char *title) void set_icon(char *title) { - /* FIXME: currently ignored */ + 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(int total, int start, int page) { + if (!cfg.scrollbar) + return; inst->sbar_adjust->lower = 0; inst->sbar_adjust->upper = total; inst->sbar_adjust->value = start; @@ -977,6 +1184,8 @@ void set_sbar(int total, int start, int page) void scrollbar_moved(GtkAdjustment *adj, gpointer data) { + if (!cfg.scrollbar) + return; if (!inst->ignore_sbar) term_scroll(1, (int)adj->value); } @@ -1033,7 +1242,6 @@ void do_text(Context ctx, int x, int y, char *text, int len, /* * NYI: * - Unicode, code pages, and ATTR_WIDE for CJK support. - * - LATTR_* (ESC # 4 double-width and double-height stuff) * - cursor shapes other than block * - shadow bolding */ @@ -1054,6 +1262,14 @@ void do_text(Context ctx, int x, int y, char *text, int len, nbg = NCOLOURS-1; } + if (lattr != LATTR_NORM) { + x *= 2; + if (x >= cols) + return; + if (x + len*2 > cols) + len = (cols-x)/2; /* trim to LH half */ + } + gdk_gc_set_foreground(gc, &inst->cols[nbg]); gdk_draw_rectangle(inst->pixmap, gc, 1, x*inst->font_width+cfg.window_border, @@ -1076,6 +1292,44 @@ void do_text(Context ctx, int x, int y, char *text, int len, 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); + } + } + 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, @@ -1217,6 +1471,11 @@ void modalfatalbox(char *p, ...) exit(1); } +char *get_x_display(void) +{ + return gdk_get_display(); +} + int main(int argc, char **argv) { extern int pty_master_fd; /* declared in pty.c */ @@ -1266,9 +1525,18 @@ int main(int argc, char **argv) if (!strcmp(p, "-hide")) { cfg.hide_mouseptr = 1; } + if (!strcmp(p, "-ut-")) { + cfg.stamp_utmp = 0; + } + if (!strcmp(p, "-ls-")) { + cfg.login_shell = 0; + } if (!strcmp(p, "-nethack")) { cfg.nethack_keypad = 1; } + if (!strcmp(p, "-sb-")) { + cfg.scrollbar = 0; + } } inst->fonts[0] = gdk_font_load(cfg.font); @@ -1280,9 +1548,6 @@ int main(int argc, char **argv) init_ucs(); - back = &pty_backend; - back->init(NULL, 0, NULL, 0); - inst->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (cfg.wintitle[0]) @@ -1290,15 +1555,27 @@ int main(int argc, char **argv) else set_title("pterm"); + /* + * Set up the colour map. + */ + palette_reset(); + 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); - inst->sbar_adjust = GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 0, 0, 0, 0)); - inst->sbar = gtk_vscrollbar_new(inst->sbar_adjust); + 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_box_pack_end(inst->hbox, inst->sbar, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(inst->window), GTK_WIDGET(inst->hbox)); @@ -1323,6 +1600,8 @@ int main(int argc, char **argv) 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", @@ -1343,18 +1622,18 @@ int main(int argc, char **argv) GTK_SIGNAL_FUNC(selection_get), inst); gtk_signal_connect(GTK_OBJECT(inst->area), "selection_clear_event", GTK_SIGNAL_FUNC(selection_clear), inst); - gtk_signal_connect(GTK_OBJECT(inst->sbar_adjust), "value_changed", - GTK_SIGNAL_FUNC(scrollbar_moved), inst); - gtk_idle_add(idle_func, inst); + if (cfg.scrollbar) + gtk_signal_connect(GTK_OBJECT(inst->sbar_adjust), "value_changed", + GTK_SIGNAL_FUNC(scrollbar_moved), inst); gtk_timeout_add(20, timer_func, inst); - gdk_input_add(pty_master_fd, GDK_INPUT_READ, pty_input_func, inst); gtk_widget_add_events(GTK_WIDGET(inst->area), GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK); gtk_widget_show(inst->area); - gtk_widget_show(inst->sbar); + if (cfg.scrollbar) + gtk_widget_show(inst->sbar); gtk_widget_show(GTK_WIDGET(inst->hbox)); gtk_widget_show(inst->window); @@ -1365,8 +1644,13 @@ int main(int argc, char **argv) inst->currcursor = inst->textcursor; show_mouseptr(1); + back = &pty_backend; + back->init(NULL, 0, NULL, 0); + + gdk_input_add(pty_master_fd, GDK_INPUT_READ, pty_input_func, inst); + term_init(); - term_size(24, 80, 2000); + term_size(cfg.height, cfg.width, cfg.savelines); gtk_main();