* This file is part of pluma

*

* Copyright (C) 1998, 1999 Alex Roberts, Evan Lawrence

*

* 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

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

/*

* See the ChangeLog files for a list of changes.

*

*/

#ifdef HAVE_CONFIG_H

struct _PlumaViewPrivate

{

SearchMode search_mode;

GtkTextIter start_search_iter;

/* used to restore the search state if an

guint typeselect_flush_timeout;

guint search_entry_changed_id;

gboolean disable_popdown;

GtkTextBuffer *current_buffer;

};

} PlumaSearchEntryState;

static void

GParamSpec *pspec,

PlumaView *view)

{

pluma_debug (DEBUG_VIEW);

!pluma_document_get_readonly (document));

}

GObjectClass *object_class = G_OBJECT_CLASS (klass);

GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

GtkTextViewClass *text_view_class = GTK_TEXT_VIEW_CLASS (klass);

GtkBindingSet *binding_set;

object_class->dispose = pluma_view_dispose;

widget_class->focus_out_event = pluma_view_focus_out;

widget_class->draw = pluma_view_draw;

widget_class->scroll_event = pluma_view_scroll_event;

/*

* Override the gtk_text_view_drag_motion and drag_drop

* functions to get URIs

text_view_class->populate_popup = pluma_view_populate_popup;

klass->start_interactive_search = start_interactive_search;

klass->start_interactive_goto_line = start_interactive_goto_line;

text_view_class->delete_from_cursor = pluma_view_delete_from_cursor;

view_signals[START_INTERACTIVE_SEARCH] =

g_signal_new ("start_interactive_search",

G_TYPE_FROM_CLASS (object_class),

G_STRUCT_OFFSET (PlumaViewClass, start_interactive_search),

NULL, NULL,

pluma_marshal_BOOLEAN__VOID,

view_signals[START_INTERACTIVE_GOTO_LINE] =

g_signal_new ("start_interactive_goto_line",

G_STRUCT_OFFSET (PlumaViewClass, reset_searched_text),

NULL, NULL,

pluma_marshal_BOOLEAN__VOID,

/* A new signal DROP_URIS has been added to allow plugins to intercept

* the default dnd behaviour of 'text/uri-list'. PlumaView now handles

* drag_data_received. The view emits drop_uris from drag_data_received

* default behaviour. They should _NOT_ use this signal because this

* will not prevent pluma from loading the uri

*/

NULL, NULL,

g_cclosure_marshal_VOID__BOXED,

G_TYPE_NONE, 1, G_TYPE_STRV);

g_type_class_add_private (klass, sizeof (PlumaViewPrivate));

binding_set = gtk_binding_set_by_class (klass);

gtk_binding_entry_add_signal (binding_set,

GDK_KEY_k,

GDK_CONTROL_MASK,

"start_interactive_search", 0);

gtk_binding_entry_add_signal (binding_set,

GDK_KEY_i,

GDK_CONTROL_MASK,

"start_interactive_goto_line", 0);

gtk_binding_entry_add_signal (binding_set,

GDK_KEY_k,

GDK_CONTROL_MASK | GDK_SHIFT_MASK,

"reset_searched_text", 0);

GDK_KEY_d,

GDK_CONTROL_MASK,

"delete_from_cursor", 2,

g_signal_handlers_disconnect_by_func (view->priv->current_buffer,

search_highlight_updated_cb,

view);

g_object_unref (view->priv->current_buffer);

view->priv->current_buffer = NULL;

}

gpointer userdata)

{

GtkTextBuffer *buffer;

current_buffer_removed (view);

buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));

if (buffer == NULL || !PLUMA_IS_DOCUMENT (buffer))

return;

G_CALLBACK (document_read_only_notify_handler),

view);

!pluma_document_get_readonly (PLUMA_DOCUMENT (buffer)));

g_signal_connect (buffer,

}

#endif

pluma_view_init (PlumaView *view)

