view.c

一个简单的文本编辑器

	gtk_text_insert          (view->text, NULL, NULL, NULL, " ", 1);
	gtk_text_backward_delete (view->text, 1);

	return FALSE;
}

static void
gedit_view_delete (GeditView *view, guint position, gint length, gboolean exclude_this_view)
{
	gfloat upper;
	gfloat value;
	gfloat page_size;
	guint p1;

	gedit_debug (DEBUG_VIEW, "");

	if (!exclude_this_view) {
		p1 = gtk_text_get_point (view->text);
		gtk_text_set_point      (view->text, position);
		gtk_text_forward_delete (view->text, length);
	}
	
	upper     = GTK_ADJUSTMENT (view->text->vadj)->upper;
	value     = GTK_ADJUSTMENT (view->text->vadj)->value;
	page_size = GTK_ADJUSTMENT (view->text->vadj)->page_size;

	/* Only add the hack when we need it, if we add it all the time
	   the reaplace all is ugly. This problem only happens when we are
	   at the bottom of the file and there is a scroolbar*/
	if ((page_size != upper) && (value + page_size >= upper))
		gtk_idle_add ((GtkFunction) gedit_view_refresh_line_hack, view);
	
}


static void
gedit_views_delete (GeditDocument *doc, guint start_pos, guint end_pos, GeditView *view_exclude)
{
	GeditView *nth_view;
	gint n;

	gedit_debug (DEBUG_VIEW, "");

	g_return_if_fail (doc!=NULL);
	g_return_if_fail (end_pos > start_pos);

	for (n = 0; n < g_list_length (doc->views); n++)
	{
		nth_view = g_list_nth_data (doc->views, n);

		gedit_view_delete (nth_view, start_pos, end_pos-start_pos, nth_view == view_exclude);
	}
}

void
doc_delete_text_real_cb (GtkWidget *editable, int start_pos, int end_pos,
			 GeditView *view, gint exclude_this_view, gint undo)
{
	GeditDocument *doc;
	guchar *text_to_delete;

	gedit_debug (DEBUG_VIEW, "");

	g_return_if_fail (view != NULL);
	doc = view->doc;
	g_return_if_fail (doc != NULL);

	if (start_pos == end_pos )
	     return;

	text_to_delete = gtk_editable_get_chars (GTK_EDITABLE(editable), start_pos, end_pos);
	if (undo)
		gedit_undo_add (text_to_delete, start_pos, end_pos, GEDIT_UNDO_ACTION_DELETE, doc, view);
	g_free (text_to_delete);

	if (!exclude_this_view)
		gedit_views_delete (doc, start_pos, end_pos, NULL);
	else
		gedit_views_delete (doc, start_pos, end_pos, view);

}


static void
doc_delete_text_cb (GtkWidget *editable, int start_pos, int end_pos, GeditView *view)
{
	gedit_debug (DEBUG_VIEW, "");

	doc_delete_text_real_cb (editable, start_pos, end_pos, view, TRUE, TRUE);
}


