static void
select_range (Movement *mv,
GtkTextIter *insert_iter,
GtkTextIter *selection_iter)
{
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextMark *selection;
gint insert_off;
gint selection_off;
g_assert (insert_iter);
g_assert (selection_iter);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
insert = gtk_text_buffer_get_insert (buffer);
selection = gtk_text_buffer_get_selection_bound (buffer);
mv->ignore_select = TRUE;
/*
* If the caller is requesting that we select a single character, we will
* keep the iter before that character. This more closely matches the visual
* mode in VIM.
*/
insert_off = gtk_text_iter_get_offset (insert_iter);
selection_off = gtk_text_iter_get_offset (selection_iter);
if ((insert_off - selection_off) == 1)
gtk_text_iter_order (insert_iter, selection_iter);
gtk_text_buffer_move_mark (buffer, insert, insert_iter);
gtk_text_buffer_move_mark (buffer, selection, selection_iter);
}
static void cb_focus_event(GtkWidget *view, GdkEventFocus *event)
{
if (!gtk_text_buffer_get_selection_bounds(GTK_TEXT_VIEW(view)->buffer, NULL, NULL))
gtk_text_mark_set_visible(
gtk_text_buffer_get_selection_bound(
GTK_TEXT_VIEW(view)->buffer), !event->in);
if (event->in)
menu_sensitivity_from_clipboard();
}
/* It is recommended to use this function with 2.4 and up. For
* earlier versions, we define it ourselves.
*/
void
gtk_text_buffer_select_range (GtkTextBuffer *text_buffer,
GtkTextIter *insertion_iterator,
GtkTextIter *bound_iterator)
{
gtk_text_buffer_move_mark (text_buffer,
gtk_text_buffer_get_insert (text_buffer),
insertion_iterator);
gtk_text_buffer_move_mark (text_buffer,
gtk_text_buffer_get_selection_bound (text_buffer),
bound_iterator);
}
static void
ensure_anchor_selected (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *selection_mark;
GtkTextMark *insert_mark;
GtkTextIter anchor_begin;
GtkTextIter anchor_end;
GtkTextIter insert_iter;
GtkTextIter selection_iter;
GtkTextMark *selection_anchor_begin;
GtkTextMark *selection_anchor_end;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
selection_anchor_begin = gtk_text_buffer_get_mark (buffer, ANCHOR_BEGIN);
selection_anchor_end = gtk_text_buffer_get_mark (buffer, ANCHOR_END);
if (!selection_anchor_begin || !selection_anchor_end)
return;
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_begin, selection_anchor_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_end, selection_anchor_end);
insert_mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &insert_iter, insert_mark);
selection_mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &selection_iter, selection_mark);
if ((gtk_text_iter_compare (&selection_iter, &anchor_end) < 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_end) < 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &insert_iter, &anchor_end);
else
select_range (mv, &anchor_end, &selection_iter);
}
else if ((gtk_text_iter_compare (&selection_iter, &anchor_begin) > 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_begin) > 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &anchor_begin, &selection_iter);
else
select_range (mv, &insert_iter, &anchor_begin);
}
}
static void
ide_source_view_movements_get_selection (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *mark;
g_assert (mv);
g_assert (IDE_IS_SOURCE_VIEW (mv->self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &mv->insert, mark);
mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &mv->selection, mark);
}
static void
ide_editor_view__buffer_cursor_moved (IdeEditorView *self,
const GtkTextIter *iter,
GtkTextBuffer *buffer)
{
GtkTextIter bounds;
GtkTextMark *mark;
gchar *str;
guint line;
gint column;
gint column2;
g_assert (IDE_IS_EDITOR_VIEW (self));
g_assert (iter != NULL);
g_assert (IDE_IS_BUFFER (buffer));
ide_source_view_get_visual_position (self->frame1->source_view, &line, (guint *)&column);
mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &bounds, mark);
if (!gtk_widget_has_focus (GTK_WIDGET (self->frame1->source_view)) ||
gtk_text_iter_equal (&bounds, iter) ||
(gtk_text_iter_get_line (iter) != gtk_text_iter_get_line (&bounds)))
{
str = g_strdup_printf ("%d:%d", line + 1, column + 1);
gtk_label_set_text (self->cursor_label, str);
g_free (str);
return;
}
/* We have a selection that is on the same line.
* Lets give some detail as to how long the selection is.
*/
column2 = gtk_source_view_get_visual_column (GTK_SOURCE_VIEW (self->frame1->source_view),
&bounds);
str = g_strdup_printf ("%d:%d (%d)", line + 1, column + 1, ABS (column2 - column));
gtk_label_set_text (self->cursor_label, str);
g_free (str);
}
static void cb_button_ok(GtkButton *button, gpointer user_data)
{
u_int64_t pharr8[MAX_PHRASE_LEN];
int i;
for(i=0; i < bigphoN; i++) {
int idx = gtk_combo_box_get_active(GTK_COMBO_BOX(bigpho[i].opt_menu));
void *dest = get_ph_key_ptr(pharr8, i);
cp_ph_key(bigpho[i].phokeys, idx, dest);
}
save_phrase_to_db(pharr8, current_str, bigphoN, 0);
destroy_pho_sel_area();
GtkTextMark *selebound = gtk_text_buffer_get_selection_bound(buffer);
gtk_text_mark_set_visible(selebound, FALSE);
cb_button_parse(NULL, NULL);
}
void
InfoWinDrawInfoText(const char *str)
{
GtkTextBuffer *buf;
GtkTextIter iter;
gint len;
GtkTextMark *mark;
if (str == NULL)
return;
if (NgraphApp.InfoWin.Win == NULL) {
return;
}
if (NgraphApp.InfoWin.data.text == NULL) {
return;
}
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(NgraphApp.InfoWin.data.text));
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_insert(buf, &iter, str, -1);
len = gtk_text_buffer_get_line_count(buf);
if (len > Menulocal.info_size) {
GtkTextIter start, end;
gtk_text_buffer_get_start_iter(buf, &start);
gtk_text_buffer_get_iter_at_line(buf, &end, len - Menulocal.info_size);
gtk_text_buffer_delete(buf, &start, &end);
}
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_place_cursor(buf, &iter);
mark = gtk_text_buffer_get_selection_bound(buf);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(NgraphApp.InfoWin.data.text), mark);
}
static gboolean
parasite_python_shell_key_press_cb(GtkWidget *textview,
GdkEventKey *event,
GtkWidget *python_shell)
{
if (event->keyval == GDK_Return)
{
parasite_python_shell_process_line(python_shell);
return TRUE;
}
else if (event->keyval == GDK_Up)
{
parasite_python_shell_replace_input(python_shell,
parasite_python_shell_get_history_back(python_shell));
return TRUE;
}
else if (event->keyval == GDK_Down)
{
parasite_python_shell_replace_input(python_shell,
parasite_python_shell_get_history_forward(python_shell));
return TRUE;
}
else if (event->string != NULL)
{
ParasitePythonShellPrivate *priv =
PARASITE_PYTHON_SHELL_GET_PRIVATE(python_shell);
GtkTextBuffer *buffer =
gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->textview));
GtkTextMark *insert_mark = gtk_text_buffer_get_insert(buffer);
GtkTextMark *selection_mark =
gtk_text_buffer_get_selection_bound(buffer);
GtkTextIter insert_iter;
GtkTextIter selection_iter;
GtkTextIter start_iter;
gint cmp_start_insert;
gint cmp_start_select;
gint cmp_insert_select;
gtk_text_buffer_get_iter_at_mark(buffer, &start_iter,
priv->line_start_mark);
gtk_text_buffer_get_iter_at_mark(buffer, &insert_iter, insert_mark);
gtk_text_buffer_get_iter_at_mark(buffer, &selection_iter,
selection_mark);
cmp_start_insert = gtk_text_iter_compare(&start_iter, &insert_iter);
cmp_start_select = gtk_text_iter_compare(&start_iter, &selection_iter);
cmp_insert_select = gtk_text_iter_compare(&insert_iter,
&selection_iter);
if (cmp_start_insert == 0 && cmp_start_select == 0 &&
(event->keyval == GDK_BackSpace ||
event->keyval == GDK_Left))
{
return TRUE;
}
if (cmp_start_insert <= 0 && cmp_start_select <= 0)
{
return FALSE;
}
else if (cmp_start_insert > 0 && cmp_start_select > 0)
{
gtk_text_buffer_place_cursor(buffer, &start_iter);
}
else if (cmp_insert_select < 0)
{
gtk_text_buffer_move_mark(buffer, insert_mark, &start_iter);
}
else if (cmp_insert_select > 0)
{
gtk_text_buffer_move_mark(buffer, selection_mark, &start_iter);
}
}
return FALSE;
}
gboolean document_search_real(GtkWidget *textview, gint direction)
{
GtkTextIter iter, match_start, match_end;
gboolean res;
GtkSourceSearchFlags search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
if (!string_find)
return FALSE;
if (!match_case)
search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
// if (direction == 0 || !hlight_check_searched())
if (direction == 0 || (direction != 2 && !hlight_check_searched()))
hlight_searched_strings(GTK_TEXT_VIEW(textview)->buffer, string_find);
gtk_text_mark_set_visible(
gtk_text_buffer_get_selection_bound(
GTK_TEXT_VIEW(textview)->buffer), FALSE);
gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer));
if (direction < 0) {
res = gtk_source_iter_backward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
if (gtk_text_iter_equal(&iter, &match_end)) {
res = gtk_source_iter_backward_search(
&match_start, string_find, search_flags, &match_start, &match_end, NULL);
}
} else {
res = gtk_source_iter_forward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
}
/* TODO: both gtk_(text/source)_iter_backward_search works not fine for multi-byte */
/* wrap */
/* TODO: define limit NULL -> proper value */
if (!res) {
if (direction < 0) {
gtk_text_buffer_get_end_iter(textbuffer, &iter);
res = gtk_source_iter_backward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
} else {
gtk_text_buffer_get_start_iter(textbuffer, &iter);
res = gtk_source_iter_forward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
}
}
if (res) {
gtk_text_buffer_place_cursor(textbuffer, &match_start);
gtk_text_buffer_move_mark_by_name(textbuffer, "insert", &match_end);
// gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &match_start, 0.1, FALSE, 0.5, 0.5);
scroll_to_cursor(textbuffer, 0.05);
}
else if (direction == 0)
run_dialog_message(gtk_widget_get_toplevel(textview), GTK_MESSAGE_WARNING,
_("Search string not found"));
return res;
}
static void
gimp_text_tool_move_cursor (GimpTextTool *text_tool,
GtkMovementStep step,
gint count,
gboolean extend_selection)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
GtkTextIter cursor;
GtkTextIter selection;
GtkTextIter *sel_start;
gboolean cancel_selection = FALSE;
gint x_pos = -1;
GIMP_LOG (TEXT_EDITING, "%s count = %d, select = %s",
g_enum_get_value (g_type_class_ref (GTK_TYPE_MOVEMENT_STEP),
step)->value_name,
count,
extend_selection ? "TRUE" : "FALSE");
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_get_iter_at_mark (buffer, &selection,
gtk_text_buffer_get_selection_bound (buffer));
if (extend_selection)
{
sel_start = &selection;
}
else
{
/* when there is a selection, moving the cursor without
* extending it should move the cursor to the end of the
* selection that is in moving direction
*/
if (count > 0)
gtk_text_iter_order (&selection, &cursor);
else
gtk_text_iter_order (&cursor, &selection);
sel_start = &cursor;
/* if we actually have a selection, just move *to* the beginning/end
* of the selection and not *from* there on LOGICAL_POSITIONS
* and VISUAL_POSITIONS movement
*/
if (! gtk_text_iter_equal (&cursor, &selection))
cancel_selection = TRUE;
}
switch (step)
{
case GTK_MOVEMENT_LOGICAL_POSITIONS:
if (! cancel_selection)
gtk_text_iter_forward_visible_cursor_positions (&cursor, count);
break;
case GTK_MOVEMENT_VISUAL_POSITIONS:
if (! cancel_selection)
{
PangoLayout *layout;
const gchar *text;
if (! gimp_text_tool_ensure_layout (text_tool))
break;
layout = gimp_text_layout_get_pango_layout (text_tool->layout);
text = pango_layout_get_text (layout);
while (count != 0)
{
const gunichar word_joiner = 8288; /*g_utf8_get_char(WORD_JOINER);*/
gint index;
gint trailing = 0;
gint new_index;
index = gimp_text_buffer_get_iter_index (text_tool->buffer,
&cursor, TRUE);
if (count > 0)
{
if (g_utf8_get_char (text + index) == word_joiner)
pango_layout_move_cursor_visually (layout, TRUE,
index, 0, 1,
&new_index, &trailing);
else
new_index = index;
pango_layout_move_cursor_visually (layout, TRUE,
new_index, trailing, 1,
&new_index, &trailing);
count--;
}
else
{
pango_layout_move_cursor_visually (layout, TRUE,
index, 0, -1,
&new_index, &trailing);
if (new_index != -1 && new_index != G_MAXINT &&
g_utf8_get_char (text + new_index) == word_joiner)
{
pango_layout_move_cursor_visually (layout, TRUE,
new_index, trailing, -1,
&new_index, &trailing);
}
count++;
}
if (new_index != G_MAXINT && new_index != -1)
index = new_index;
else
break;
gimp_text_buffer_get_iter_at_index (text_tool->buffer,
&cursor, index, TRUE);
gtk_text_iter_forward_chars (&cursor, trailing);
}
}
break;
case GTK_MOVEMENT_WORDS:
if (count < 0)
{
gtk_text_iter_backward_visible_word_starts (&cursor, -count);
}
else if (count > 0)
{
if (! gtk_text_iter_forward_visible_word_ends (&cursor, count))
gtk_text_iter_forward_to_line_end (&cursor);
}
break;
case GTK_MOVEMENT_DISPLAY_LINES:
{
GtkTextIter start;
GtkTextIter end;
gint cursor_index;
PangoLayout *layout;
PangoLayoutLine *layout_line;
PangoLayoutIter *layout_iter;
PangoRectangle logical;
gint line;
gint trailing;
gint i;
gtk_text_buffer_get_bounds (buffer, &start, &end);
cursor_index = gimp_text_buffer_get_iter_index (text_tool->buffer,
&cursor, TRUE);
if (! gimp_text_tool_ensure_layout (text_tool))
break;
layout = gimp_text_layout_get_pango_layout (text_tool->layout);
pango_layout_index_to_line_x (layout, cursor_index, FALSE,
&line, &x_pos);
layout_iter = pango_layout_get_iter (layout);
for (i = 0; i < line; i++)
pango_layout_iter_next_line (layout_iter);
pango_layout_iter_get_line_extents (layout_iter, NULL, &logical);
x_pos += logical.x;
pango_layout_iter_free (layout_iter);
/* try to go to the remembered x_pos if it exists *and* we are at
* the beginning or at the end of the current line
*/
if (text_tool->x_pos != -1 && (x_pos <= logical.x ||
x_pos >= logical.x + logical.width))
x_pos = text_tool->x_pos;
line += count;
if (line < 0)
{
cursor = start;
break;
}
else if (line >= pango_layout_get_line_count (layout))
{
cursor = end;
break;
}
layout_iter = pango_layout_get_iter (layout);
for (i = 0; i < line; i++)
pango_layout_iter_next_line (layout_iter);
layout_line = pango_layout_iter_get_line_readonly (layout_iter);
pango_layout_iter_get_line_extents (layout_iter, NULL, &logical);
pango_layout_iter_free (layout_iter);
pango_layout_line_x_to_index (layout_line, x_pos - logical.x,
&cursor_index, &trailing);
gimp_text_buffer_get_iter_at_index (text_tool->buffer, &cursor,
cursor_index, TRUE);
while (trailing--)
gtk_text_iter_forward_char (&cursor);
}
break;
case GTK_MOVEMENT_PAGES: /* well... */
case GTK_MOVEMENT_BUFFER_ENDS:
if (count < 0)
{
gtk_text_buffer_get_start_iter (buffer, &cursor);
}
else if (count > 0)
{
gtk_text_buffer_get_end_iter (buffer, &cursor);
}
break;
case GTK_MOVEMENT_PARAGRAPH_ENDS:
if (count < 0)
{
gtk_text_iter_set_line_offset (&cursor, 0);
}
else if (count > 0)
{
if (! gtk_text_iter_ends_line (&cursor))
gtk_text_iter_forward_to_line_end (&cursor);
}
break;
case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
if (count < 0)
{
gtk_text_iter_set_line_offset (&cursor, 0);
}
else if (count > 0)
{
if (! gtk_text_iter_ends_line (&cursor))
gtk_text_iter_forward_to_line_end (&cursor);
}
break;
default:
return;
}
text_tool->x_pos = x_pos;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool));
gimp_text_tool_reset_im_context (text_tool);
gtk_text_buffer_select_range (buffer, &cursor, sel_start);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool));
}
gboolean
gimp_text_tool_editor_key_press (GimpTextTool *text_tool,
GdkEventKey *kevent)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
GtkTextIter cursor;
GtkTextIter selection;
gint x_pos = -1;
gboolean retval = TRUE;
if (gtk_im_context_filter_keypress (text_tool->im_context, kevent))
{
text_tool->needs_im_reset = TRUE;
text_tool->x_pos = -1;
return TRUE;
}
gimp_text_tool_ensure_proxy (text_tool);
if (gtk_bindings_activate_event (GTK_OBJECT (text_tool->proxy_text_view),
kevent))
{
GIMP_LOG (TEXT_EDITING, "binding handled event");
return TRUE;
}
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_get_iter_at_mark (buffer, &selection,
gtk_text_buffer_get_selection_bound (buffer));
switch (kevent->keyval)
{
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
gimp_text_tool_reset_im_context (text_tool);
gimp_text_tool_enter_text (text_tool, "\n");
break;
case GDK_KEY_Tab:
case GDK_KEY_KP_Tab:
case GDK_KEY_ISO_Left_Tab:
gimp_text_tool_reset_im_context (text_tool);
gimp_text_tool_enter_text (text_tool, "\t");
break;
case GDK_KEY_Escape:
gimp_rectangle_tool_cancel (GIMP_RECTANGLE_TOOL (text_tool));
gimp_tool_control (GIMP_TOOL (text_tool), GIMP_TOOL_ACTION_HALT,
GIMP_TOOL (text_tool)->display);
break;
default:
retval = FALSE;
}
text_tool->x_pos = x_pos;
return retval;
}
void
gimp_text_tool_editor_motion (GimpTextTool *text_tool,
gdouble x,
gdouble y)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
GtkTextIter old_cursor;
GtkTextIter old_selection;
GtkTextIter cursor;
GtkTextIter selection;
gtk_text_buffer_get_iter_at_mark (buffer, &old_cursor,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_get_iter_at_mark (buffer, &old_selection,
gtk_text_buffer_get_selection_bound (buffer));
gimp_text_tool_xy_to_iter (text_tool, x, y, &cursor);
selection = text_tool->select_start_iter;
if (text_tool->select_words ||
text_tool->select_lines)
{
GtkTextIter start;
GtkTextIter end;
if (gtk_text_iter_compare (&cursor, &selection) < 0)
{
start = cursor;
end = selection;
}
else
{
start = selection;
end = cursor;
}
if (text_tool->select_words)
{
if (! gtk_text_iter_starts_word (&start))
gtk_text_iter_backward_visible_word_starts (&start, 1);
if (! gtk_text_iter_ends_word (&end) &&
! gtk_text_iter_forward_visible_word_ends (&end, 1))
gtk_text_iter_forward_to_line_end (&end);
}
else if (text_tool->select_lines)
{
gtk_text_iter_set_line_offset (&start, 0);
gtk_text_iter_forward_to_line_end (&end);
}
if (gtk_text_iter_compare (&cursor, &selection) < 0)
{
cursor = start;
selection = end;
}
else
{
selection = start;
cursor = end;
}
}
if (! gtk_text_iter_equal (&cursor, &old_cursor) ||
! gtk_text_iter_equal (&selection, &old_selection))
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool));
gtk_text_buffer_select_range (buffer, &cursor, &selection);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool));
}
}
static void
start_interactive_search_real (GeditViewFrame *frame)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextMark *mark;
if (gtk_bin_get_child (GTK_BIN (frame->priv->slider)) == NULL)
{
gtk_container_add (GTK_CONTAINER (frame->priv->slider),
create_search_widget (frame));
}
if (gtk_widget_get_visible (frame->priv->slider))
{
if (frame->priv->search_mode != frame->priv->request_search_mode)
{
hide_search_widget (frame, TRUE);
}
else
{
gtk_editable_select_region (GTK_EDITABLE (frame->priv->search_entry),
0, -1);
return;
}
}
frame->priv->search_mode = frame->priv->request_search_mode;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (frame->priv->view));
if (frame->priv->search_mode == SEARCH)
{
GtkTextIter start, end;
if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
{
if (gtk_text_iter_compare (&start, &end) == -1)
{
iter = start;
}
else
{
iter = end;
}
}
else
{
mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
}
}
else
{
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
}
frame->priv->start_mark = gtk_text_buffer_create_mark (buffer, NULL,
&iter, FALSE);
/* To slide in we set the right animation state in the animatable */
g_object_set (G_OBJECT (frame->priv->slider),
"animation-state", GEDIT_THEATRICS_ANIMATION_STATE_COMING,
NULL);
/* NOTE: we must be very careful here to not have any text before
focusing the entry because when the entry is focused the text is
selected, and gtk+ doesn't allow us to have more than one selection
active */
g_signal_handler_block (frame->priv->search_entry,
frame->priv->search_entry_changed_id);
gtk_entry_set_text (GTK_ENTRY (frame->priv->search_entry),
"");
g_signal_handler_unblock (frame->priv->search_entry,
frame->priv->search_entry_changed_id);
/* We need to grab the focus after the widget has been added */
gtk_widget_grab_focus (frame->priv->search_entry);
init_search_entry (frame);
/* Manage the scroll also for the view */
frame->priv->view_scroll_event_id =
g_signal_connect (frame->priv->view, "scroll-event",
G_CALLBACK (search_widget_scroll_event),
frame);
frame->priv->typeselect_flush_timeout =
g_timeout_add (GEDIT_VIEW_FRAME_SEARCH_DIALOG_TIMEOUT,
(GSourceFunc) search_entry_flush_timeout,
frame);
}