{

GtkTargetList *tl;

pluma_debug (DEBUG_VIEW);

view->priv = PLUMA_VIEW_GET_PRIVATE (view);

/*

* Set tab, fonts, wrap mode, colors, etc. according

*/

if (!pluma_prefs_manager_get_use_default_font ())

{

pluma_view_set_font (view, TRUE, NULL);

}

"wrap_mode", pluma_prefs_manager_get_wrap_mode (),

"show_line_numbers", pluma_prefs_manager_get_display_line_numbers (),

"auto_indent", pluma_prefs_manager_get_auto_indent (),

"tab_width", pluma_prefs_manager_get_tabs_size (),

"insert_spaces_instead_of_tabs", pluma_prefs_manager_get_insert_spaces (),

"right_margin_position", pluma_prefs_manager_get_right_margin_position (),

"highlight_current_line", pluma_prefs_manager_get_highlight_current_line (),

"smart_home_end", pluma_prefs_manager_get_smart_home_end (),

view->priv->typeselect_flush_timeout = 0;

view->priv->wrap_around = TRUE;

tl = gtk_drag_dest_get_target_list (GTK_WIDGET (view));

if (tl != NULL)

gtk_target_list_add_uri_targets (tl, TARGET_URI_LIST);

/* Act on buffer change */

G_CALLBACK (on_notify_buffer_cb),

NULL);

}

gtk_widget_destroy (view->priv->search_window);

view->priv->search_window = NULL;

view->priv->search_entry = NULL;

if (view->priv->typeselect_flush_timeout != 0)

{

g_source_remove (view->priv->typeselect_flush_timeout);

view->priv->typeselect_flush_timeout = 0;

}

}

/* Disconnect notify buffer because the destroy of the textview will

set the buffer to NULL, and we call get_buffer in the notify which

would reinstate a GtkTextBuffer which we don't want */

current_buffer_removed (view);

g_signal_handlers_disconnect_by_func (view, on_notify_buffer_cb, NULL);

(* G_OBJECT_CLASS (pluma_view_parent_class)->dispose) (object);

}

pluma_view_focus_out (GtkWidget *widget, GdkEventFocus *event)

{

PlumaView *view = PLUMA_VIEW (widget);

gtk_widget_queue_draw (widget);

/* hide interactive search dialog */

if (view->priv->search_window != NULL)

hide_search_window (view, FALSE);

(* GTK_WIDGET_CLASS (pluma_view_parent_class)->focus_out_event) (widget, event);

return FALSE;

}

/**

* pluma_view_new:

* @doc: a #PlumaDocument

* @doc cannot be %NULL.

*

* Return value: a new #PlumaView

clipboard,

!pluma_document_get_readonly (

PLUMA_DOCUMENT (buffer)));

gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),

gtk_text_buffer_get_insert (buffer),

PLUMA_VIEW_SCROLL_MARGIN,

/**

* pluma_view_delete_selection:

* @view: a #PlumaView

* Deletes the text currently selected in the #GtkTextBuffer associated

* to the view and scroll to the cursor position.

**/

TRUE,

!pluma_document_get_readonly (

PLUMA_DOCUMENT (buffer)));

gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),

gtk_text_buffer_get_insert (buffer),

PLUMA_VIEW_SCROLL_MARGIN,

/**

* pluma_view_select_all:

* @view: a #PlumaView

* Selects all the text displayed in the @view.

**/

void

/**

* pluma_view_scroll_to_cursor:

* @view: a #PlumaView

* Scrolls the @view to the cursor position.

**/

void

pluma_debug (DEBUG_VIEW);

g_return_if_fail (PLUMA_IS_VIEW (view));

buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));

g_return_if_fail (buffer != NULL);

* @view: a #PlumaView

* @def: whether to reset the default font

* @font_name: the name of the font to use

* If @def is #TRUE, resets the font of the @view to the default font

* otherwise sets it to @font_name.

**/

void

const gchar *font_name)

{

PangoFontDescription *font_desc = NULL;

pango_font_description_free (sys_font_desc);

}

}

static void

g_return_if_fail (GTK_IS_TREE_MODEL (search_completion_model));

/* Get the first iter in the list */

valid = gtk_tree_model_get_iter_first (model, &iter);

/* Walk through the list, reading each row */

gchar *str_data;

&str_data,

-1);

{

GtkTextIter start_iter;

GtkTextIter match_start;

gboolean found = FALSE;

PlumaDocument *doc;

g_return_val_if_fail (view->priv->search_mode == SEARCH, FALSE);

doc = PLUMA_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));

