gtkedit.c

具有IDE功能的编辑器

/* gtkedit.c - front end for gtk/gnome version

   Copyright (C) 1996-2000 the Free Software Foundation

   Authors: 1996, 1997 Paul Sheer

   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.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307, USA.
*/

#define _GTK_EDIT_C

#include <config.h>
#include <gnome.h>
#include <ctype.h>
#include <string.h>
#include <pwd.h>
#include "gdk/gdkkeysyms.h"
#include "gtk/gtkmain.h"
#include "gtk/gtkselection.h"
#include "gtk/gtksignal.h"
#include "edit.h"
#include "mousemark.h"
#include "mad.h"

#define EDIT_BORDER_ROOM         1
#define MIN_EDIT_WIDTH_LINES     20
#define MIN_EDIT_HEIGHT_LINES    10

#define GDK_FONT_XFONT(font) (((GdkFontPrivate*) font)->xfont)

int edit_key_emulation = 0;

static GtkWidgetClass *parent_class = NULL;

WEdit *edit_init (WEdit * edit, int lines, int columns, const char *filename, const char *text, const char *dir, unsigned long text_size);
void edit_destroy_callback (CWidget * w);
int edit_translate_key (unsigned int x_keycode, long x_key, int x_state, int *cmd, int *ch);
void gtk_edit_alloc_colors (GtkEdit *edit, GdkColormap *colormap);
static void gtk_edit_set_position (GtkEditable *editable, gint position);
void edit_mouse_mark (WEdit * edit, XEvent * event, int double_click);
void edit_move_to_prev_col (WEdit * edit, long p);
int edit_load_file_from_filename (WEdit *edit, char *exp);


guchar gtk_edit_font_width_per_char[256];
int gtk_edit_option_text_line_spacing;
int gtk_edit_option_font_ascent;
int gtk_edit_option_font_descent;
int gtk_edit_option_font_mean_width;
int gtk_edit_fixed_font;

static void clear_focus_area (GtkEdit *edit, gint area_x, gint area_y, gint area_width, gint area_height)
{
    return;
}

void gtk_edit_freeze (GtkEdit *edit)
{
    return;
}

void       gtk_edit_insert          (GtkEdit       *edit,
				     GdkFont       *font,
				     GdkColor      *fore,
				     GdkColor      *back,
				     const char    *chars,
				     gint           length)
{
    while (length-- > 0)
	edit_insert (GTK_EDIT (edit)->editor, *chars++);
}

void       gtk_edit_set_editable    (GtkEdit       *text,
				     gint           editable)
{
    return;
}

void       gtk_edit_thaw            (GtkEdit       *text)
{
    return;
}


void gtk_edit_configure_font_dimensions (GtkEdit * edit)
{
    XFontStruct *f;
    XCharStruct s;
    char *p;
    char q[256];
    unsigned char t;
    int i, direction;
    f = GDK_FONT_XFONT (edit->editable.widget.style->font);
    p = _ ("The Quick Brown Fox Jumps Over The Lazy Dog");
    for (i = ' '; i <= '~'; i++)
	q[i - ' '] = i;
    if (XmbTextEscapement (f, "M", 1) == XmbTextEscapement (f, "M", 1))
	gtk_edit_fixed_font = 1;
    else
	gtk_edit_fixed_font = 0;
    XTextExtents (f, q, '~' - ' ', &direction, &gtk_edit_option_font_ascent, &gtk_edit_option_font_descent, &s);
    gtk_edit_option_font_mean_width = XmbTextEscapement (f, p, strlen (p)) / strlen (p);
    for (i = 0; i < 256; i++) {
	t = (unsigned char) i;
	if (i > f->max_char_or_byte2 || i < f->min_char_or_byte2) {
	    gtk_edit_font_width_per_char[i] = 0;
	} else {
	    gtk_edit_font_width_per_char[i] = XmbTextEscapement (f, (char *) &t, 1);
	}
    }
}