static void
gedit_view_init (GeditView *view)
{
	GtkWidget *window;
	static GtkWidget *menu = NULL;
	GtkStyle *style;
	GdkColor *bg;
	GdkColor *fg;
	
	gedit_debug (DEBUG_VIEW, "");

	/* Vbox */
	/*
	view->vbox = gtk_vbox_new (TRUE, TRUE);
	gtk_container_add (GTK_CONTAINER (view), view->vbox);
	*/
	
	/* Create the upper split screen */
	window = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (window),
					GTK_POLICY_NEVER,
					GTK_POLICY_AUTOMATIC);
	gtk_box_pack_start (GTK_BOX (view), window, TRUE, TRUE, 0);
	
	/* Create and configure the GtkText Widget */
	view->text = GTK_TEXT (gtk_text_new (NULL, NULL));
	gedit_view_set_tab_size (view, settings->tab_size);
	gtk_text_set_editable  (view->text, !view->readonly);
	gtk_text_set_word_wrap (view->text, settings->word_wrap);
	
	/* Toolbar */
	view->toolbar = NULL;

        /* Hook the button & key pressed events */
	gtk_signal_connect (GTK_OBJECT (view->text), "button_press_event",
			    GTK_SIGNAL_FUNC (gedit_event_button_press), NULL);
	gtk_signal_connect (GTK_OBJECT (view->text), "key_press_event",
			    GTK_SIGNAL_FUNC (gedit_event_key_press), NULL);

	/* Handle Auto Indent */
	gtk_signal_connect_after (GTK_OBJECT (view->text), "insert_text",
				  GTK_SIGNAL_FUNC (auto_indent_cb), view);

	/* Connect the insert & delete text callbacks */
	gtk_signal_connect (GTK_OBJECT (view->text), "insert_text",
			    GTK_SIGNAL_FUNC (doc_insert_text_cb), (gpointer) view);
	gtk_signal_connect (GTK_OBJECT (view->text), "delete_text",
			    GTK_SIGNAL_FUNC (doc_delete_text_cb), (gpointer) view);
	gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (view->text));
	
	/* View changed signal */
	view->view_text_changed_signal =
		gtk_signal_connect (GTK_OBJECT(view->text), "changed",
				    GTK_SIGNAL_FUNC (gedit_view_text_changed_cb), view);

	gtk_text_set_point (view->text, 0);

	/* Set colors */
	style = gtk_style_copy (gtk_widget_get_style (GTK_WIDGET (view->text)));

	bg = &style->base[0];
	bg->red   = settings->bg[0];
	bg->green = settings->bg[1];
	bg->blue  = settings->bg[2];

	fg = &style->text[0];
	fg->red   = settings->fg[0];
	fg->green = settings->fg[1];
	fg->blue  = settings->fg[2];
	
   	gtk_widget_set_style (GTK_WIDGET(view->text), style);
	
	gtk_style_unref (style);

	/* Popup Menu */
	if (menu == NULL) 
	{
		menu = gnome_popup_menu_new (popup_menu);
		/* popup menu will not be destroyed when all the view are closed
		 * FIXME: destroy popup before exiting the program*/
		gtk_widget_ref(menu);
	}

	/* The same popup menu is attached to all views */
	gnome_popup_menu_attach (menu, GTK_WIDGET (view->text), view);

	gtk_widget_show_all   (GTK_WIDGET (view));
	gtk_widget_grab_focus (GTK_WIDGET (view->text));
}


void
gedit_view_changed_cb (GnomeMDI *mdi, GtkWidget *old_view)
{
	GeditView *view = gedit_view_active();
	GeditDocument *doc = view->doc;
	gint undo_state, redo_state;

	gedit_debug (DEBUG_VIEW, "start");

	g_return_if_fail (view!=NULL);
		
	gtk_widget_grab_focus (GTK_WIDGET (view->text));
	gedit_document_set_title (view->doc);

	view->app = gedit_window_active_app();
	
	gedit_view_load_widgets (view);
	
	if (g_list_length(doc->undo) == 0)
		undo_state = GEDIT_UNDO_STATE_FALSE;
	else
		undo_state = GEDIT_UNDO_STATE_TRUE;
	if (g_list_length(doc->redo) == 0)
		redo_state = GEDIT_UNDO_STATE_FALSE;
	else
		redo_state = GEDIT_UNDO_STATE_TRUE;
	gedit_view_set_undo (view, undo_state, redo_state);
	gedit_view_set_undo (view, GEDIT_UNDO_STATE_REFRESH, GEDIT_UNDO_STATE_REFRESH);
	gnome_app_install_menu_hints(view->app, gnome_mdi_get_child_menu_info(view->app));

	gedit_window_set_view_menu_sensitivity (gedit_window_active_app());
	gedit_window_set_widgets_sensitivity_ro (gedit_window_active_app(), doc->readonly);

	gedit_debug (DEBUG_VIEW, "end");
}

void
gedit_view_text_changed_cb (GtkWidget *w, gpointer cbdata)
{
	GeditView *view;
	gchar* doc_name;
	
	gedit_debug (DEBUG_VIEW, "");

	view = GEDIT_VIEW (cbdata);
	g_return_if_fail (view != NULL);

	if (view->doc->changed)
		return;
	
	view->doc->changed = TRUE;

	/* Disconect this signal */
	gtk_signal_disconnect (GTK_OBJECT(view->text), (gint) view->view_text_changed_signal);

	/* Set the title ( so that we add the "modified" string to it )*/
	gedit_document_set_title (view->doc);
	
	doc_name = gedit_document_get_tab_name (view->doc, TRUE);
	gnome_mdi_child_set_name (GNOME_MDI_CHILD (view->doc), doc_name);
	g_free(doc_name);
}