start_iter = view->priv->start_search_iter;

if (*entry_text != '\0')

if (!search_backward)

{

if (!typing)

gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),

&start_iter,

&match_end);

gtk_text_iter_order (&match_end, &start_iter);

}

/* run search */

found = pluma_document_search_forward (doc,

&start_iter,

NULL,

&match_start,

&match_end);

else if (!typing)

{

/* backward and not typing */

gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),

&start_iter,

&match_end);

/* run search */

found = pluma_document_search_backward (doc,

NULL,

&start_iter,

&match_start,

&match_end);

else

{

/* backward (while typing) */

g_return_val_if_reached (FALSE);

}

if (!found && wrap_around)

{

if (!search_backward)

else

found = pluma_document_search_backward (doc,

NULL, /* FIXME: set the start_inter */

&match_start,

&match_end);

}

else

{

gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),

if (found)

{

gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc),

&view->priv->start_search_iter);

}

}

if (found || (*entry_text == '\0'))

pluma_view_scroll_to_cursor (view);

set_entry_state (view->priv->search_entry,

fevent->focus_change.type = GDK_FOCUS_CHANGE;

fevent->focus_change.window = g_object_ref (gtk_widget_get_window (widget));

fevent->focus_change.in = in;

gtk_widget_event (widget, fevent);

g_object_notify (G_OBJECT (widget), "has-focus");

g_object_unref (widget);

send_focus_change (GTK_WIDGET (view->priv->search_entry), FALSE);

gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), TRUE);

gtk_widget_hide (view->priv->search_window);

if (cancel)

{

GtkTextBuffer *buffer;

buffer = GTK_TEXT_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));

gtk_text_buffer_place_cursor (buffer, &view->priv->start_search_iter);

pluma_view_scroll_to_cursor (view);

}

gtk_widget_realize (view->priv->search_window);

gdk_window_get_origin (view_window, &view_x, &view_y);

x = MAX (12, view_x + 12);

y = MAX (12, view_y - 12);

gtk_window_move (GTK_WINDOW (view->priv->search_window), x, y);

}

PlumaView *view)

{

hide_search_window (view, FALSE);

gtk_propagate_event (GTK_WIDGET (view), (GdkEvent *)event);

return FALSE;

const gchar *entry_text;

g_return_if_fail (view->priv->search_mode == SEARCH);

/* renew the flush timeout */

if (view->priv->typeselect_flush_timeout != 0)

{

(GSourceFunc)search_entry_flush_timeout,

view);

}

entry_text = gtk_entry_get_text (GTK_ENTRY (view->priv->search_entry));

add_search_completion_entry (entry_text);

run_search (view,

entry_text,

search_backward,

if (view->priv->search_mode == GOTO_LINE)

return retval;

if (event->direction == GDK_SCROLL_UP)

{

search_again (view, TRUE);

/* restore document search so that Find Next does the right thing */

doc = PLUMA_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));

view->priv->old_search_text,

view->priv->old_search_flags);

}

hide_search_window (view, TRUE);

retval = TRUE;

}

if (view->priv->search_mode == GOTO_LINE)

return retval;

/* SEARCH mode */

/* select previous matching iter */

retval = TRUE;

}

(event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))

{

search_again (view, TRUE);

retval = TRUE;

}

(event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))

{

search_again (view, FALSE);

static void

wrap_around_menu_item_toggled (GtkCheckMenuItem *checkmenuitem,

PlumaView *view)

view->priv->wrap_around = gtk_check_menu_item_get_active (checkmenuitem);

}

PlumaView *view)

{

g_timeout_add (200, real_search_enable_popdown, view);

/* renew the flush timeout */

if (view->priv->typeselect_flush_timeout != 0)

g_source_remove (view->priv->typeselect_flush_timeout);

/* create "Wrap Around" menu item. */

menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Wrap Around"));

g_signal_connect (G_OBJECT (menu_item), "toggled",

view);

gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);

gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),

/* create "Match Entire Word Only" menu item. */

menu_item = gtk_check_menu_item_new_with_mnemonic (_("Match _Entire Word Only"));

g_signal_connect (G_OBJECT (menu_item), "toggled",

view);

gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);

gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),

