nyje
/
medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
medit/moo/mooterm/mooterm.c

1436 lines
44 KiB
C
Raw Blame History

/*
* mooterm/mooterm.c
*
* Copyright (C) 2004-2005 by Yevgen Muntyan <muntyan@math.tamu.edu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* See COPYING file that comes with this distribution.
*/
#define MOOTERM_COMPILATION
#include "mooterm/mooterm-private.h"
#include "mooterm/mootermparser.h"
#include "mooterm/mootermpt.h"
#include "mooterm/mootermbuffer-private.h"
#include "mooutils/moocompat.h"
#include "mooutils/moomarshals.h"
static void moo_term_finalize (GObject *object);
static void moo_term_realize (GtkWidget *widget);
static void moo_term_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static gboolean moo_term_popup_menu (GtkWidget *widget);
static gboolean moo_term_scroll (GtkWidget *widget,
GdkEventScroll *event);
static void moo_term_set_scroll_adjustments (GtkWidget *widget,
GtkAdjustment *hadj,
GtkAdjustment *vadj);
static void update_adjustment (MooTerm *term);
static void update_adjustment_value (MooTerm *term);
static void adjustment_value_changed (MooTerm *term);
static void queue_adjustment_changed (MooTerm *term,
gboolean now);
static void queue_adjustment_value_changed (MooTerm *term,
gboolean now);
static gboolean emit_adjustment_changed (MooTerm *term);
static gboolean emit_adjustment_value_changed (MooTerm *term);
static void scroll_abs (MooTerm *term,
guint line,
gboolean update_adj);
static void scroll_to_bottom (MooTerm *term,
gboolean update_adj);
static void scrollback_changed (MooTerm *term,
GParamSpec *pspec,
MooTermBuffer *buf);
static void width_changed (MooTerm *term,
GParamSpec *pspec);
static void height_changed (MooTerm *term,
GParamSpec *pspec);
static void im_preedit_start (MooTerm *term);
static void im_preedit_end (MooTerm *term);
static void child_died (MooTerm *term);
enum {
SET_SCROLL_ADJUSTMENTS,
SET_WINDOW_TITLE,
SET_ICON_NAME,
BELL,
CHILD_DIED,
POPULATE_POPUP,
LAST_SIGNAL
};
enum {
PROP_0 = 0,
LAST_PROP
};
/* MOO_TYPE_TERM */
G_DEFINE_TYPE (MooTerm, moo_term, GTK_TYPE_WIDGET)
static guint signals[LAST_SIGNAL];
static void moo_term_class_init (MooTermClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
gobject_class->finalize = moo_term_finalize;
widget_class->realize = moo_term_realize;
widget_class->size_allocate = moo_term_size_allocate;
widget_class->expose_event = moo_term_expose_event;
widget_class->key_press_event = moo_term_key_press;
widget_class->key_release_event = moo_term_key_release;
widget_class->popup_menu = moo_term_popup_menu;
widget_class->scroll_event = moo_term_scroll;
widget_class->button_press_event = moo_term_button_press;
widget_class->button_release_event = moo_term_button_release;
widget_class->motion_notify_event = moo_term_motion_notify;
klass->set_scroll_adjustments = moo_term_set_scroll_adjustments;
signals[SET_SCROLL_ADJUSTMENTS] =
g_signal_new ("set-scroll-adjustments",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MooTermClass, set_scroll_adjustments),
NULL, NULL,
_moo_marshal_VOID__OBJECT_OBJECT,
G_TYPE_NONE, 2,
GTK_TYPE_ADJUSTMENT,
GTK_TYPE_ADJUSTMENT);
widget_class->set_scroll_adjustments_signal = signals[SET_SCROLL_ADJUSTMENTS];
signals[SET_WINDOW_TITLE] =
g_signal_new ("set-window-title",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MooTermClass, set_window_title),
NULL, NULL,
_moo_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
signals[SET_ICON_NAME] =
g_signal_new ("set-icon-name",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MooTermClass, set_icon_name),
NULL, NULL,
_moo_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
signals[BELL] =
g_signal_new ("bell",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MooTermClass, bell),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[CHILD_DIED] =
g_signal_new ("child-died",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MooTermClass, child_died),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[POPULATE_POPUP] =
g_signal_new ("populate-popup",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MooTermClass, populate_popup),
NULL, NULL,
_moo_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GTK_TYPE_MENU);
}
static void moo_term_init (MooTerm *term)
{
term->priv = g_new0 (MooTermPrivate, 1);
term->priv->pt = moo_term_pt_new (term);
g_signal_connect_swapped (term->priv->pt, "child-died",
G_CALLBACK (child_died), term);
term->priv->parser = moo_term_parser_new (term);
term->priv->primary_buffer = moo_term_buffer_new (80, 24);
term->priv->alternate_buffer = moo_term_buffer_new (80, 24);
term->priv->buffer = term->priv->primary_buffer;
term->priv->saved_cursor = g_array_new (FALSE, FALSE, sizeof(guint));
term->priv->width = 80;
term->priv->height = 24;
term->priv->selection = term_selection_new ();
term->priv->cursor_visible = TRUE;
term->priv->settings.hide_pointer_on_keypress = TRUE;
term->priv->settings.meta_sends_escape = TRUE;
term->priv->settings.scroll_on_keystroke = TRUE;
term->priv->settings.backspace_binding = MOO_TERM_ERASE_AUTO;
term->priv->settings.delete_binding = MOO_TERM_ERASE_AUTO;
term->priv->pointer_visible = TRUE;
set_default_modes (term->priv->modes);
set_default_modes (term->priv->saved_modes);
g_signal_connect_swapped (term->priv->primary_buffer,
"notify::scrollback",
G_CALLBACK (scrollback_changed),
term);
g_signal_connect_swapped (term->priv->alternate_buffer,
"notify::scrollback",
G_CALLBACK (scrollback_changed),
term);
g_signal_connect_swapped (term->priv->buffer,
"notify::screen-width",
G_CALLBACK (width_changed),
term);
g_signal_connect_swapped (term->priv->buffer,
"notify::screen-height",
G_CALLBACK (height_changed),
term);
g_signal_connect_swapped (term->priv->primary_buffer,
"changed",
G_CALLBACK (moo_term_buf_content_changed),
term);
g_signal_connect_swapped (term->priv->alternate_buffer,
"changed",
G_CALLBACK (moo_term_buf_content_changed),
term);
g_signal_connect_swapped (term->priv->primary_buffer,
"cursor-moved",
G_CALLBACK (moo_term_cursor_moved),
term);
g_signal_connect_swapped (term->priv->alternate_buffer,
"cursor-moved",
G_CALLBACK (moo_term_cursor_moved),
term);
g_signal_connect_swapped (term->priv->primary_buffer,
"feed-child",
G_CALLBACK (moo_term_feed_child),
term);
g_signal_connect_swapped (term->priv->alternate_buffer,
"feed-child",
G_CALLBACK (moo_term_feed_child),
term);
}
static void moo_term_finalize (GObject *object)
{
guint i, j;
MooTerm *term = MOO_TERM (object);
g_object_unref (term->priv->pt);
moo_term_parser_free (term->priv->parser);
g_object_unref (term->priv->primary_buffer);
g_object_unref (term->priv->alternate_buffer);
term_selection_free (term->priv->selection);
term_font_info_free (term->priv->font_info);
g_array_free (term->priv->saved_cursor, TRUE);
g_object_unref (term->priv->back_pixmap);
if (term->priv->changed_content)
gdk_region_destroy (term->priv->changed_content);
if (term->priv->pending_expose)
g_source_remove (term->priv->pending_expose);
g_object_unref (term->priv->clip);
g_object_unref (term->priv->layout);
g_object_unref (term->priv->im);
if (term->priv->adjustment)
g_object_unref (term->priv->adjustment);
for (i = 0; i < POINTERS_NUM; ++i)
if (term->priv->pointer[i])
gdk_cursor_unref (term->priv->pointer[i]);
/* TODO TODO TODO */
for (i = 0; i < 1; ++i)
for (j = 0; j <= MOO_TERM_COLOR_MAX; ++j)
{
g_object_unref (term->priv->fg[i][j]);
g_object_unref (term->priv->bg[i][j]);
}
g_object_unref (term->priv->fg[1][MOO_TERM_COLOR_MAX]);
g_object_unref (term->priv->bg[1][MOO_TERM_COLOR_MAX]);
g_object_unref (term->priv->fg[2][MOO_TERM_COLOR_MAX]);
g_object_unref (term->priv->bg[2][MOO_TERM_COLOR_MAX]);
g_free (term->priv);
G_OBJECT_CLASS (moo_term_parent_class)->finalize (object);
}
static void moo_term_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
int old_width, old_height;
MooTerm *term = MOO_TERM (widget);
old_width = widget->allocation.width;
old_height = widget->allocation.height;
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);
if (old_width != allocation->width || old_height != allocation->height)
moo_term_size_changed (term);
}
}
static void moo_term_realize (GtkWidget *widget)
{
MooTerm *term;
GdkWindowAttr attributes;
gint attributes_mask;
GdkDisplay *display;
GdkBitmap *empty_bitmap;
GdkColor useless = {0, 0, 0, 0};
char invisible_cursor_bits[] = { 0x0 };
term = MOO_TERM (widget);
empty_bitmap = gdk_bitmap_create_from_data (NULL, invisible_cursor_bits, 1, 1);
term->priv->pointer[POINTER_NONE] =
gdk_cursor_new_from_pixmap (empty_bitmap,
empty_bitmap,
&useless,
&useless, 0, 0);
display = gtk_widget_get_display (widget);
term->priv->pointer[POINTER_TEXT] =
gdk_cursor_new_for_display (display, GDK_XTERM);
term->priv->pointer[POINTER_NORMAL] = NULL;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.cursor = term->priv->pointer[POINTER_TEXT];
attributes.event_mask = gtk_widget_get_events (widget) |
GDK_EXPOSURE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_POINTER_MOTION_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL |
GDK_WA_COLORMAP | GDK_WA_CURSOR;
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED | GTK_CAN_FOCUS | GTK_CAN_DEFAULT);
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (widget->window, widget);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_widget_set_double_buffered (widget, FALSE);
moo_term_setup_palette (term);
moo_term_init_font_stuff (term);
moo_term_init_back_pixmap (term);
moo_term_size_changed (term);
gdk_window_set_background (widget->window, &(widget->style->white));
term->priv->im = gtk_im_multicontext_new ();
gtk_im_context_set_client_window (term->priv->im, widget->window);
gtk_im_context_set_use_preedit (term->priv->im, FALSE);
g_signal_connect (term->priv->im, "commit",
G_CALLBACK (moo_term_im_commit), term);
g_signal_connect_swapped (term->priv->im, "preedit-start",
G_CALLBACK (im_preedit_start), term);
g_signal_connect_swapped (term->priv->im, "preedit-end",
G_CALLBACK (im_preedit_end), term);
gtk_im_context_focus_in (term->priv->im);
}
static void im_preedit_start (MooTerm *term)
{
term->priv->im_preedit_active = TRUE;
}
static void im_preedit_end (MooTerm *term)
{
term->priv->im_preedit_active = FALSE;
}
static void child_died (MooTerm *term)
{
g_signal_emit (term, signals[CHILD_DIED], 0);
}
static void moo_term_set_scroll_adjustments (GtkWidget *widget,
G_GNUC_UNUSED GtkAdjustment *hadj,
GtkAdjustment *vadj)
{
moo_term_set_adjustment (MOO_TERM (widget), vadj);
}
void moo_term_set_adjustment (MooTerm *term,
GtkAdjustment *vadj)
{
if (term->priv->adjustment == vadj)
return;
if (term->priv->adjustment)
{
g_signal_handlers_disconnect_by_func (term->priv->adjustment,
(gpointer) adjustment_value_changed,
term);
g_object_unref (term->priv->adjustment);
}
term->priv->adjustment = vadj;
if (term->priv->adjustment)
{
g_object_ref (term->priv->adjustment);
gtk_object_sink (GTK_OBJECT (term->priv->adjustment));
update_adjustment (term);
g_signal_connect_swapped (term->priv->adjustment,
"value-changed",
G_CALLBACK (adjustment_value_changed),
term);
}
}
static void scrollback_changed (MooTerm *term,
G_GNUC_UNUSED GParamSpec *pspec,
MooTermBuffer *buf)
{
g_assert (!strcmp (pspec->name, "scrollback"));
if (buf == term->priv->buffer)
{
guint scrollback = buf_scrollback (term->priv->buffer);
if (term->priv->_scrolled && term->priv->_top_line > scrollback)
scroll_to_bottom (term, TRUE);
else
update_adjustment (term);
}
}
static void width_changed (MooTerm *term,
G_GNUC_UNUSED GParamSpec *pspec)
{
g_assert (!strcmp (pspec->name, "screen-width"));
term->priv->width = buf_screen_width (term->priv->buffer);
if (GTK_WIDGET_REALIZED (term))
moo_term_resize_back_pixmap (term);
term_selection_set_width (term, term->priv->width);
term_selection_clear (term);
}
static void height_changed (MooTerm *term,
G_GNUC_UNUSED GParamSpec *pspec)
{
guint scrollback = buf_scrollback (term->priv->buffer);
g_assert (!strcmp (pspec->name, "screen-height"));
term->priv->height = buf_screen_height (term->priv->buffer);
if (!term->priv->_scrolled || term->priv->_top_line > scrollback)
scroll_to_bottom (term, TRUE);
else
update_adjustment (term);
if (GTK_WIDGET_REALIZED (term))
moo_term_resize_back_pixmap (term);
term_selection_clear (term);
moo_term_invalidate_all (term);
}
#define equal(a, b) (ABS((a)-(b)) < 0.4)
static void update_adjustment (MooTerm *term)
{
double upper, value, page_size;
GtkAdjustment *adj = term->priv->adjustment;
gboolean now = FALSE;
if (!adj)
return;
upper = buf_total_height (term->priv->buffer);
value = term_top_line (term);
page_size = term->priv->height;
if ((ABS (upper - term->priv->adjustment->upper) >
ADJUSTMENT_DELTA * page_size) ||
(ABS (value - term->priv->adjustment->value) >
ADJUSTMENT_DELTA * page_size))
{
now = TRUE;
}
if (!equal (adj->lower, 0.0) || !equal (adj->upper, upper) ||
!equal (adj->value, value) || !equal (adj->page_size, page_size) ||
!equal (adj->page_increment, page_size) || !equal (adj->step_increment, 1.0))
{
adj->lower = 0.0;
adj->upper = upper;
adj->value = value;
adj->page_size = page_size;
adj->page_increment = page_size;
adj->step_increment = 1.0;
queue_adjustment_changed (term, now);
}
}
static void update_adjustment_value (MooTerm *term)
{
double value = term_top_line (term);
gboolean now = FALSE;
if (!term->priv->adjustment)
return;
if (ABS (value - term->priv->adjustment->value) >
ADJUSTMENT_DELTA * term->priv->height)
{
now = TRUE;
}
if (!equal (term->priv->adjustment->value, value))
{
term->priv->adjustment->value = value;
queue_adjustment_value_changed (term, now);
}
}
static void adjustment_value_changed (MooTerm *term)
{
guint val, real_val;
g_assert (term->priv->adjustment != NULL);
val = term->priv->adjustment->value;
real_val = term_top_line (term);
if (val == real_val)
return;
g_return_if_fail (val <= buf_scrollback (term->priv->buffer));
scroll_abs (term, val, FALSE);
}
static void queue_adjustment_changed (MooTerm *term,
gboolean now)
{
if (now)
{
if (term->priv->pending_adjustment_changed)
g_source_remove (term->priv->pending_adjustment_changed);
term->priv->pending_adjustment_changed = 0;
emit_adjustment_changed (term);
}
else if (!term->priv->pending_adjustment_changed)
{
term->priv->pending_adjustment_changed =
g_idle_add_full (ADJUSTMENT_PRIORITY,
(GSourceFunc) emit_adjustment_changed,
term,
NULL);
}
}
static void queue_adjustment_value_changed (MooTerm *term,
gboolean now)
{
if (now)
{
if (term->priv->pending_adjustment_value_changed)
g_source_remove (term->priv->pending_adjustment_value_changed);
term->priv->pending_adjustment_value_changed = 0;
emit_adjustment_value_changed (term);
}
else if (!term->priv->pending_adjustment_value_changed)
{
term->priv->pending_adjustment_value_changed =
g_idle_add_full(ADJUSTMENT_PRIORITY,
(GSourceFunc) emit_adjustment_value_changed,
term,
NULL);
}
}
static gboolean emit_adjustment_changed (MooTerm *term)
{
term->priv->pending_adjustment_changed = 0;
gtk_adjustment_changed (term->priv->adjustment);
return FALSE;
}
static gboolean emit_adjustment_value_changed (MooTerm *term)
{
term->priv->pending_adjustment_value_changed = 0;
gtk_adjustment_value_changed (term->priv->adjustment);
return FALSE;
}
static void scroll_abs (MooTerm *term,
guint line,
gboolean update_adj)
{
if (term_top_line (term) == line)
{
if (update_adj)
update_adjustment_value (term);
return;
}
if (line >= buf_scrollback (term->priv->buffer))
return scroll_to_bottom (term, update_adj);
term->priv->_top_line = line;
term->priv->_scrolled = TRUE;
moo_term_invalidate_content_all (term);
moo_term_invalidate_all (term);
if (update_adj)
update_adjustment_value (term);
}
static void scroll_to_bottom (MooTerm *term,
gboolean update_adj)
{
guint scrollback = buf_scrollback (term->priv->buffer);
gboolean update_full = FALSE;
if (!term->priv->_scrolled && term->priv->_top_line <= scrollback)
{
if (update_adj)
update_adjustment_value (term);
return;
}
if (term->priv->_top_line > scrollback)
{
term->priv->_top_line = scrollback;
update_full = TRUE;
}
term->priv->_scrolled = FALSE;
moo_term_invalidate_content_all (term);
moo_term_invalidate_all (term);
if (update_full)
update_adjustment (term);
else if (update_adj)
update_adjustment_value (term);
}
void moo_term_size_changed (MooTerm *term)
{
GtkWidget *widget = GTK_WIDGET (term);
TermFontInfo *font_info = term->priv->font_info;
guint width, height;
guint old_width, old_height;
width = widget->allocation.width / font_info->width;
height = widget->allocation.height / font_info->height;
old_width = term->priv->width;
old_height = term->priv->height;
if (width == old_width && height == old_height)
return;
moo_term_buffer_set_screen_size (term->priv->primary_buffer,
width, height);
moo_term_buffer_set_screen_size (term->priv->alternate_buffer,
width, height);
moo_term_pt_set_size (term->priv->pt, width, height);
}
gboolean moo_term_fork_command (MooTerm *term,
const char *cmd,
const char *working_dir,
char **envp)
{
g_return_val_if_fail (MOO_IS_TERM (term), FALSE);
return moo_term_pt_fork_command (term->priv->pt,
cmd, working_dir, envp);
}
void moo_term_feed_child (MooTerm *term,
const char *string,
int len)
{
g_return_if_fail (MOO_IS_TERM (term) && string != NULL);
moo_term_pt_write (term->priv->pt, string, len);
}
void moo_term_copy_clipboard (MooTerm *term)
{
char *text = term_selection_get_text (term);
if (text && *text)
gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
text, -1);
if (text)
{
g_assert (*text);
g_free (text);
}
}
void moo_term_ctrl_c (MooTerm *term)
{
moo_term_pt_send_intr (term->priv->pt);
}
void moo_term_paste_clipboard (MooTerm *term)
{
GtkClipboard *cb;
char *text;
g_return_if_fail (MOO_IS_TERM (term));
cb = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
text = gtk_clipboard_wait_for_text (cb);
if (text)
{
moo_term_pt_write (term->priv->pt, text, -1);
g_free (text);
}
}
void moo_term_feed (MooTerm *term,
const char *data,
int len)
{
if (!len)
return;
g_return_if_fail (data != NULL);
if (len < 0)
len = strlen (data);
moo_term_parser_parse (term->priv->parser, data, len);
}
void moo_term_scroll_to_top (MooTerm *term)
{
scroll_abs (term, 0, TRUE);
}
void moo_term_scroll_to_bottom (MooTerm *term)
{
scroll_to_bottom (term, TRUE);
}
void moo_term_scroll_lines (MooTerm *term,
int lines)
{
int top = term_top_line (term);
top += lines;
if (top < 0)
top = 0;
scroll_abs (term, top, TRUE);
}
void moo_term_scroll_pages (MooTerm *term,
int pages)
{
int top = term_top_line (term);
top += pages * term->priv->height;
if (top < 0)
top = 0;
scroll_abs (term, top, TRUE);
}
void moo_term_set_window_title (MooTerm *term,
const char *title)
{
g_signal_emit (term, signals[SET_WINDOW_TITLE], 0, title);
}
void moo_term_set_icon_name (MooTerm *term,
const char *title)
{
g_signal_emit (term, signals[SET_ICON_NAME], 0, title);
}
void moo_term_bell (MooTerm *term)
{
g_signal_emit (term, signals[BELL], 0);
}
void moo_term_decid (MooTerm *term)
{
moo_term_feed_child (term, TERM_VT_DECID_STRING, -1);
}
void moo_term_set_dec_modes (MooTerm *term,
int *modes,
guint n_modes,
gboolean set)
{
guint i;
g_return_if_fail (n_modes != 0); /* ??? */
for (i = 0; i < n_modes; ++i)
{
int mode = -1;
switch (modes[i])
{
case 47:
moo_term_set_alternate_buffer (term, set);
break;
default:
GET_DEC_MODE (modes[i], mode);
if (mode >= 0)
moo_term_set_mode (term, mode, set);
}
}
}
void moo_term_save_dec_modes (MooTerm *term,
int *modes,
guint n_modes)
{
guint i;
g_return_if_fail (n_modes != 0); /* ??? */
for (i = 0; i < n_modes; ++i)
{
int mode = -1;
GET_DEC_MODE (modes[i], mode);
if (mode >= 0)
term->priv->saved_modes[mode] = term->priv->modes[mode];
}
}
void moo_term_restore_dec_modes (MooTerm *term,
int *modes,
guint n_modes)
{
guint i;
g_return_if_fail (n_modes != 0); /* ??? */
for (i = 0; i < n_modes; ++i)
{
int mode = -1;
GET_DEC_MODE (modes[i], mode);
if (mode >= 0)
moo_term_set_mode (term, mode, term->priv->saved_modes[mode]);
}
}
void moo_term_set_ansi_modes (MooTerm *term,
int *modes,
guint n_modes,
gboolean set)
{
guint i;
g_return_if_fail (n_modes != 0); /* ??? */
for (i = 0; i < n_modes; ++i)
{
int mode = -1;
GET_ANSI_MODE (modes[i], mode);
if (mode >= 0)
moo_term_set_mode (term, mode, set);
}
}
void moo_term_set_mode (MooTerm *term,
int mode,
gboolean set)
{
#if 1
switch (mode)
{
case MODE_DECSCNM:
g_message ("set MODE_DECSCNM %s", set ? "TRUE" : "FALSE");
break;
#if 0
case MODE_DECTCEM:
g_message ("set MODE_DECTCEM %s", set ? "TRUE" : "FALSE");
break;
#endif
case MODE_CA:
g_message ("set MODE_CA %s", set ? "TRUE" : "FALSE");
break;
case MODE_REVERSE_WRAPAROUND:
g_message ("set MODE_REVERSE_WRAPAROUND %s", set ? "TRUE" : "FALSE");
break;
case MODE_PRESS_TRACKING:
g_message ("set MODE_PRESS_TRACKING %s", set ? "TRUE" : "FALSE");
break;
case MODE_PRESS_AND_RELEASE_TRACKING:
g_message ("set MODE_PRESS_AND_RELEASE_TRACKING %s", set ? "TRUE" : "FALSE");
break;
case MODE_HILITE_MOUSE_TRACKING:
g_message ("set MODE_HILITE_MOUSE_TRACKING %s", set ? "TRUE" : "FALSE");
break;
case MODE_SRM:
g_message ("set MODE_SRM %s", set ? "TRUE" : "FALSE");
break;
case MODE_LNM:
g_message ("set MODE_LNM %s", set ? "TRUE" : "FALSE");
break;
#if 0
case MODE_DECNKM:
g_message ("set MODE_DECNKM %s", set ? "TRUE" : "FALSE");
break;
case MODE_DECCKM:
g_message ("set MODE_DECCKM %s", set ? "TRUE" : "FALSE");
break;
#endif
case MODE_DECANM:
g_message ("set MODE_DECANM %s", set ? "TRUE" : "FALSE");
break;
case MODE_DECBKM:
g_message ("set MODE_DECBKM %s", set ? "TRUE" : "FALSE");
break;
case MODE_DECKPM:
g_message ("set MODE_DECKPM %s", set ? "TRUE" : "FALSE");
break;
case MODE_IRM:
g_message ("set MODE_IRM %s", set ? "TRUE" : "FALSE");
break;
case MODE_DECOM:
g_message ("set MODE_DECOM %s", set ? "TRUE" : "FALSE");
break;
case MODE_DECAWM:
g_message ("set MODE_DECAWM %s", set ? "TRUE" : "FALSE");
break;
}
#endif
switch (mode)
{
case MODE_DECSCNM:
term->priv->modes[mode] = set;
moo_term_buffer_set_mode (term->priv->buffer, mode, set);
moo_term_invert_colors (term, set);
break;
case MODE_DECTCEM:
term->priv->modes[mode] = set;
moo_term_buffer_set_mode (term->priv->buffer, mode, set);
moo_term_set_cursor_visible (term, set);
break;
case MODE_CA:
term->priv->modes[mode] = set;
moo_term_buffer_set_mode (term->priv->buffer, mode, set);
moo_term_set_ca_mode (term, set);
break;
case MODE_PRESS_TRACKING:
case MODE_PRESS_AND_RELEASE_TRACKING:
case MODE_HILITE_MOUSE_TRACKING:
if (set)
moo_term_set_mouse_tracking (term, mode);
else
moo_term_set_mouse_tracking (term, -1);
term->priv->modes[mode] = set;
moo_term_buffer_set_mode (term->priv->buffer, mode, set);
break;
/* these do not require anything special, just record the value */
case MODE_SRM:
case MODE_LNM:
case MODE_DECNKM:
case MODE_DECCKM:
case MODE_DECANM:
case MODE_DECBKM:
case MODE_DECKPM:
case MODE_REVERSE_WRAPAROUND:
term->priv->modes[mode] = set;
moo_term_buffer_set_mode (term->priv->buffer, mode, set);
break;
/* these are ignored */
case MODE_IRM:
case MODE_DECOM:
case MODE_DECAWM:
term->priv->modes[mode] = set;
moo_term_buffer_set_mode (term->priv->buffer, mode, set);
break;
default:
g_warning ("%s: unknown mode %d", G_STRFUNC, mode);
}
}
static void save_cursor (MooTerm *term)
{
g_array_append_val (term->priv->saved_cursor,
term->priv->cursor_row);
g_array_append_val (term->priv->saved_cursor,
term->priv->cursor_col);
}
static void restore_cursor (MooTerm *term)
{
guint row = 0;
guint col = 0;
if (term->priv->saved_cursor->len)
{
row = g_array_index (term->priv->saved_cursor, guint,
term->priv->saved_cursor->len - 2);
col = g_array_index (term->priv->saved_cursor, guint,
term->priv->saved_cursor->len - 1);
g_array_set_size (term->priv->saved_cursor,
term->priv->saved_cursor->len - 2);
}
moo_term_buffer_cursor_move_to (term->priv->buffer, row, col);
}
void moo_term_set_ca_mode (MooTerm *term,
gboolean set)
{
if (set)
{
save_cursor (term);
moo_term_set_alternate_buffer (term, TRUE);
moo_term_buffer_erase_in_display (term->priv->buffer, 2);
moo_term_buffer_set_ca_mode (term->priv->buffer, TRUE);
}
else
{
moo_term_set_alternate_buffer (term, FALSE);
moo_term_buffer_set_ca_mode (term->priv->buffer, FALSE);
restore_cursor (term);
}
}
void moo_term_set_alternate_buffer (MooTerm *term,
gboolean alternate)
{
g_message ("set alternate buffer %s", alternate ? "TRUE" : "FALSE");
if ((alternate && term->priv->buffer == term->priv->alternate_buffer) ||
(!alternate && term->priv->buffer == term->priv->primary_buffer))
return;
if (alternate)
term->priv->buffer = term->priv->alternate_buffer;
else
term->priv->buffer = term->priv->primary_buffer;
moo_term_invalidate_content_all (term);
moo_term_invalidate_all (term);
moo_term_buffer_scrollback_changed (term->priv->buffer);
}
void moo_term_da1 (MooTerm *term)
{
moo_term_feed_child (term, "\033[?64;1;c", -1);
/*
1 132 columns
2 Printer port
4 Sixel
6 Selective erase
7 Soft character set (DRCS) TODO
8 User-defined keys (UDKs) TODO
9 National replacement character sets (NRCS)
(International terminal only) TODO
12 Yugoslavian (SCS)
15 Technical character set TODO
18 Windowing capability TODO
21 Horizontal scrolling TODO
23 Greek
24 Turkish
42 ISO Latin-2 character set
44 PCTerm TODO
45 Soft key map TODO
46 ASCII emulation TODO
*/
}
void moo_term_da2 (MooTerm *term)
{
/* TODO */
moo_term_feed_child (term, "\033[>61;20;1;c", -1);
}
void moo_term_da3 (MooTerm *term)
{
/* TODO */
moo_term_feed_child (term, "\033P!|FFFFFFFF\033\\", -1);
}
#define make_DECRQSS(c) \
answer = g_strdup_printf ("\033P%s$r" FINAL_##c "\033\\", ps)
void moo_term_setting_request (MooTerm *term,
int setting)
{
DECRQSSCode code = setting;
char *ps = NULL, *answer = NULL;
switch (code)
{
case CODE_DECSASD: /* Select Active Status Display*/
ps = g_strdup ("0");
make_DECRQSS (DECSASD);
break;
case CODE_DECSCL: /* Set Conformance Level */
ps = g_strdup ("61");
make_DECRQSS (DECSCL);
break;
case CODE_DECSCPP: /* Set Columns Per Page */
ps = g_strdup_printf ("%d", term->priv->width);
make_DECRQSS (DECSCPP);
break;
case CODE_DECSLPP: /* Set Lines Per Page */
ps = g_strdup_printf ("%d", term->priv->height);
make_DECRQSS (DECSLPP);
break;
case CODE_DECSNLS: /* Set Number of Lines per Screen */
ps = g_strdup_printf ("%d", term->priv->height);
make_DECRQSS (DECSNLS);
break;
case CODE_DECSTBM: /* Set Top and Bottom Margins */
ps = g_strdup_printf ("%d;%d",
term->priv->buffer->priv->top_margin + 1,
term->priv->buffer->priv->bottom_margin + 1);
make_DECRQSS (DECSTBM);
break;
}
moo_term_feed_child (term, answer, -1);
g_free (answer);
g_free (ps);
}
void moo_term_reset (MooTerm *term)
{
moo_term_buffer_freeze_changed_notify (term->priv->primary_buffer);
moo_term_buffer_freeze_cursor_notify (term->priv->primary_buffer);
term->priv->buffer = term->priv->primary_buffer;
moo_term_buffer_reset (term->priv->primary_buffer);
moo_term_buffer_reset (term->priv->alternate_buffer);
set_default_modes (term->priv->modes);
set_default_modes (term->priv->saved_modes);
moo_term_buffer_thaw_changed_notify (term->priv->primary_buffer);
moo_term_buffer_thaw_cursor_notify (term->priv->primary_buffer);
moo_term_buffer_changed (term->priv->primary_buffer);
moo_term_buffer_cursor_moved (term->priv->primary_buffer);
}
void moo_term_soft_reset (MooTerm *term)
{
moo_term_buffer_freeze_changed_notify (term->priv->buffer);
moo_term_buffer_freeze_cursor_notify (term->priv->buffer);
moo_term_buffer_soft_reset (term->priv->buffer);
set_default_modes (term->priv->modes);
set_default_modes (term->priv->saved_modes);
moo_term_buffer_thaw_changed_notify (term->priv->primary_buffer);
moo_term_buffer_thaw_cursor_notify (term->priv->primary_buffer);
moo_term_buffer_changed (term->priv->primary_buffer);
moo_term_buffer_cursor_moved (term->priv->primary_buffer);
}
void moo_term_dsr (MooTerm *term,
int type,
int arg,
gboolean extended)
{
char *answer = NULL;
MooTermBuffer *buf = term->priv->buffer;
switch (type)
{
case 6:
if (extended)
answer = g_strdup_printf ("\233%d;%d;0R",
buf_cursor_row (buf) + 1,
buf_cursor_col (buf) + 1);
else
answer = g_strdup_printf ("\233%d;%dR",
buf_cursor_row (buf) + 1,
buf_cursor_col (buf) + 1);
break;
break;
case 75:
answer = g_strdup ("\233?70n");
break;
case 26:
answer = g_strdup ("\233?27;1;0;5n");
break;
case 62:
answer = g_strdup ("\2330*{");
break;
case 63:
if (arg > 0)
answer = g_strdup_printf ("\220%d!~30303030\234", arg);
else
answer = g_strdup ("\220!~30303030\234");
break;
case 5:
answer = g_strdup ("\2330n");
break;
case 15:
answer = g_strdup ("\233?13n");
break;
case 25:
answer = g_strdup ("\233?21n");
break;
default:
g_warning ("%s: unknown request", G_STRFUNC);
}
if (answer)
{
moo_term_feed_child (term, answer, -1);
g_free (answer);
}
}
void moo_term_update_pointer (MooTerm *term)
{
if (term->priv->pointer_visible)
{
if (term->priv->tracking_mouse)
gdk_window_set_cursor (GTK_WIDGET(term)->window,
term->priv->pointer[POINTER_NORMAL]);
else
gdk_window_set_cursor (GTK_WIDGET(term)->window,
term->priv->pointer[POINTER_TEXT]);
}
else
{
gdk_window_set_cursor (GTK_WIDGET(term)->window,
term->priv->pointer[POINTER_NONE]);
}
}
void moo_term_set_pointer_visible (MooTerm *term,
gboolean visible)
{
g_return_if_fail (GTK_WIDGET_REALIZED (term));
if (visible != term->priv->pointer_visible)
{
term->priv->pointer_visible = visible;
moo_term_update_pointer (term);
}
}
static gboolean moo_term_popup_menu (GtkWidget *widget)
{
moo_term_do_popup_menu (MOO_TERM (widget), NULL);
return TRUE;
}
static void menu_position_func (G_GNUC_UNUSED GtkMenu *menu,
gint *px,
gint *py,
gboolean *push_in,
MooTerm *term)
{
guint cursor_row, cursor_col;
GdkWindow *window;
window = GTK_WIDGET(term)->window;
gdk_window_get_origin (window, px, py);
cursor_col = buf_cursor_col (term->priv->buffer);
cursor_row = buf_cursor_row (term->priv->buffer);
cursor_row += buf_scrollback (term->priv->buffer);
if (cursor_row >= term_top_line (term))
{
cursor_row -= term_top_line (term);
*px += (cursor_col + 1) * term_char_width (term);
*py += (cursor_row + 1) * term_char_height (term);
}
else
{
int x, y, width, height;
GdkModifierType mask;
gdk_window_get_pointer (window, &x, &y, &mask);
gdk_drawable_get_size (GDK_DRAWABLE (window), &width, &height);
*px += CLAMP (x, 2, width - 2);
*py += CLAMP (x, 2, height - 2);
}
*push_in = TRUE;
}
void moo_term_do_popup_menu (MooTerm *term,
GdkEventButton *event)
{
GtkWidget *menu;
menu = gtk_menu_new ();
g_signal_connect (menu, "deactivate",
G_CALLBACK (gtk_widget_destroy), NULL);
/* TODO: add copy/paste */
g_signal_emit (term, signals[POPULATE_POPUP], 0, menu);
if (event)
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
event->button, event->time);
else
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
(GtkMenuPositionFunc) menu_position_func,
term, 0, gtk_get_current_event_time ());
}
static gboolean moo_term_scroll (GtkWidget *widget,
GdkEventScroll *event)
{
switch (event->direction)
{
case GDK_SCROLL_UP:
moo_term_scroll_lines (MOO_TERM (widget), -SCROLL_GRANULARITY);
return TRUE;
case GDK_SCROLL_DOWN:
moo_term_scroll_lines (MOO_TERM (widget), SCROLL_GRANULARITY);
return TRUE;
default:
return FALSE;
}
}
Reference in New Issue View Git Blame Copy Permalink