GtkWidget *
gedit_view_new (GeditDocument *doc)
{
	GeditView *view;
	guchar *document_buffer;

	gedit_debug (DEBUG_VIEW, "");

	if (doc == NULL)
		return NULL;

	view = gtk_type_new (gedit_view_get_type ());

	view->app = NULL;
	view->doc = doc;
	doc->views = g_list_append (doc->views, view);

	if (g_list_length (doc->views) > 1) {
		document_buffer = gedit_document_get_buffer (view->doc);
		gedit_view_insert (view, 0, document_buffer, strlen (document_buffer));
		g_free (document_buffer);
	}

	return GTK_WIDGET (view);
}



/**
 * gedit_view_set_font:
 * @view: View that we're going to change the font for.
 * @fontname: String name "-b&h-lucida-blah-..." of the font to load
 *
 *
 **/
void
gedit_view_set_font (GeditView *view, gchar *fontname)
{
	GtkStyle *style;
	GdkFont *font = NULL;

	gedit_debug (DEBUG_VIEW, "");
	
	style = gtk_style_copy (gtk_widget_get_style (GTK_WIDGET((view)->text)));
  	
  	if (settings->use_fontset)
		font = gdk_fontset_load (fontname);
  	else
		font = gdk_font_load (fontname);

	if (font != NULL)
	{
		gdk_font_unref (style->font);
		style->font = font;
	}
	else
		g_warning ("Unable to load font ``%s''", fontname);

  	gtk_widget_set_style (GTK_WIDGET((view)->text), style);

	gtk_style_unref (style);
}



void
gedit_view_add_cb (GtkWidget *widget, gpointer data)
{
	GnomeMDIChild *child;
	GeditView *view;
	guchar * buffer;

	gedit_debug (DEBUG_VIEW, "");

	view = gedit_view_active();

	if (view)
	{
		view = gedit_view_active();
		buffer = gedit_document_get_buffer (view->doc);
		child = gnome_mdi_get_child_from_view (GTK_WIDGET(view));
		gnome_mdi_add_view (mdi, child);
		view = gedit_view_active();
		gedit_view_insert ( view, 0, buffer, strlen (buffer));
		/* Move the window to the top after inserting */
		gedit_view_set_window_position (view, 0);
		g_free (buffer);
		gedit_window_set_view_menu_sensitivity (gedit_window_active_app());
		gedit_window_set_widgets_sensitivity_ro (gedit_window_active_app(), view->doc->readonly);
	}

}

void
gedit_view_remove (GeditView *view)
{
	GeditDocument *doc;
	
	doc = view->doc;
	
	g_return_if_fail (doc != NULL);

	if (g_list_length (doc->views) < 2)
	{
		gnome_app_error (gedit_window_active_app(), _("You can't remove the last view of a document."));
		return;
	}

	/* First, we remove the view from the document's list */
	doc->views = g_list_remove (doc->views, view);

	/* Now, we can remove the view proper */
	gnome_mdi_remove_view (mdi, GTK_WIDGET(view), FALSE);
	
	gedit_document_set_title (doc);

	gedit_window_set_view_menu_sensitivity (gedit_window_active_app());
	gedit_window_set_widgets_sensitivity_ro (gedit_window_active_app(), doc->readonly);
}

void
gedit_view_remove_cb (GtkWidget *widget, gpointer data)
{
	GeditView *view;

	gedit_debug (DEBUG_VIEW, "");

	view = gedit_view_active();
	
	if (view == NULL)
		return;

	gedit_view_remove (view);
}