/* create "Match Case" menu item. */

menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Match Case"));

g_signal_connect (G_OBJECT (menu_item), "toggled",

view);

gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);

gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),

/* create "Parse escapes" menu item. */

menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Parse escape sequences (e.g. \n)"));

g_signal_connect (G_OBJECT (menu_item), "toggled",

view);

gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);

gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),

}

static void

gint *position,

PlumaView *view)

{

return;

c = g_utf8_get_char (p);

if (((c == '-' || c == '+') && *position == 0) ||

(c == ':' && *position != 0))

{

gchar *s = NULL;

if (c == ':')

{

s = gtk_editable_get_chars (editable, 0, -1);

s = g_utf8_strchr (s, -1, ':');

}

if (s == NULL || s == p)

{

next = g_utf8_next_char (p);

p = next;

}

g_free (s);

}

insert_text = TRUE;

g_signal_stop_emission_by_name (editable, "insert_text");

gtk_editable_insert_text (editable, escaped_text, new_len, position);

insert_text = FALSE;

gtk_entry_set_icon_from_icon_name (GTK_ENTRY (view->priv->search_entry),

GTK_ENTRY_ICON_PRIMARY,

"edit-find");

gtk_widget_set_tooltip_text (view->priv->search_entry,

_("String you want to search for"));

}

gtk_entry_set_icon_from_icon_name (GTK_ENTRY (view->priv->search_entry),

GTK_ENTRY_ICON_PRIMARY,

"go-jump");

gtk_widget_set_tooltip_text (view->priv->search_entry,

_("Line you want to move the cursor to"));

}

GtkTreeModel *model;

PlumaViewPrivate *priv = (PlumaViewPrivate *)data;

const gchar *real_key;

if (priv->search_mode == GOTO_LINE)

return FALSE;

real_key = gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry (completion)));

if (g_utf8_strlen (real_key, -1) <= MIN_SEARCH_COMPLETION_KEY_LEN)

return FALSE;

model = gtk_entry_completion_get_model (completion);

FALSE);

iter,

&item,

-1);

if (item == NULL)

return FALSE;

if (PLUMA_SEARCH_IS_CASE_SENSITIVE (priv->search_flags))

if (!strncmp (real_key, item, strlen (real_key)))

ret = TRUE;

}

{

gchar *normalized_string;

gchar *case_normalized_string;

normalized_string = g_utf8_normalize (item, -1, G_NORMALIZE_ALL);

case_normalized_string = g_utf8_casefold (normalized_string, -1);

if (!strncmp (key, case_normalized_string, strlen (key)))

ret = TRUE;

g_free (normalized_string);

g_free (case_normalized_string);

}

g_free (item);

}

static void

ensure_search_window (PlumaView *view)

GtkWidget *frame;

GtkWidget *vbox;

GtkWidget *toplevel;

GtkEntryCompletion *completion;

GtkWindowGroup *group;

GtkWindowGroup *search_group;

toplevel = gtk_widget_get_toplevel (GTK_WIDGET (view));

group = gtk_window_get_group (GTK_WINDOW (toplevel));

if (view->priv->search_window != NULL)

else if (search_group)

gtk_window_group_remove_window (search_group,

GTK_WINDOW (view->priv->search_window));

customize_for_search_mode (view);

return;

}

view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);

if (group)

gtk_window_group_add_window (group,

GTK_WINDOW (view->priv->search_window));

gtk_window_set_modal (GTK_WINDOW (view->priv->search_window), TRUE);

g_signal_connect (view->priv->search_window, "delete_event",

G_CALLBACK (search_window_delete_event),

view);

/* add entry */

view->priv->search_entry = gtk_entry_new ();

gtk_widget_show (view->priv->search_entry);

g_signal_connect (view->priv->search_entry, "populate_popup",

G_CALLBACK (search_entry_populate_popup),

view);

G_CALLBACK (search_entry_activate),

view);

"insert_text",

gtk_container_add (GTK_CONTAINER (vbox),

view->priv->search_entry);

/* Create a tree model and use it as the completion model */

search_completion_model = gtk_list_store_new (1, G_TYPE_STRING);

}

/* Create the completion object for the search entry */

completion = gtk_entry_completion_new ();

