gtkedit.c

具有IDE功能的编辑器

    g_return_if_fail (requisition != NULL);

    xthickness = widget->style->klass->xthickness + EDIT_BORDER_ROOM;
    ythickness = widget->style->klass->ythickness + EDIT_BORDER_ROOM;

    char_height = MIN_EDIT_HEIGHT_LINES * (widget->style->font->ascent +
					   widget->style->font->descent);

    char_width = MIN_EDIT_WIDTH_LINES * (gdk_text_width (widget->style->font,
					    "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
							 26)
					 / 26);

    requisition->width = char_width + xthickness * 2;
    requisition->height = char_height + ythickness * 2;
}

static void gtk_edit_size_allocate (GtkWidget * widget,
				    GtkAllocation * allocation)
{
    GtkEdit *edit;
    GtkEditable *editable;

    g_return_if_fail (widget != NULL);
    g_return_if_fail (GTK_IS_EDIT (widget));
    g_return_if_fail (allocation != NULL);

    edit = GTK_EDIT (widget);
    editable = GTK_EDITABLE (widget);

    widget->allocation = *allocation;
    if (GTK_WIDGET_REALIZED (widget)) {
	gdk_window_move_resize (widget->window,
				allocation->x, allocation->y,
				allocation->width, allocation->height);

	gdk_window_move_resize (edit->text_area,
		     widget->style->klass->xthickness + EDIT_BORDER_ROOM,
		     widget->style->klass->ythickness + EDIT_BORDER_ROOM,
	   widget->allocation.width - (widget->style->klass->xthickness +
				       EDIT_BORDER_ROOM) * 2,
	  widget->allocation.height - (widget->style->klass->ythickness +
				       EDIT_BORDER_ROOM) * 2);

#if 0
	recompute_geometry (edit);
#endif
    }
}

static void gtk_edit_draw (GtkWidget * widget,
			   GdkRectangle * area)
{
    GtkEdit *edit;
    g_return_if_fail (widget != NULL);
    g_return_if_fail (GTK_IS_EDIT (widget));
    g_return_if_fail (area != NULL);

    if (GTK_WIDGET_DRAWABLE (widget)) {
/* convert the gtk expose to a coolwidget expose */
	XExposeEvent xexpose;
	xexpose.x = area->x;
	xexpose.y = area->y;
	xexpose.width = area->width;
	xexpose.height = area->height;
	edit = GTK_EDIT (widget);
	edit_render_expose (edit->editor, &xexpose);
	edit_status (edit->editor);
    }
}

void gtk_edit_set_colors (GtkEdit *win)
{
    edit_set_foreground_colors (
				 color_palette (option_editor_fg_normal),
				   color_palette (option_editor_fg_bold),
				   color_palette (option_editor_fg_italic)
	);
    edit_set_background_colors (
				 color_palette (option_editor_bg_normal),
			       color_palette (option_editor_bg_abnormal),
				 color_palette (option_editor_bg_marked),
			color_palette (option_editor_bg_marked_abnormal),
			     color_palette (option_editor_bg_highlighted)
	);
    edit_set_cursor_color (
			      color_palette (option_editor_fg_cursor)
	);
}

static gint
 gtk_edit_expose (GtkWidget * widget,
		  GdkEventExpose * event)
{
    GtkEdit *edit;
    g_return_val_if_fail (widget != NULL, FALSE);
    g_return_val_if_fail (GTK_IS_EDIT (widget), FALSE);
    g_return_val_if_fail (event != NULL, FALSE);

    if (GTK_WIDGET_DRAWABLE (widget)) {
/* convert the gtk expose to a coolwidget expose */
	XExposeEvent xexpose;
	xexpose.x = event->area.x;
	xexpose.y = event->area.y;
	xexpose.width = event->area.width;
	xexpose.height = event->area.height;
	edit = GTK_EDIT (widget);
	gtk_edit_set_colors (edit);
	edit_render_expose (edit->editor, &xexpose);
	edit_status (edit->editor);
    }
    return FALSE;
}