void gtk_edit_set_adjustments (GtkEdit * edit,
			       GtkAdjustment * hadj,
			       GtkAdjustment * vadj)
{
    g_return_if_fail (edit != NULL);
    g_return_if_fail (GTK_IS_EDIT (edit));

    if (edit->hadj && (edit->hadj != hadj)) {
	gtk_signal_disconnect_by_data (GTK_OBJECT (edit->hadj), edit);
	gtk_object_unref (GTK_OBJECT (edit->hadj));
    }
    if (edit->vadj && (edit->vadj != vadj)) {
	gtk_signal_disconnect_by_data (GTK_OBJECT (edit->vadj), edit);
	gtk_object_unref (GTK_OBJECT (edit->vadj));
    }
    if (!hadj)
	hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));

    if (!vadj)
	vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));

    if (edit->hadj != hadj) {
	edit->hadj = hadj;
	gtk_object_ref (GTK_OBJECT (edit->hadj));
	gtk_object_sink (GTK_OBJECT (edit->hadj));

#if 0
	gtk_signal_connect (GTK_OBJECT (edit->hadj), "changed",
			    (GtkSignalFunc) gtk_edit_adjustment,
			    edit);
	gtk_signal_connect (GTK_OBJECT (edit->hadj), "value_changed",
			    (GtkSignalFunc) gtk_edit_adjustment,
			    edit);
	gtk_signal_connect (GTK_OBJECT (edit->hadj), "disconnect",
			    (GtkSignalFunc) gtk_edit_disconnect,
			    edit);
#endif
    }
    if (edit->vadj != vadj) {
	edit->vadj = vadj;
	gtk_object_ref (GTK_OBJECT (edit->vadj));
	gtk_object_sink (GTK_OBJECT (edit->vadj));

#if 0
	gtk_signal_connect (GTK_OBJECT (edit->vadj), "changed",
			    (GtkSignalFunc) gtk_edit_adjustment,
			    edit);
	gtk_signal_connect (GTK_OBJECT (edit->vadj), "value_changed",
			    (GtkSignalFunc) gtk_edit_adjustment,
			    edit);
	gtk_signal_connect (GTK_OBJECT (edit->vadj), "disconnect",
			    (GtkSignalFunc) gtk_edit_disconnect,
			    edit);
#endif
    }
}

GtkWidget *gtk_edit_new (GtkAdjustment * hadj,
			 GtkAdjustment * vadj)
{
    GtkEdit *edit;
    edit = gtk_type_new (gtk_edit_get_type ());
    gtk_edit_set_adjustments (edit, hadj, vadj);
    gtk_edit_configure_font_dimensions (edit);
    return GTK_WIDGET (edit);
}

static void gtk_edit_realize (GtkWidget * widget)
{
    GtkEdit *edit;
    GtkEditable *editable;
    GdkWindowAttr attributes;
    GdkColormap *colormap;
    gint attributes_mask;

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

    edit = GTK_EDIT (widget);
    editable = GTK_EDITABLE (widget);
    GTK_WIDGET_SET_FLAGS (edit, GTK_REALIZED);

    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);
    colormap = attributes.colormap = gtk_widget_get_colormap (widget);
    attributes.event_mask = gtk_widget_get_events (widget);
    attributes.event_mask |= (GDK_EXPOSURE_MASK |
			      GDK_BUTTON_PRESS_MASK |
			      GDK_BUTTON_RELEASE_MASK |
			      GDK_BUTTON_MOTION_MASK |
			      GDK_ENTER_NOTIFY_MASK |
			      GDK_LEAVE_NOTIFY_MASK |
			      GDK_KEY_RELEASE_MASK |
			      GDK_KEY_PRESS_MASK);
    attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

    widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
    gdk_window_set_user_data (widget->window, edit);

    attributes.x = (widget->style->klass->xthickness + EDIT_BORDER_ROOM);
    attributes.y = (widget->style->klass->ythickness + EDIT_BORDER_ROOM);
    attributes.width = widget->allocation.width - attributes.x * 2;
    attributes.height = widget->allocation.height - attributes.y * 2;

    edit->text_area = gdk_window_new (widget->window, &attributes, attributes_mask);
    gdk_window_set_user_data (edit->text_area, edit);

    widget->style = gtk_style_attach (widget->style, widget->window);

    gtk_edit_alloc_colors (edit, colormap);

    /* Can't call gtk_style_set_background here because it's handled specially */
    gdk_window_set_background (widget->window, &edit->color[1]);
    gdk_window_set_background (edit->text_area, &edit->color[1]);

    edit->gc = gdk_gc_new (edit->text_area);
    gdk_gc_set_exposures (edit->gc, TRUE);
    gdk_gc_set_foreground (edit->gc, &edit->color[26]);
    gdk_gc_set_background (edit->gc, &edit->color[1]);


    gdk_window_show (edit->text_area);

    if (editable->selection_start_pos != editable->selection_end_pos)
	gtk_editable_claim_selection (editable, TRUE, GDK_CURRENT_TIME);