GTK_TREE_MODEL (search_completion_model));

/* Use model column 0 as the text column */

gtk_entry_completion_set_text_column (completion, 0);

gtk_entry_completion_set_popup_completion (completion, FALSE);

gtk_entry_completion_set_inline_completion (completion, TRUE);

completion_func,

view->priv,

NULL);

/* Assign the completion to the entry */

completion);

g_object_unref (completion);

gtk_widget_realize (view->priv->search_entry);

}

static gboolean

init_search_entry (PlumaView *view)

{

GtkTextBuffer *buffer;

buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));

if (view->priv->search_mode == GOTO_LINE)

gint line;

gchar *line_str;

line = gtk_text_iter_get_line (&view->priv->start_search_iter);

line_str = g_strdup_printf ("%d", line + 1);

line_str);

g_free (line_str);

return;

}

else

guint old_find_flags = 0;

gint sel_len = 0;

&old_find_flags);

if (old_find_text != NULL)

{

view->priv->old_search_flags = old_find_flags;

}

&sel_len);

if (selection_exists && (find_text != NULL) && (sel_len <= 160))

{

}

else

{

"");

}

g_free (find_text);

}

}

(GSourceFunc)search_entry_flush_timeout,

view);

}

doc = PLUMA_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));

entry_text = gtk_entry_get_text (GTK_ENTRY (entry));

if (view->priv->search_mode == SEARCH)

{

gchar *search_text;

(strcmp (search_text, entry_text) != 0) ||

search_flags != view->priv->search_flags)

{

entry_text,

view->priv->search_flags);

}

gint line_offset = 0;

gchar **split_text = NULL;

const gchar *text;

split_text = g_strsplit (entry_text, ":", -1);

if (g_strv_length (split_text) > 1)

{

text = split_text[0];

{

text = entry_text;

}

if (*text == '-')

{

gint cur_line = gtk_text_iter_get_line (&view->priv->start_search_iter);

if (*(text + 1) != '\0')

offset_line = MAX (atoi (text + 1), 0);

line = MAX (cur_line - offset_line, 0);

}

else if (*entry_text == '+')

{

gint cur_line = gtk_text_iter_get_line (&view->priv->start_search_iter);

if (*(text + 1) != '\0')

offset_line = MAX (atoi (text + 1), 0);

line = cur_line + offset_line;

}

else

{

line = MAX (atoi (text) - 1, 0);

}

if (split_text[1] != NULL)

{

line_offset = atoi (split_text[1]);

}

g_strfreev (split_text);

moved = pluma_document_goto_line (doc, line);

moved_offset = pluma_document_goto_line_offset (doc, line,

line_offset);

pluma_view_scroll_to_cursor (view);

if (!moved || !moved_offset)

static gboolean

start_interactive_search_real (PlumaView *view)

GtkTextBuffer *buffer;

if ((view->priv->search_window != NULL) &&

gtk_widget_get_visible (view->priv->search_window))

return TRUE;

init_search_entry (view);

g_timeout_add (PLUMA_VIEW_SEARCH_DIALOG_TIMEOUT,

(GSourceFunc) search_entry_flush_timeout,

view);

gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE);

gtk_widget_grab_focus (view->priv->search_entry);

send_focus_change (view->priv->search_entry, TRUE);

return TRUE;

}

static gboolean

reset_searched_text (PlumaView *view)

PlumaDocument *doc;

doc = PLUMA_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));

pluma_document_set_search_text (doc, "", PLUMA_SEARCH_DONT_SET_FLAGS);

return TRUE;

}

static gboolean

start_interactive_search (PlumaView *view)

view->priv->search_mode = SEARCH;

return start_interactive_search_real (view);

}

start_interactive_goto_line (PlumaView *view)

{

view->priv->search_mode = GOTO_LINE;

return start_interactive_search_real (view);

}

GtkTextView *text_view;

PlumaDocument *doc;

GdkWindow *window;

text_view = GTK_TEXT_VIEW (widget);

doc = PLUMA_DOCUMENT (gtk_text_view_get_buffer (text_view));

window = gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT);