void
gedit_view_load_widgets (GeditView *view)
{
	GnomeUIInfo *toolbar_ui_info = NULL;
	GnomeUIInfo *menu_ui_info = NULL;
	gint count, sub_count;

	gedit_debug (DEBUG_VIEW, "");
	
	g_return_if_fail (view->app != NULL);

	toolbar_ui_info = gnome_mdi_get_toolbar_info (view->app);
	menu_ui_info	= gnome_mdi_get_menubar_info (view->app);
/*
	menu_ui_info    = gnome_mdi_get_child_menu_info (view->app);
*/
	g_return_if_fail (toolbar_ui_info != NULL);
	g_return_if_fail (menu_ui_info != NULL);

	if (!view->toolbar)
		view->toolbar = g_malloc (sizeof (GeditToolbar));
	
	view->toolbar->undo_button    = NULL;
	view->toolbar->redo_button    = NULL;
	view->toolbar->undo_menu_item = NULL;
	view->toolbar->redo_menu_item = NULL;
	
	count = 0;
	while (toolbar_ui_info[count].type != GNOME_APP_UI_ENDOFINFO)
	{
		if (toolbar_ui_info [count].moreinfo == gedit_undo_undo)
		{
			view->toolbar->undo_button = toolbar_ui_info[count].widget;
#if 0			
			g_print ("undo button found ..   count %i widget 0x%x  view 0x%x\n",
				 count,
				 (gint) toolbar_ui_info[count].widget,
				 (gint) view);
#endif			
		}
		if (toolbar_ui_info [count].moreinfo == gedit_undo_redo)
		{
			view->toolbar->redo_button = toolbar_ui_info[count].widget;
#if 0			
			g_print ("redo button found ..   count %i widget 0x%x view 0x%x\n",
				 count,
				 (gint) toolbar_ui_info[count].widget,
				 (gint) view);
#endif			
		}
		count++;
	}
	count = 0;
	while (menu_ui_info[count].type != GNOME_APP_UI_ENDOFINFO)
	{
		/* FIXME: The correct way to do this is to do recurse the find function
		   Chema.*/
		if (menu_ui_info[count].type == GNOME_APP_UI_SUBTREE_STOCK ||
		    menu_ui_info[count].type == GNOME_APP_UI_SUBTREE)
		{
			GnomeUIInfo *sub_menu_ui_info = menu_ui_info[count].moreinfo;
			sub_count = 0;
			while (sub_menu_ui_info[sub_count].type != GNOME_APP_UI_ENDOFINFO)
			{
				if (sub_menu_ui_info [sub_count].moreinfo == gedit_undo_undo)
				{
					view->toolbar->undo_menu_item = sub_menu_ui_info[sub_count].widget;
					g_return_if_fail (GTK_IS_WIDGET(view->toolbar->undo_menu_item));
#if 0					
					g_print ("<-undo menu item Widget 0x%x      view 0x%x toolbar: 0x%x\n",
						 (gint) view->toolbar->undo_menu_item,
						 (gint) view,
						 (gint) view->toolbar);
#endif					
				}
				if (sub_menu_ui_info [sub_count].moreinfo == gedit_undo_redo)
				{
					view->toolbar->redo_menu_item = sub_menu_ui_info[sub_count].widget;
					g_return_if_fail (GTK_IS_WIDGET(view->toolbar->redo_menu_item));
#if 0					
					g_print ("<-redo menu item found count %i widget 0x%x view 0x%x toolbar: 0x%x\n",
						 sub_count,
						 (gint) view->toolbar->redo_menu_item,
						 (gint) view,
						 (gint) view->toolbar);
#endif					
				}
				sub_count++;
			}
		}
		else
		{
			g_warning ("BORK !\n");
			if (menu_ui_info [count].moreinfo == gedit_undo_undo)
				view->toolbar->undo_menu_item = menu_ui_info[count].widget;
			if (menu_ui_info [count].moreinfo == gedit_undo_redo)
				view->toolbar->redo_menu_item = menu_ui_info[count].widget;
		}
		count++;
	}

	g_return_if_fail (view->toolbar->undo_button != NULL);
	g_return_if_fail (view->toolbar->redo_button != NULL);
	g_return_if_fail (view->toolbar->undo_menu_item != NULL);
	g_return_if_fail (view->toolbar->redo_menu_item != NULL);
}