#if 0
    if ((widget->allocation.width > 1) || (widget->allocation.height > 1))
	recompute_geometry (edit);
#endif
}

static void gtk_edit_unrealize (GtkWidget * widget)
{
    GtkEdit *edit;

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

    edit = GTK_EDIT (widget);

    gdk_window_set_user_data (edit->text_area, NULL);
    gdk_window_destroy (edit->text_area);
    edit->text_area = NULL;

    gdk_gc_destroy (edit->gc);
    edit->gc = NULL;

    if (GTK_WIDGET_CLASS (parent_class)->unrealize)
	(*GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}

static void gtk_edit_destroy (GtkObject * object)
{
    GtkEdit *edit;

    g_return_if_fail (object != NULL);
    g_return_if_fail (GTK_IS_EDIT (object));

    edit = (GtkEdit *) object;
    if (edit->hadj) {
	gtk_object_unref (GTK_OBJECT (edit->hadj));
	edit->hadj = NULL;
    }
    if (edit->vadj) {
	gtk_object_unref (GTK_OBJECT (edit->vadj));
	edit->vadj = NULL;
    }
    if (edit->timer) {
	gtk_timeout_remove (edit->timer);
	edit->timer = 0;
    }
    if (edit->funcs) {
	free (edit->funcs);
    }
    edit_destroy_callback (edit);

    GTK_OBJECT_CLASS (parent_class)->destroy (object);
}

static void gtk_edit_style_set (GtkWidget * widget,
				GtkStyle * previous_style)
{
    GtkEdit *edit;

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

    edit = GTK_EDIT (widget);
    if (GTK_WIDGET_REALIZED (widget)) {
	gdk_window_set_background (widget->window, &edit->color[1]);
	gdk_window_set_background (edit->text_area, &edit->color[1]);

#if 0
	if ((widget->allocation.width > 1) || (widget->allocation.height > 1))
	    recompute_geometry (edit);
#endif
    }
    if (GTK_WIDGET_DRAWABLE (widget))
	gdk_window_clear (widget->window);
}

static void gtk_edit_draw_focus (GtkWidget * widget)
{
    GtkEdit *edit;
    gint width, height;
    gint x, y;

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

    edit = GTK_EDIT (widget);

    if (GTK_WIDGET_DRAWABLE (widget)) {
	gint ythick = widget->style->klass->ythickness;
	gint xthick = widget->style->klass->xthickness;
	gint xextra = EDIT_BORDER_ROOM;
	gint yextra = EDIT_BORDER_ROOM;

/*      TDEBUG (("in gtk_edit_draw_focus\n")); */

	x = 0;
	y = 0;
	width = widget->allocation.width;
	height = widget->allocation.height;

	if (GTK_WIDGET_HAS_FOCUS (widget)) {
	    x += 1;
	    y += 1;
	    width -= 2;
	    height -= 2;
	    xextra -= 1;
	    yextra -= 1;

	    gdk_draw_rectangle (widget->window,
				widget->style->fg_gc[GTK_STATE_NORMAL],
				FALSE, 0, 0,
				widget->allocation.width - 1,
				widget->allocation.height - 1);
	}
	gtk_draw_shadow (widget->style, widget->window,
			 GTK_STATE_NORMAL, GTK_SHADOW_IN,
			 x, y, width, height);

	x += xthick;
	y += ythick;
	width -= 2 * xthick;
	height -= 2 * ythick;

	if (widget->style->bg_pixmap[GTK_STATE_NORMAL]) {
	    /* top rect */
	    clear_focus_area (edit, x, y, width, yextra);
	    /* left rect */
	    clear_focus_area (edit, x, y + yextra,
			      xextra, y + height - 2 * yextra);
	    /* right rect */
	    clear_focus_area (edit, x + width - xextra, y + yextra,
			      xextra, height - 2 * ythick);
	    /* bottom rect */
	    clear_focus_area (edit, x, x + height - yextra, width, yextra);
	} else if (!GTK_WIDGET_HAS_FOCUS (widget)) {
	    gdk_draw_rectangle (widget->window,
			 widget->style->base_gc[GTK_STATE_NORMAL], FALSE,
				x, y,
				width - 1,
				height - 1);
	}
    }
#if 0
    else {
	TDEBUG (("in gtk_edit_draw_focus (undrawable !!!)\n"));
    }
#endif
}

static void gtk_edit_size_request (GtkWidget * widget,
				   GtkRequisition * requisition)
{
    gint xthickness;
    gint ythickness;
    gint char_height;
    gint char_width;

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