static gint
 gtk_edit_button_press_release (GtkWidget * widget,
				GdkEventButton * event)
{
    int double_click = 0;
    XEvent xevent;
    GtkEdit *edit;
    GtkEditable *editable;
    static GdkAtom ctext_atom = GDK_NONE;

    g_return_val_if_fail (widget != NULL, FALSE);
    g_return_val_if_fail (GTK_IS_EDIT (widget), FALSE);
    g_return_val_if_fail (event != NULL, FALSE);

    if (ctext_atom == GDK_NONE)
	ctext_atom = gdk_atom_intern ("COMPOUND_TEXT", FALSE);

    edit = GTK_EDIT (widget);
    editable = GTK_EDITABLE (widget);

    if (!GTK_WIDGET_HAS_FOCUS (widget))
	if (!(event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)))
	    gtk_widget_grab_focus (widget);

    switch (event->type) {
    case GDK_MOTION_NOTIFY:
	xevent.type = MotionNotify;
	break;
    case GDK_BUTTON_PRESS:
	xevent.type = ButtonPress;
	break;
    case GDK_2BUTTON_PRESS:
	xevent.type = ButtonPress;
	double_click = 1;
	break;
    case GDK_BUTTON_RELEASE:
	xevent.type = ButtonRelease;
	break;
    case GDK_3BUTTON_PRESS:
    default:
	return FALSE;
	break;
    }
    xevent.xbutton.window = (guint32) event->window;
    xevent.xbutton.x = event->x;
    xevent.xbutton.y = event->y;
    xevent.xbutton.state = event->state;

    edit_mouse_mark (edit->editor, &xevent, double_click);
    return FALSE;
}

static gint
 gtk_edit_button_motion (GtkWidget * widget,
			 GdkEventMotion * event)
{
    return gtk_edit_button_press_release (widget, (GdkEventButton *) event);
}

static guint toggle_bit (guint x, guint mask)
{
    unsigned long m = -1;
    if ((x & mask))
	return x & (m - mask);
    else
	return x | mask;
}

int mod_type_key (guint x)
{
    switch ((guint) x) {
    case GDK_Shift_L:
    case GDK_Shift_R:
    case GDK_Control_L:
    case GDK_Control_R:
    case GDK_Caps_Lock:
    case GDK_Shift_Lock:
    case GDK_Meta_L:
    case GDK_Meta_R:
    case GDK_Alt_L:
    case GDK_Alt_R:
    case GDK_Super_L:
    case GDK_Super_R:
    case GDK_Hyper_L:
    case GDK_Hyper_R:
	return 1;
    }
    return 0;
}

/* get a 15 bit "almost unique" key sym that includes keyboard modifier
   info in the top 3 bits */
short key_sym_mod (gint key, gint state)
{
    if (key && !mod_type_key (key)) {
	key = toggle_bit (key, 0x1000 * ((state & GDK_SHIFT_MASK) != 0));
	key = toggle_bit (key, 0x2000 * ((state & GDK_CONTROL_MASK) != 0));
	key = toggle_bit (key, 0x4000 * ((state & GDK_MOD1_MASK) != 0));
	key &= 0x7FFF;
    } else
	key = 0;
    return key;
}

static gint
 gtk_edit_key_press (GtkWidget * widget,
		     GdkEventKey * event)
{
    GtkEdit *edit;
    GtkEditable *editable;
    gint command = 0, insert = -1, r = 0;
    guint key, state;

    g_return_val_if_fail (widget != NULL, FALSE);
    g_return_val_if_fail (GTK_IS_EDIT (widget), FALSE);
    g_return_val_if_fail (event != NULL, FALSE);

    edit = GTK_EDIT (widget);
    editable = GTK_EDITABLE (widget);

    if (!edit_translate_key (0, event->keyval, event->state, &command, &insert)) {
	return FALSE;
    }
    key = event->keyval;
    state = event->state;
    if (!command && insert < 0) {	/* no translation took place, so lets see if we have a macro */
	if ((key == GDK_r || key == GDK_R) && (state & ControlMask)) {
	    command = edit->editor->macro_i < 0 ? CK_Begin_Record_Macro : CK_End_Record_Macro;
	} else {
	    command = key_sym_mod (key, state);
	    if (command > 0)
		command = CK_Macro (command);
	}
    }
    r = edit_execute_key_command (edit->editor, command, insert);
    if (r)
	edit_update_screen (edit->editor);

    return r;
}

/**********************************************************************/
/*                              Widget Crap                           */
/**********************************************************************/

char *home_dir = 0;

static void get_home_dir (void)
{
    if (home_dir)		/* already been set */
	return;
    home_dir = getenv ("HOME");
    if (home_dir)
	if (*home_dir) {
	    home_dir = strdup (home_dir);
	    return;
	}
    home_dir = (getpwuid (geteuid ()))->pw_dir;
    if (home_dir)
	if (*home_dir) {
	    home_dir = strdup (home_dir);
	    return;
	}
    fprintf (stderr, _("gtkedit.c: HOME environment variable not set and no passwd entry - aborting\n"));
    abort ();
}