void
gedit_view_set_undo (GeditView *view, gint undo_state, gint redo_state)
{
	gedit_debug (DEBUG_VIEW, "");

#if 0
	g_print ("\nSet_undo. view:0x%x Widget: 0x%x  UNDO:%i  REDO:%i\n",
		 (gint) view,
		 (gint) view->toolbar->undo_menu_item,
		 undo_state,
		 redo_state);
#endif	
	g_return_if_fail (view != NULL);
	g_return_if_fail (view->toolbar != NULL);
	g_return_if_fail (view->toolbar->undo_button != NULL);
	g_return_if_fail (view->toolbar->redo_button != NULL);
	g_return_if_fail (view->toolbar->undo_menu_item != NULL);
	g_return_if_fail (view->toolbar->redo_menu_item != NULL);
	g_return_if_fail (GTK_IS_WIDGET (view->toolbar->undo_button));
	g_return_if_fail (GTK_IS_WIDGET (view->toolbar->redo_button));
	g_return_if_fail (GTK_IS_WIDGET (view->toolbar->undo_menu_item));
	g_return_if_fail (GTK_IS_WIDGET (view->toolbar->redo_menu_item));
		 
/*
  g_print ("Undo->button %i Redo->menu_button %i\n",
		 (guint) view->toolbar->undo_button,
		 (guint) view->toolbar->redo_button);
	g_print ("Undo->menu_item %i Redo->menu_item %i\n",
		 (guint) view->toolbar->undo_menu_item,
		 (guint) view->toolbar->redo_menu_item);
	g_print ("undo state %i redo state %i\n", undo_state, redo_state);
	g_print ("view->toolbar->undo:%i view->toolbar->redo:%i FALSE:%i TRUE:%i\n\n\n",
		 view->toolbar->undo,
		 view->toolbar->redo,
		 FALSE, TRUE);
*/

	/* Set undo */
	switch (undo_state)
	{
	case GEDIT_UNDO_STATE_TRUE:
		if (!view->toolbar->undo)
		{
			view->toolbar->undo = TRUE;
			gtk_widget_set_sensitive (view->toolbar->undo_button, TRUE);
			gtk_widget_set_sensitive (view->toolbar->undo_menu_item, TRUE);
		}
		break;
	case GEDIT_UNDO_STATE_FALSE:
		if (view->toolbar->undo)
		{
			view->toolbar->undo = FALSE;
			gtk_widget_set_sensitive (view->toolbar->undo_button, FALSE);
			gtk_widget_set_sensitive (view->toolbar->undo_menu_item, FALSE);
		}
		break;
	case GEDIT_UNDO_STATE_UNCHANGED:
		break;
	case GEDIT_UNDO_STATE_REFRESH:
		gtk_widget_set_sensitive (view->toolbar->undo_button, view->toolbar->undo);
		gtk_widget_set_sensitive (view->toolbar->undo_menu_item, view->toolbar->undo);
		break;
	default:
		g_warning ("Undo state not recognized");
	}
	
	/* Set redo*/
	switch (redo_state)
	{
	case GEDIT_UNDO_STATE_TRUE:
		if (!view->toolbar->redo)
		{
			view->toolbar->redo = TRUE;
			gtk_widget_set_sensitive (view->toolbar->redo_button, TRUE);
			gtk_widget_set_sensitive (view->toolbar->redo_menu_item, TRUE);
		}
		break;
	case GEDIT_UNDO_STATE_FALSE:
		if (view->toolbar->redo)
		{
			view->toolbar->redo = FALSE;
			gtk_widget_set_sensitive (view->toolbar->redo_button, FALSE);
			gtk_widget_set_sensitive (view->toolbar->redo_menu_item, FALSE);
		}
		break;
	case GEDIT_UNDO_STATE_UNCHANGED:
		break;
	case GEDIT_UNDO_STATE_REFRESH:
		gtk_widget_set_sensitive (view->toolbar->redo_button, view->toolbar->redo);
		gtk_widget_set_sensitive (view->toolbar->redo_menu_item, view->toolbar->redo);
		break;
	default:
		g_warning ("Redo state not recognized");
	}
}
		

/**
 * gedit_view_set_tab_size:
 * @view: 
 * @tab_size: 
 * 
 * Set the gtk_text tab size
 **/
void
gedit_view_set_tab_size (GeditView *view, gint tab_size)
{
	GList *l;
	gint i;

	g_return_if_fail (GEDIT_IS_VIEW (view));

	l = GTK_TEXT (view->text)->tab_stops;
	g_list_free (l);
		
	l = NULL;
	for (i = 0; i < 50; i++)
		l = g_list_prepend (l, GINT_TO_POINTER (tab_size));
	GTK_TEXT (view->text)->tab_stops = l;

}