if (gtk_cairo_should_draw_window (cr, window) &&

{

GdkRectangle visible_rect;

GtkTextIter iter1, iter2;

gtk_text_view_get_visible_rect (text_view, &visible_rect);

gtk_text_view_get_line_at_y (text_view, &iter1,

visible_rect.y, NULL);

visible_rect.y

+ visible_rect.height, NULL);

gtk_text_iter_forward_line (&iter2);

_pluma_document_search_region (doc,

&iter1,

&iter2);

{

GdkAtom target;

GtkTargetList *tl;

tl = gtk_target_list_new (NULL, 0);

gtk_target_list_add_uri_targets (tl, 0);

target = gtk_drag_dest_find_target (widget, context, tl);

gtk_target_list_unref (tl);

}

static gboolean

{

gboolean result;

* that this needs to be checked if gtksourceview or gtktextview

* changes drag_motion behaviour */

result = GTK_WIDGET_CLASS (pluma_view_parent_class)->drag_motion (widget, context, x, y, timestamp);

/* If this is a URL, deal with it here */

{

gdk_drag_status (context,

gdk_drag_context_get_suggested_action (context),

guint timestamp)

{

gchar **uri_list;

/* If this is an URL emit DROP_URIS, otherwise chain up the signal */

if (info == TARGET_URI_LIST)

{

uri_list = pluma_utils_drop_get_uris (selection_data);

if (uri_list != NULL)

{

g_signal_emit (widget, view_signals[DROP_URIS], 0, uri_list);

g_strfreev (uri_list);

gtk_drag_finish (context, TRUE, FALSE, timestamp);

}

}

g_signal_connect (item, "toggled",

G_CALLBACK (show_line_numbers_toggled), view);

gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

gtk_widget_show_all (menu);

return menu;

}

else

gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_PRIMARY), primtxt, strlen (primtxt));

(event->window == gtk_text_view_get_window (GTK_TEXT_VIEW (widget),

GTK_TEXT_WINDOW_LEFT)))

{

middle_or_right_down = FALSE;

}

search_highlight_updated_cb (PlumaDocument *doc,

GtkTextIter *start,

GtkTextIter *end,

PlumaView *view)

{

GdkRectangle visible_rect;

GdkRectangle redraw_rect;

gint y;

gint height;

GtkTextView *text_view;

text_view = GTK_TEXT_VIEW (view);

g_return_if_fail (pluma_document_get_enable_search_highlighting (

PLUMA_DOCUMENT (gtk_text_view_get_buffer (text_view))));

/* get visible area */

gtk_text_view_get_visible_rect (text_view, &visible_rect);

/* get updated rectangle */

gtk_text_view_get_line_yrange (text_view, start, &y, &height);

updated_rect.y = y;

updated_rect.width = visible_rect.width;

/* intersect both rectangles to see whether we need to queue a redraw */

{

GdkRectangle widget_rect;

gtk_text_view_buffer_to_window_coords (text_view,

GTK_TEXT_WINDOW_WIDGET,

redraw_rect.x,

redraw_rect.y,

&widget_rect.x,

&widget_rect.y);

widget_rect.width = redraw_rect.width;

widget_rect.height = redraw_rect.height;

gtk_widget_queue_draw_area (GTK_WIDGET (text_view),

widget_rect.x,

widget_rect.y,

if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))

{

gtk_text_iter_order (&start, &end);

if (gtk_text_iter_starts_line (&end))

{

/* Do no delete the line with the cursor if the cursor

* is at the beginning of the line */

count = 0;

}

count = 1;

}

gtk_text_iter_set_line_offset (&start, 0);

if (count > 0)

gtk_text_iter_forward_lines (&end, count);

if (gtk_text_iter_is_end (&end))

if (gtk_text_iter_backward_line (&start) && !gtk_text_iter_ends_line (&start))

gtk_text_iter_forward_to_line_end (&start);

}

}

{

if (!gtk_text_iter_ends_line (&end))

gtk_text_iter_forward_to_line_end (&end);

{

if (!gtk_text_iter_backward_line (&start))

break;

++count;

}

{

GtkTextIter cur = start;

gtk_text_iter_set_line_offset (&cur, 0);

gtk_text_buffer_begin_user_action (buffer);

gtk_text_buffer_place_cursor (buffer, &cur);

&start,

&end,

gtk_text_view_get_editable (text_view));