static void gtk_edit_class_init (GtkEditClass * class)
{
    GtkObjectClass *object_class;
    GtkWidgetClass *widget_class;
    GtkEditableClass *editable_class;

    object_class = (GtkObjectClass *) class;
    widget_class = (GtkWidgetClass *) class;
    editable_class = (GtkEditableClass *) class;

    parent_class = gtk_type_class (gtk_editable_get_type ());

    object_class->destroy = gtk_edit_destroy;

    widget_class->realize = gtk_edit_realize;
    widget_class->unrealize = gtk_edit_unrealize;
    widget_class->style_set = gtk_edit_style_set;
    widget_class->draw_focus = gtk_edit_draw_focus;
    widget_class->size_request = gtk_edit_size_request;
    widget_class->size_allocate = gtk_edit_size_allocate;
    widget_class->draw = gtk_edit_draw;
    widget_class->expose_event = gtk_edit_expose;
    widget_class->button_press_event = gtk_edit_button_press_release;
    widget_class->button_release_event = gtk_edit_button_press_release;
    widget_class->motion_notify_event = gtk_edit_button_motion;

    widget_class->key_press_event = gtk_edit_key_press;
#if 0
    widget_class->focus_in_event = gtk_edit_focus_in;
    widget_class->focus_out_event = gtk_edit_focus_out;
#endif
    widget_class->focus_in_event = 0;
    widget_class->focus_out_event = 0;

#if 0
    editable_class->insert_text = gtk_edit_insert_text;
    editable_class->delete_text = gtk_edit_delete_text;
    editable_class->update_text = gtk_edit_update_text;
    editable_class->get_chars = gtk_edit_get_chars;
    editable_class->set_selection = gtk_edit_set_selection;
#endif
    editable_class->set_position = gtk_edit_set_position;

    editable_class->insert_text = 0;
    editable_class->delete_text = 0;
    editable_class->update_text = 0;
    editable_class->get_chars = 0;

#if 0
    editable_class->set_position = 0;
#endif

    get_home_dir ();
}

extern struct mouse_funcs edit_mouse_funcs;

static void gtk_edit_init (GtkEdit * edit)
{
    static made_directory = 0;

    GTK_WIDGET_SET_FLAGS (edit, GTK_CAN_FOCUS);

    edit->editor = edit_init (0, 80, 25, 0, "", "/", 0);
    edit->editor->macro_i = -1;
    edit->editor->widget = edit;
    edit->timer = 0;
    edit->menubar = 0;
    edit->status = 0;
    edit->options = 0;
    edit->funcs = mouse_funcs_new (edit->editor, &edit_mouse_funcs);

    gtk_edit_configure_font_dimensions (edit);

    if (!made_directory) {
	mkdir (catstrs (home_dir, EDIT_DIR, 0), 0700);
	made_directory = 1;
    }
    GTK_EDITABLE (edit)->editable = TRUE;
}

guint
gtk_edit_get_type (void)
{
    static guint edit_type = 0;

    if (!edit_type) {
	GtkTypeInfo edit_info =
	{
	    "GtkEdit",
	    sizeof (GtkEdit),
	    sizeof (GtkEditClass),
	    (GtkClassInitFunc) gtk_edit_class_init,
	    (GtkObjectInitFunc) gtk_edit_init,
	    (GtkArgSetFunc) NULL,
	    (GtkArgGetFunc) NULL,
	};

	edit_type = gtk_type_unique (gtk_editable_get_type (), &edit_info);
    }
    return edit_type;
}

#include <libgnomeui/gtkcauldron.h>
#include <libgnomeui/gnome-stock.h>

char *gtk_edit_dialog_get_save_file (guchar * dir, guchar * def, guchar * title)
{
    char *s;
    s = gtk_dialog_cauldron (
				title, GTK_CAULDRON_TOPLEVEL | GTK_CAULDRON_GRAB,
	    " ( ( (Filename:)d | %Fgxf )f )xf / ( %Bxfgrq || %Bxfgq )f ",
				&def, "filename", title,
				GNOME_STOCK_BUTTON_OK,
				GNOME_STOCK_BUTTON_CANCEL
	);
    if (s == GTK_CAULDRON_ESCAPE || !s || s == GNOME_STOCK_BUTTON_CANCEL)
	return 0;
    return def;
}

char *gtk_edit_dialog_get_load_file (guchar * dir, guchar * def, guchar * title)
{
    char *s;
    s = gtk_dialog_cauldron (
				title, GTK_CAULDRON_TOPLEVEL | GTK_CAULDRON_GRAB,
	    " ( ( (Filename:)d | %Fgxf )f )xf / ( %Bxfgrq || %Bxfgq )f ",
				&def, "filename", title,
				GNOME_STOCK_BUTTON_OK,
				GNOME_STOCK_BUTTON_CANCEL
	);
    if (s == GTK_CAULDRON_ESCAPE || !s || s == GNOME_STOCK_BUTTON_CANCEL)
	return 0;