static gboolean
button_release_event (GtkWidget *text, GdkEventButton *event)
{
gchar *sel;
#if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN)
GtkTextIter start;
GtkTextIter end;
if (gtk_text_buffer_get_selection_bounds (GTK_TEXT_VIEW(text)->buffer,
&start, &end))
{
if(gtk_text_iter_compare (&start, &end) < 0)
{
sel = gtk_text_buffer_get_text(GTK_TEXT_VIEW(text)->buffer,
&start, &end, FALSE);
if(sel)
{
int slen = strlen(sel);
char *sel2 = NULL;
if((slen)&&(sel[0]>='0')&&(sel[0]<='9'))
{
TimeType tm;
gunichar gch = gtk_text_iter_get_char(&end);
int do_si_append = 0;
if(gch==' ') /* in case time is of format "100 ps" with a space */
{
gtk_text_iter_forward_char(&end);
gch = gtk_text_iter_get_char(&end);
}
if((sel[slen-1]>='0')&&(sel[slen-1]<='9')) /* need to append units? */
{
int silen = strlen(WAVE_SI_UNITS);
int silp;
gch = tolower(gch);
if(gch == 's')
{
do_si_append = 1;
}
else
{
for(silp=0;silp<silen;silp++)
{
if(gch == WAVE_SI_UNITS[silp])
{
do_si_append = 1;
break;
}
}
}
}
if(do_si_append)
{
sel2 = malloc_2(slen + 2);
sprintf(sel2, "%s%c", sel, (unsigned char)gch);
}
tm = unformat_time(sel2 ? sel2 : sel, GLOBALS->time_dimension);
if((tm >= GLOBALS->tims.first) && (tm <= GLOBALS->tims.last))
{
GLOBALS->tims.lmbcache = -1;
update_markertime(GLOBALS->tims.marker = tm);
center_op();
signalarea_configure_event(GLOBALS->signalarea, NULL);
wavearea_configure_event(GLOBALS->wavearea, NULL);
update_markertime(GLOBALS->tims.marker = tm); /* centering problem in GTK2 */
}
}
if(sel2) { free_2(sel2); }
g_free(sel);
}
}
}
#else
#ifndef WAVE_USE_GTK2
GtkEditable *oe = GTK_EDITABLE(>K_TEXT(text)->editable);
GtkTextClass *tc = (GtkTextClass *) ((GtkObject*) (GTK_OBJECT(text)))->klass;
GtkEditableClass *oec = &tc->parent_class;
#else
GtkOldEditable *oe = GTK_OLD_EDITABLE(>K_TEXT(text)->old_editable);
GtkOldEditableClass *oec = GTK_OLD_EDITABLE_GET_CLASS(oe);
#endif
if(oe->has_selection)
{
if(oec->get_chars)
{
sel = oec->get_chars(oe, oe->selection_start_pos, oe->selection_end_pos);
if(sel)
{
int slen = strlen(sel);
char *sel2 = NULL;
if((slen)&&(sel[0]>='0')&&(sel[0]<='9'))
{
TimeType tm;
gint gchpos = oe->selection_end_pos;
gchar *extra = oec->get_chars(oe, gchpos, gchpos+2);
gchar gch = extra ? extra[0] : 0;
int do_si_append = 0;
if(gch==' ') /* in case time is of format "100 ps" with a space */
{
gch = gch ? extra[1] : 0;
}
if(extra) g_free(extra);
if((sel[slen-1]>='0')&&(sel[slen-1]<='9')) /* need to append units? */
{
int silen = strlen(WAVE_SI_UNITS);
int silp;
gch = tolower(gch);
if(gch == 's')
{
do_si_append = 1;
}
else
{
for(silp=0;silp<silen;silp++)
{
if(gch == WAVE_SI_UNITS[silp])
{
do_si_append = 1;
break;
}
}
}
}
if(do_si_append)
{
sel2 = malloc_2(slen + 2);
sprintf(sel2, "%s%c", sel, (unsigned char)gch);
}
tm = unformat_time(sel2 ? sel2 : sel, GLOBALS->time_dimension);
if((tm >= GLOBALS->tims.first) && (tm <= GLOBALS->tims.last))
{
GLOBALS->tims.lmbcache = -1;
update_markertime(GLOBALS->tims.marker = tm);
center_op();
signalarea_configure_event(GLOBALS->signalarea, NULL);
wavearea_configure_event(GLOBALS->wavearea, NULL);
update_markertime(GLOBALS->tims.marker = tm); /* centering problem in GTK2 */
}
}
if(sel2) { free_2(sel2); }
g_free(sel);
}
}
}
#endif
return(FALSE); /* call remaining handlers... */
}
void
gtk_text_layout_draw (GtkTextLayout *layout,
GtkWidget *widget,
GdkDrawable *drawable,
GdkGC *cursor_gc,
/* Location of the drawable
in layout coordinates */
gint x_offset,
gint y_offset,
/* Region of the layout to
render */
gint x,
gint y,
gint width,
gint height,
/* widgets to expose */
GList **widgets)
{
GdkRectangle clip;
gint current_y;
GSList *cursor_list;
GtkTextRenderState *render_state;
GtkTextIter selection_start, selection_end;
gboolean have_selection = FALSE;
GSList *line_list;
GSList *tmp_list;
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
g_return_if_fail (layout->default_style != NULL);
g_return_if_fail (layout->buffer != NULL);
g_return_if_fail (drawable != NULL);
g_return_if_fail (width >= 0);
g_return_if_fail (height >= 0);
if (width == 0 || height == 0)
return;
line_list = gtk_text_layout_get_lines (layout, y + y_offset, y + y_offset + height, ¤t_y);
current_y -= y_offset;
if (line_list == NULL)
return; /* nothing on the screen */
clip.x = x;
clip.y = y;
clip.width = width;
clip.height = height;
render_state = gtk_text_render_state_new (widget, drawable, &clip);
gdk_gc_set_clip_rectangle (render_state->fg_gc, &clip);
gdk_gc_set_clip_rectangle (render_state->bg_gc, &clip);
gtk_text_layout_wrap_loop_start (layout);
if (gtk_text_buffer_get_selection_bounds (layout->buffer,
&selection_start,
&selection_end))
have_selection = TRUE;
tmp_list = line_list;
while (tmp_list != NULL)
{
GtkTextLineDisplay *line_display;
gint selection_start_index = -1;
gint selection_end_index = -1;
gboolean have_strong;
gboolean have_weak;
GtkTextLine *line = tmp_list->data;
line_display = gtk_text_layout_get_line_display (layout, line, FALSE);
if (line_display->height > 0)
{
g_assert (line_display->layout != NULL);
if (have_selection)
{
GtkTextIter line_start, line_end;
gint byte_count;
gtk_text_layout_get_iter_at_line (layout,
&line_start,
line, 0);
line_end = line_start;
if (!gtk_text_iter_ends_line (&line_end))
gtk_text_iter_forward_to_line_end (&line_end);
byte_count = gtk_text_iter_get_line_index (&line_end);
if (gtk_text_iter_compare (&selection_start, &line_end) <= 0 &&
gtk_text_iter_compare (&selection_end, &line_start) >= 0)
{
if (gtk_text_iter_compare (&selection_start, &line_start) >= 0)
selection_start_index = gtk_text_iter_get_line_index (&selection_start);
else
selection_start_index = -1;
if (gtk_text_iter_compare (&selection_end, &line_end) <= 0)
selection_end_index = gtk_text_iter_get_line_index (&selection_end);
else
selection_end_index = MAX(byte_count, 1);
}
}
render_para (drawable, render_state, line_display,
- x_offset,
current_y,
selection_start_index, selection_end_index,
widgets);
/* We paint the cursors last, because they overlap another chunk
and need to appear on top. */
have_strong = FALSE;
have_weak = FALSE;
cursor_list = line_display->cursors;
while (cursor_list)
{
GtkTextCursorDisplay *cursor = cursor_list->data;
if (cursor->is_strong)
have_strong = TRUE;
else
have_weak = TRUE;
cursor_list = cursor_list->next;
}
cursor_list = line_display->cursors;
while (cursor_list)
{
GtkTextCursorDisplay *cursor = cursor_list->data;
GtkTextDirection dir;
GdkRectangle cursor_location;
GdkGC *gc;
dir = line_display->direction;
if (have_strong && have_weak)
{
if (!cursor->is_strong)
dir = (dir == GTK_TEXT_DIR_RTL) ? GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
}
cursor_location.x = line_display->x_offset + cursor->x - x_offset;
cursor_location.y = current_y + line_display->top_margin + cursor->y;
cursor_location.width = 0;
cursor_location.height = cursor->height;
gc = _gtk_get_insertion_cursor_gc (widget, cursor->is_strong);
gdk_gc_set_clip_rectangle(gc, &clip);
_gtk_draw_insertion_cursor (widget, drawable, gc, &cursor_location,
dir, have_strong && have_weak);
gdk_gc_set_clip_rectangle (gc, NULL);
g_object_unref (gc);
cursor_list = cursor_list->next;
}
} /* line_display->height > 0 */
current_y += line_display->height;
gtk_text_layout_free_line_display (layout, line_display);
render_state->last_appearance = NULL;
render_state->last_bg_appearance = NULL;
tmp_list = g_slist_next (tmp_list);
}
gtk_text_layout_wrap_loop_end (layout);
gtk_text_render_state_destroy (render_state);
g_slist_free (line_list);
}
static void
spell_cb (GSimpleAction *action,
GVariant *parameter,
gpointer data)
{
GeditSpellPlugin *plugin = GEDIT_SPELL_PLUGIN (data);
GeditSpellPluginPrivate *priv;
GeditView *view;
GeditDocument *doc;
GeditSpellChecker *spell;
GtkWidget *dlg;
GtkTextIter start, end;
gchar *word;
gchar *data_dir;
gedit_debug (DEBUG_PLUGINS);
priv = plugin->priv;
view = gedit_window_get_active_view (priv->window);
g_return_if_fail (view != NULL);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
g_return_if_fail (doc != NULL);
spell = get_spell_checker_from_document (doc);
g_return_if_fail (spell != NULL);
if (gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (doc)) <= 0)
{
GtkWidget *statusbar;
statusbar = gedit_window_get_statusbar (priv->window);
gedit_statusbar_flash_message (GEDIT_STATUSBAR (statusbar),
priv->message_cid,
_("The document is empty."));
return;
}
if (!gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start,
&end))
{
/* no selection, get the whole doc */
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc),
&start,
&end);
}
set_check_range (doc, &start, &end);
word = get_next_misspelled_word (view);
if (word == NULL)
{
GtkWidget *statusbar;
statusbar = gedit_window_get_statusbar (priv->window);
gedit_statusbar_flash_message (GEDIT_STATUSBAR (statusbar),
priv->message_cid,
_("No misspelled words"));
return;
}
data_dir = peas_extension_base_get_data_dir (PEAS_EXTENSION_BASE (plugin));
dlg = gedit_spell_checker_dialog_new_from_spell_checker (spell, data_dir);
g_free (data_dir);
gtk_window_set_modal (GTK_WINDOW (dlg), TRUE);
gtk_window_set_transient_for (GTK_WINDOW (dlg),
GTK_WINDOW (priv->window));
g_signal_connect (dlg, "ignore", G_CALLBACK (ignore_cb), view);
g_signal_connect (dlg, "ignore_all", G_CALLBACK (ignore_cb), view);
g_signal_connect (dlg, "change", G_CALLBACK (change_cb), view);
g_signal_connect (dlg, "change_all", G_CALLBACK (change_all_cb), view);
g_signal_connect (dlg, "add_word_to_personal", G_CALLBACK (add_word_cb), view);
gedit_spell_checker_dialog_set_misspelled_word (GEDIT_SPELL_CHECKER_DIALOG (dlg),
word,
-1);
g_free (word);
gtk_widget_show (dlg);
}
/* Links can also be activated by clicking. */
static gboolean
textview_event_after (GtkTextView *textview,
GdkEvent *event)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
gint x, y;
GdkModifierType mt = 0;
guint event_button = 0;
gdouble event_x_win = 0;
gdouble event_y_win = 0;
g_return_val_if_fail (GTK_IS_TEXT_VIEW (textview), FALSE);
if (event->type == GDK_KEY_PRESS || event->type == GDK_KEY_RELEASE) {
guint event_keyval = 0;
gdk_event_get_keyval (event, &event_keyval);
switch (event_keyval) {
case GDK_KEY_Control_L:
case GDK_KEY_Control_R:
update_ctrl_state (
textview,
event->type == GDK_KEY_PRESS);
break;
}
return FALSE;
}
if (!gdk_event_get_state (event, &mt)) {
GdkWindow *window;
GdkDisplay *display;
GdkDeviceManager *device_manager;
GdkDevice *device;
window = gtk_widget_get_parent_window (GTK_WIDGET (textview));
display = gdk_window_get_display (window);
device_manager = gdk_display_get_device_manager (display);
device = gdk_device_manager_get_client_pointer (device_manager);
gdk_window_get_device_position (window, device, NULL, NULL, &mt);
}
update_ctrl_state (textview, (mt & GDK_CONTROL_MASK) != 0);
if (event->type != GDK_BUTTON_RELEASE)
return FALSE;
gdk_event_get_button (event, &event_button);
gdk_event_get_coords (event, &event_x_win, &event_y_win);
if (event_button != 1 || (mt & GDK_CONTROL_MASK) == 0)
return FALSE;
buffer = gtk_text_view_get_buffer (textview);
/* we shouldn't follow a link if the user has selected something */
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
if (gtk_text_iter_get_offset (&start) != gtk_text_iter_get_offset (&end))
return FALSE;
gtk_text_view_window_to_buffer_coords (
textview,
GTK_TEXT_WINDOW_WIDGET,
event_x_win, event_y_win, &x, &y);
gtk_text_view_get_iter_at_location (textview, &iter, x, y);
invoke_link_if_present (buffer, &iter);
update_mouse_cursor (textview, x, y);
return FALSE;
}
/* original version taken from bluefish's (doc_indent_selection) */
gint func_indent( GtkWidget *widget, GdkEventKey *kevent, Tbfwin *bfwin, gint opt) {
Tdocument *doc = bfwin->current_document;
if (!doc) return 0;
gint unindent = opt & FUNC_VALUE_0;
GtkTextIter itstart, itend;
if ( gtk_text_buffer_get_selection_bounds( doc->buffer, &itstart, &itend ) ) {
GtkTextMark * end;
doc_unbind_signals( doc );
doc_unre_new_group( doc );
/* we have a selection, now we loop trough the characters, and for every newline
we add or remove a tab, we set the end with a mark */
end = gtk_text_buffer_create_mark( doc->buffer, NULL, &itend, TRUE );
if ( gtk_text_iter_get_line_offset( &itstart ) > 0 ) {
gtk_text_iter_set_line_index( &itstart, 0 );
}
while ( gtk_text_iter_compare( &itstart, &itend ) < 0 ) {
GtkTextMark * cur;
cur = gtk_text_buffer_create_mark( doc->buffer, NULL, &itstart, TRUE );
if ( unindent ) {
/* when unindenting we try to set itend to the end of the indenting step
which might be a tab or 'tabsize' spaces, then we delete that part */
gboolean cont = TRUE;
gchar *buf = NULL;
gunichar cchar = gtk_text_iter_get_char( &itstart );
if ( cchar == 9 ) { /* 9 is ascii for tab */
itend = itstart;
cont = gtk_text_iter_forward_char( &itend );
buf = g_strdup( "\t" );
} else if ( cchar == 32 ) { /* 32 is ascii for space */
gint i = 0;
itend = itstart;
gtk_text_iter_forward_chars( &itend, main_v->props.editor_tab_width );
buf = gtk_text_buffer_get_text( doc->buffer, &itstart, &itend, FALSE );
DEBUG_MSG( "func_indent: tab_width=%d, strlen(buf)=%d, buf='%s'\n", main_v->props.editor_tab_width, strlen( buf ), buf );
while ( cont && buf[ i ] != '\0' ) {
cont = ( buf[ i ] == ' ' );
DEBUG_MSG( "func_indent: buf[%d]='%c'\n", i, buf[ i ] );
i++;
}
if ( !cont ) {
g_free ( buf );
}
} else {
cont = FALSE;
}
if ( cont ) {
gint offsetstart, offsetend;
offsetstart = gtk_text_iter_get_offset( &itstart );
offsetend = gtk_text_iter_get_offset( &itend );
gtk_text_buffer_delete( doc->buffer, &itstart, &itend );
doc_unre_add( doc, buf, offsetstart, offsetend, UndoDelete );
g_free ( buf );
}
} else { /* indent */
gint offsetstart = gtk_text_iter_get_offset( &itstart );
gchar *indentstring;
gint indentlen;
if ( main_v->props.view_bars & MODE_INDENT_WITH_SPACES ) {
indentstring = bf_str_repeat( " ", main_v->props.editor_tab_width );
indentlen = main_v->props.editor_tab_width;
} else {
indentstring = g_strdup( "\t" );
indentlen = 1;
}
gtk_text_buffer_insert( doc->buffer, &itstart, indentstring, indentlen );
doc_unre_add( doc, indentstring, offsetstart, offsetstart + indentlen, UndoInsert );
g_free( indentstring );
}
gtk_text_buffer_get_iter_at_mark( doc->buffer, &itstart, cur );
gtk_text_buffer_get_iter_at_mark( doc->buffer, &itend, end );
gtk_text_buffer_delete_mark( doc->buffer, cur );
gtk_text_iter_forward_line( &itstart );
DEBUG_MSG( "func_indent: itstart at %d, itend at %d\n", gtk_text_iter_get_offset( &itstart ), gtk_text_iter_get_offset( &itend ) );
}
gtk_text_buffer_delete_mark( doc->buffer, end );
doc_bind_signals( doc );
doc_set_modified( doc, 1 );
} else {
/* there is no selection, work on the current line */
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark( doc->buffer, &iter, gtk_text_buffer_get_insert( doc->buffer ) );
gtk_text_iter_set_line_offset( &iter, 0 );
if ( unindent ) {
gint deletelen = 0;
gchar *tmpstr, *tmp2str;
GtkTextIter itend = iter;
gtk_text_iter_forward_chars( &itend, main_v->props.editor_tab_width );
tmpstr = gtk_text_buffer_get_text( doc->buffer, &iter, &itend, FALSE );
tmp2str = bf_str_repeat( " ", main_v->props.editor_tab_width );
if ( tmpstr[ 0 ] == '\t' ) {
deletelen = 1;
} else if ( tmpstr && strncmp( tmpstr, tmp2str, main_v->props.editor_tab_width ) == 0 ) {
deletelen = main_v->props.editor_tab_width;
}
g_free( tmpstr );
g_free( tmp2str );
if ( deletelen ) {
itend = iter;
gtk_text_iter_forward_chars( &itend, deletelen );
gtk_text_buffer_delete( doc->buffer, &iter, &itend );
}
} else { /* indent */
gchar *indentstring;
gint indentlen;
if ( main_v->props.view_bars & MODE_INDENT_WITH_SPACES ) {
indentstring = bf_str_repeat( " ", main_v->props.editor_tab_width );
indentlen = main_v->props.editor_tab_width;
} else {
indentstring = g_strdup( "\t" );
indentlen = 1;
}
gtk_text_buffer_insert( doc->buffer, &iter, indentstring, indentlen );
g_free( indentstring );
}
}
return 1;
}
gdouble get_selection_font_size(GtkTextBuffer *text_buffer, GtkTextView *text_view)
{
// Local variables
GtkTextIter end_iter;
gfloat font_size; // Used for calculating the font size of a character
gint font_size_int; // Used for retrieving the size of a character in a text layer
gfloat iter_size; // The size of the present character
GtkTextAttributes *text_attributes; // Pointer to the attributes for a text layer character
GtkTextIter first_iter;
// Retrieve the selection start and end iters
gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(text_buffer), &first_iter, &end_iter);
// If the start iter is not at the start of the text buffer, we move it back one character to get an accurate value
if (FALSE == gtk_text_iter_is_start(&first_iter))
{
gtk_text_iter_backward_char(&first_iter);
}
// Unless the start and end iters are at the same place, move the end iter back one so we
// get an accurate value
if (FALSE == gtk_text_iter_equal(&first_iter, &end_iter))
{
gtk_text_iter_backward_char(&end_iter);
}
// Determine the font size at the selection start iter
text_attributes = gtk_text_view_get_default_attributes(GTK_TEXT_VIEW(text_view));
gtk_text_iter_get_attributes(&first_iter, text_attributes);
font_size_int = pango_font_description_get_size(text_attributes->font);
font_size_int *= 10;
font_size = roundf(((gfloat) font_size_int) / PANGO_SCALE);
font_size /= 10;
// Step through the text buffer character by character,
// checking if the font size has changed
while (FALSE == gtk_text_iter_equal(&first_iter, &end_iter))
{
// Move forward one iter
gtk_text_iter_forward_char(&first_iter);
// Get the font size at this new iter
text_attributes = gtk_text_view_get_default_attributes(GTK_TEXT_VIEW(text_view));
gtk_text_iter_get_attributes(&first_iter, text_attributes);
font_size_int = pango_font_description_get_size(text_attributes->font);
font_size_int *= 10;
iter_size = roundf(((gfloat) font_size_int) / PANGO_SCALE);
iter_size /= 10;
// If the font size value is different to the original size,
// then we short circuit the loop and return -1.0
if (font_size != iter_size)
{
return -1.0;
}
}
// We've reached the end of the selection, and the selection font size
// has been the same the whole way. We return that font size.
return font_size;
}
static void
selectioninfo_real (CeditDocument *doc,
DocInfoDialog *dialog)
{
gboolean sel;
GtkTextIter start, end;
gint words = 0;
gint chars = 0;
gint white_chars = 0;
gint lines = 0;
gint bytes = 0;
gchar *tmp_str;
cedit_debug (DEBUG_PLUGINS);
sel = gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start,
&end);
if (sel)
{
lines = gtk_text_iter_get_line (&end) - gtk_text_iter_get_line (&start) + 1;
calculate_info (doc,
&start, &end,
&chars, &words, &white_chars, &bytes);
cedit_debug_message (DEBUG_PLUGINS, "Selected chars: %d", chars);
cedit_debug_message (DEBUG_PLUGINS, "Selected lines: %d", lines);
cedit_debug_message (DEBUG_PLUGINS, "Selected words: %d", words);
cedit_debug_message (DEBUG_PLUGINS, "Selected chars non-space: %d", chars - white_chars);
cedit_debug_message (DEBUG_PLUGINS, "Selected bytes: %d", bytes);
gtk_widget_set_sensitive (dialog->selection_vbox, TRUE);
}
else
{
gtk_widget_set_sensitive (dialog->selection_vbox, FALSE);
cedit_debug_message (DEBUG_PLUGINS, "Selection empty");
}
if (chars == 0)
lines = 0;
tmp_str = g_strdup_printf("%d", lines);
gtk_label_set_text (GTK_LABEL (dialog->selected_lines_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", words);
gtk_label_set_text (GTK_LABEL (dialog->selected_words_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", chars);
gtk_label_set_text (GTK_LABEL (dialog->selected_chars_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", chars - white_chars);
gtk_label_set_text (GTK_LABEL (dialog->selected_chars_ns_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", bytes);
gtk_label_set_text (GTK_LABEL (dialog->selected_bytes_label), tmp_str);
g_free (tmp_str);
}
static gboolean
run_search (GeditViewFrame *frame,
const gchar *entry_text,
gboolean search_backward,
gboolean wrap_around,
gboolean typing)
{
GtkTextIter start_iter;
GtkTextIter match_start;
GtkTextIter match_end;
gboolean found = FALSE;
GeditDocument *doc;
g_return_val_if_fail (frame->priv->search_mode == SEARCH, FALSE);
doc = gedit_view_frame_get_document (frame);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
&start_iter,
frame->priv->start_mark);
if (*entry_text != '\0')
{
if (!search_backward)
{
if (!typing)
{
/* forward and _NOT_ 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 = gedit_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 = gedit_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)
{
found = gedit_document_search_forward (doc,
NULL,
NULL, /* FIXME: set the end_inter */
&match_start,
&match_end);
}
else
{
found = gedit_document_search_backward (doc,
NULL, /* FIXME: set the start_inter */
NULL,
&match_start,
&match_end);
}
}
}
else
{
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start_iter,
NULL);
}
if (found)
{
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc),
&match_start);
gtk_text_buffer_move_mark_by_name (GTK_TEXT_BUFFER (doc),
"selection_bound", &match_end);
}
else if (typing)
{
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
&start_iter,
frame->priv->start_mark);
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc),
&start_iter);
}
if (found || (*entry_text == '\0'))
{
gedit_view_scroll_to_cursor (GEDIT_VIEW (frame->priv->view));
set_entry_background (frame, frame->priv->search_entry,
GEDIT_SEARCH_ENTRY_NORMAL);
}
else
{
set_entry_background (frame, frame->priv->search_entry,
GEDIT_SEARCH_ENTRY_NOT_FOUND);
}
return found;
}
void
error_console_save_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpErrorConsole *console = GIMP_ERROR_CONSOLE (data);
GtkFileChooser *chooser;
if (value && ! gtk_text_buffer_get_selection_bounds (console->text_buffer,
NULL, NULL))
{
gimp_message_literal (console->gimp,
G_OBJECT (console), GIMP_MESSAGE_WARNING,
_("Cannot save. Nothing is selected."));
return;
}
if (console->file_dialog)
{
gtk_window_present (GTK_WINDOW (console->file_dialog));
return;
}
console->file_dialog =
gtk_file_chooser_dialog_new (_("Save Error Log to File"), NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (console->file_dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
console->save_selection = value;
g_object_add_weak_pointer (G_OBJECT (console->file_dialog),
(gpointer) &console->file_dialog);
chooser = GTK_FILE_CHOOSER (console->file_dialog);
gtk_window_set_screen (GTK_WINDOW (chooser),
gtk_widget_get_screen (GTK_WIDGET (console)));
gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE);
gtk_window_set_role (GTK_WINDOW (chooser), "gimp-save-errors");
gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_OK);
gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
g_signal_connect (chooser, "response",
G_CALLBACK (error_console_save_response),
console);
g_signal_connect (chooser, "delete-event",
G_CALLBACK (gtk_true),
NULL);
gimp_help_connect (GTK_WIDGET (chooser), gimp_standard_help_func,
GIMP_HELP_ERRORS_DIALOG, NULL);
gtk_widget_show (GTK_WIDGET (chooser));
}
static gboolean
gimp_text_style_editor_update_idle (GimpTextStyleEditor *editor)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (editor->buffer);
if (editor->update_idle_id)
{
g_source_remove (editor->update_idle_id);
editor->update_idle_id = 0;
}
if (gtk_text_buffer_get_has_selection (buffer))
{
GtkTextIter start, end;
GtkTextIter iter;
GList *list;
gboolean any_toggle_active = TRUE;
gboolean font_differs = FALSE;
gboolean color_differs = FALSE;
gboolean size_differs = FALSE;
gboolean baseline_differs = FALSE;
gboolean kerning_differs = FALSE;
GtkTextTag *font_tag = NULL;
GtkTextTag *color_tag = NULL;
GtkTextTag *size_tag = NULL;
GtkTextTag *baseline_tag = NULL;
GtkTextTag *kerning_tag = NULL;
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
gtk_text_iter_order (&start, &end);
/* first, switch all toggles on */
for (list = editor->toggles; list; list = g_list_next (list))
{
GtkToggleButton *toggle = list->data;
gimp_text_style_editor_set_toggle (editor, toggle, TRUE);
}
/* and get some initial values */
font_tag = gimp_text_buffer_get_iter_font (editor->buffer,
&start, NULL);
color_tag = gimp_text_buffer_get_iter_color (editor->buffer,
&start, NULL);
size_tag = gimp_text_buffer_get_iter_size (editor->buffer,
&start, NULL);
baseline_tag = gimp_text_buffer_get_iter_baseline (editor->buffer,
&start, NULL);
kerning_tag = gimp_text_buffer_get_iter_kerning (editor->buffer,
&start, NULL);
for (iter = start;
gtk_text_iter_in_range (&iter, &start, &end);
gtk_text_iter_forward_cursor_position (&iter))
{
if (any_toggle_active)
{
any_toggle_active = FALSE;
for (list = editor->toggles; list; list = g_list_next (list))
{
GtkToggleButton *toggle = list->data;
GtkTextTag *tag = g_object_get_data (G_OBJECT (toggle),
"tag");
if (! gtk_text_iter_has_tag (&iter, tag))
{
gimp_text_style_editor_set_toggle (editor, toggle, FALSE);
}
else
{
any_toggle_active = TRUE;
}
}
}
if (! font_differs)
{
GtkTextTag *tag;
tag = gimp_text_buffer_get_iter_font (editor->buffer, &iter,
NULL);
if (tag != font_tag)
font_differs = TRUE;
}
if (! color_differs)
{
GtkTextTag *tag;
tag = gimp_text_buffer_get_iter_color (editor->buffer, &iter,
NULL);
if (tag != color_tag)
color_differs = TRUE;
}
if (! size_differs)
{
GtkTextTag *tag;
tag = gimp_text_buffer_get_iter_size (editor->buffer, &iter,
NULL);
if (tag != size_tag)
size_differs = TRUE;
}
if (! baseline_differs)
{
GtkTextTag *tag;
tag = gimp_text_buffer_get_iter_baseline (editor->buffer, &iter,
NULL);
if (tag != baseline_tag)
baseline_differs = TRUE;
}
if (! kerning_differs)
{
GtkTextTag *tag;
tag = gimp_text_buffer_get_iter_kerning (editor->buffer, &iter,
NULL);
if (tag != kerning_tag)
kerning_differs = TRUE;
}
if (! any_toggle_active &&
color_differs &&
font_differs &&
size_differs &&
baseline_differs &&
kerning_differs)
break;
}
if (font_differs)
gimp_text_style_editor_set_font (editor, NULL);
else if (font_tag)
gimp_text_style_editor_set_font (editor, font_tag);
else
gimp_text_style_editor_set_default_font (editor);
if (color_differs)
gimp_text_style_editor_set_color (editor, NULL);
else if (color_tag)
gimp_text_style_editor_set_color (editor, color_tag);
else
gimp_text_style_editor_set_default_color (editor);
if (size_differs)
gimp_text_style_editor_set_size (editor, NULL);
else if (size_tag)
gimp_text_style_editor_set_size (editor, size_tag);
else
gimp_text_style_editor_set_default_size (editor);
if (baseline_differs)
gtk_entry_set_text (GTK_ENTRY (editor->baseline_spinbutton), "");
else
gimp_text_style_editor_set_baseline (editor, baseline_tag);
if (kerning_differs)
gtk_entry_set_text (GTK_ENTRY (editor->kerning_spinbutton), "");
else
gimp_text_style_editor_set_kerning (editor, kerning_tag);
}
else /* no selection */
{
GtkTextIter cursor;
GSList *tags;
GSList *tags_on;
GSList *tags_off;
GList *list;
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
tags = gtk_text_iter_get_tags (&cursor);
tags_on = gtk_text_iter_get_toggled_tags (&cursor, TRUE);
tags_off = gtk_text_iter_get_toggled_tags (&cursor, FALSE);
for (list = editor->buffer->font_tags; list; list = g_list_next (list))
{
GtkTextTag *tag = list->data;
if ((g_slist_find (tags, tag) &&
! g_slist_find (tags_on, tag)) ||
g_slist_find (tags_off, tag))
{
gimp_text_style_editor_set_font (editor, tag);
break;
}
}
if (! list)
gimp_text_style_editor_set_default_font (editor);
for (list = editor->buffer->color_tags; list; list = g_list_next (list))
{
GtkTextTag *tag = list->data;
if ((g_slist_find (tags, tag) &&
! g_slist_find (tags_on, tag)) ||
g_slist_find (tags_off, tag))
{
gimp_text_style_editor_set_color (editor, tag);
break;
}
}
if (! list)
gimp_text_style_editor_set_default_color (editor);
for (list = editor->buffer->size_tags; list; list = g_list_next (list))
{
GtkTextTag *tag = list->data;
if ((g_slist_find (tags, tag) &&
! g_slist_find (tags_on, tag)) ||
g_slist_find (tags_off, tag))
{
gimp_text_style_editor_set_size (editor, tag);
break;
}
}
if (! list)
gimp_text_style_editor_set_default_size (editor);
for (list = editor->buffer->baseline_tags; list; list = g_list_next (list))
{
GtkTextTag *tag = list->data;
if ((g_slist_find (tags, tag) &&
! g_slist_find (tags_on, tag)) ||
g_slist_find (tags_off, tag))
{
gimp_text_style_editor_set_baseline (editor, tag);
break;
}
}
if (! list)
gimp_text_style_editor_set_baseline (editor, NULL);
for (list = editor->toggles; list; list = g_list_next (list))
{
GtkToggleButton *toggle = list->data;
GtkTextTag *tag = g_object_get_data (G_OBJECT (toggle),
"tag");
gimp_text_style_editor_set_toggle (editor, toggle,
(g_slist_find (tags, tag) &&
! g_slist_find (tags_on, tag)) ||
g_slist_find (tags_off, tag));
}
{
GtkTextTag *tag;
tag = gimp_text_buffer_get_iter_kerning (editor->buffer, &cursor, NULL);
gimp_text_style_editor_set_kerning (editor, tag);
}
g_slist_free (tags);
g_slist_free (tags_on);
g_slist_free (tags_off);
}
return FALSE;
}
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);
}
static gboolean
on_view_draw (GtkSourceView *view,
cairo_t *cr,
GtkSourceGutter *gutter)
{
GdkWindow *window;
GtkTextView *text_view;
GArray *sizes;
GdkRectangle clip;
gint x, y;
gint y1, y2;
GArray *numbers;
GArray *pixels;
GArray *heights;
GtkTextIter cur;
gint cur_line;
gint count;
gint i;
GList *item;
GtkTextIter start;
GtkTextIter end;
GtkTextBuffer *buffer;
GdkRectangle background_area;
GdkRectangle cell_area;
GtkTextIter selection_start;
GtkTextIter selection_end;
gboolean has_selection;
gint idx;
GtkStyleContext *style_context;
GdkRGBA fg_color;
window = gtk_source_gutter_get_window (gutter);
if (window == NULL || !gtk_cairo_should_draw_window (cr, window))
{
return FALSE;
}
gtk_cairo_transform_to_window (cr, GTK_WIDGET (view), window);
text_view = GTK_TEXT_VIEW (view);
if (!gdk_cairo_get_clip_rectangle (cr, &clip))
{
return FALSE;
}
gutter->priv->is_drawing = TRUE;
buffer = gtk_text_view_get_buffer (text_view);
gdk_window_get_pointer (window, &x, &y, NULL);
y1 = clip.y;
y2 = y1 + clip.height;
/* get the extents of the line printing */
gtk_text_view_window_to_buffer_coords (text_view,
gutter->priv->window_type,
0,
y1,
NULL,
&y1);
gtk_text_view_window_to_buffer_coords (text_view,
gutter->priv->window_type,
0,
y2,
NULL,
&y2);
numbers = g_array_new (FALSE, FALSE, sizeof (gint));
pixels = g_array_new (FALSE, FALSE, sizeof (gint));
heights = g_array_new (FALSE, FALSE, sizeof (gint));
sizes = g_array_new (FALSE, FALSE, sizeof (gint));
calculate_gutter_size (gutter, sizes);
i = 0;
x = 0;
background_area.x = 0;
background_area.height = get_lines (text_view,
y1,
y2,
pixels,
heights,
numbers,
&count,
&start,
&end);
cell_area.x = gutter->priv->xpad;
cell_area.height = background_area.height;
gtk_text_view_buffer_to_window_coords (text_view,
gutter->priv->window_type,
0,
g_array_index (pixels, gint, 0),
NULL,
&background_area.y);
cell_area.y = background_area.y;
item = gutter->priv->renderers;
idx = 0;
style_context = gtk_widget_get_style_context (GTK_WIDGET (view));
gtk_style_context_get_color (style_context,
gtk_widget_get_state (GTK_WIDGET (view)),
&fg_color);
gdk_cairo_set_source_rgba (cr, &fg_color);
while (item)
{
Renderer *renderer = item->data;
gint xpad;
gint width;
width = g_array_index (sizes, gint, idx++);
if (gtk_source_gutter_renderer_get_visible (renderer->renderer))
{
gtk_source_gutter_renderer_get_padding (renderer->renderer,
&xpad,
NULL);
background_area.width = width;
cell_area.width = width - 2 * xpad;
cell_area.x = background_area.x + xpad;
cairo_save (cr);
gdk_cairo_rectangle (cr, &background_area);
cairo_clip (cr);
gtk_source_gutter_renderer_begin (renderer->renderer,
cr,
&background_area,
&cell_area,
&start,
&end);
cairo_restore (cr);
background_area.x += background_area.width;
}
item = g_list_next (item);
}
gtk_text_buffer_get_iter_at_mark (buffer,
&cur,
gtk_text_buffer_get_insert (buffer));
cur_line = gtk_text_iter_get_line (&cur);
gtk_text_buffer_get_selection_bounds (buffer,
&selection_start,
&selection_end);
has_selection = !gtk_text_iter_equal (&selection_start, &selection_end);
if (has_selection)
{
if (!gtk_text_iter_starts_line (&selection_start))
{
gtk_text_iter_set_line_offset (&selection_start, 0);
}
if (!gtk_text_iter_ends_line (&selection_end))
{
gtk_text_iter_forward_to_line_end (&selection_end);
}
}
for (i = 0; i < count; ++i)
{
gint pos;
gint line_to_paint;
end = start;
if (!gtk_text_iter_ends_line (&end))
{
gtk_text_iter_forward_to_line_end (&end);
}
gtk_text_view_buffer_to_window_coords (text_view,
gutter->priv->window_type,
0,
g_array_index (pixels, gint, i),
NULL,
&pos);
line_to_paint = g_array_index (numbers, gint, i);
background_area.y = pos;
background_area.height = g_array_index (heights, gint, i);
background_area.x = 0;
idx = 0;
for (item = gutter->priv->renderers; item; item = g_list_next (item))
{
Renderer *renderer;
gint width;
GtkSourceGutterRendererState state;
gint xpad;
gint ypad;
renderer = item->data;
width = g_array_index (sizes, gint, idx++);
if (!gtk_source_gutter_renderer_get_visible (renderer->renderer))
{
continue;
}
gtk_source_gutter_renderer_get_padding (renderer->renderer,
&xpad,
&ypad);
background_area.width = width;
cell_area.y = background_area.y + ypad;
cell_area.height = background_area.height - 2 * ypad;
cell_area.x = background_area.x + xpad;
cell_area.width = background_area.width - 2 * xpad;
state = GTK_SOURCE_GUTTER_RENDERER_STATE_NORMAL;
if (line_to_paint == cur_line)
{
state |= GTK_SOURCE_GUTTER_RENDERER_STATE_CURSOR;
}
if (has_selection &&
gtk_text_iter_in_range (&start,
&selection_start,
&selection_end))
{
state |= GTK_SOURCE_GUTTER_RENDERER_STATE_SELECTED;
}
if (renderer->prelit >= 0 && cell_area.y <= renderer->prelit && cell_area.y + cell_area.height >= renderer->prelit)
{
state |= GTK_SOURCE_GUTTER_RENDERER_STATE_PRELIT;
}
gtk_source_gutter_renderer_query_data (renderer->renderer,
&start,
&end,
state);
cairo_save (cr);
gdk_cairo_rectangle (cr, &background_area);
cairo_clip (cr);
/* Call render with correct area */
gtk_source_gutter_renderer_draw (renderer->renderer,
cr,
&background_area,
&cell_area,
&start,
&end,
state);
cairo_restore (cr);
background_area.x += background_area.width;
}
gtk_text_iter_forward_line (&start);
}
for (item = gutter->priv->renderers; item; item = g_list_next (item))
{
Renderer *renderer = item->data;
if (gtk_source_gutter_renderer_get_visible (renderer->renderer))
{
gtk_source_gutter_renderer_end (renderer->renderer);
}
}
g_array_free (numbers, TRUE);
g_array_free (pixels, TRUE);
g_array_free (heights, TRUE);
g_array_free (sizes, TRUE);
gutter->priv->is_drawing = FALSE;
return FALSE;
}
static int
delete_selection_in_gtk_text_view(GtkTextView *text_view,
enum UTextOrigin origin, int former_req_len,
int latter_req_len)
{
GtkTextIter current, start, end, tmp_start, tmp_end;
gboolean cursor_at_beginning = FALSE;
if (!gtk_text_view_get_buffer(text_view))
return -1;
if (gtk_text_buffer_get_selection_bounds(gtk_text_view_get_buffer(text_view),
&start, &end)) {
gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(text_view),
¤t,
gtk_text_buffer_get_mark(gtk_text_view_get_buffer(text_view),
"insert"));
if (gtk_text_iter_compare(&start, ¤t) == 0)
cursor_at_beginning = TRUE;
} else {
return -1;
}
if (origin == UTextOrigin_Beginning ||
(origin == UTextOrigin_Cursor && cursor_at_beginning)) {
tmp_start = start;
tmp_end = start;
if (latter_req_len >= 0) {
gtk_text_iter_forward_chars(&tmp_end, latter_req_len);
if (gtk_text_iter_compare(&tmp_end, &end) < 0)
end = tmp_end;
} else {
if (latter_req_len == UTextExtent_Line) {
gtk_text_view_forward_display_line_end(text_view, &tmp_end);
if (gtk_text_iter_compare(&tmp_end, &end) < 0)
end = tmp_end;
} else {
if (!(latter_req_len == UTextExtent_Full))
return -1;
}
}
} else if (origin == UTextOrigin_End ||
(origin == UTextOrigin_Cursor && !cursor_at_beginning)) {
tmp_start = end;
tmp_end = end;
if (former_req_len >= 0) {
gtk_text_iter_backward_chars(&tmp_start, former_req_len);
if (gtk_text_iter_compare(&tmp_start, &start) > 0)
start = tmp_start;
} else {
if (former_req_len == UTextExtent_Line) {
gtk_text_view_backward_display_line_start(text_view, &tmp_start);
if (gtk_text_iter_compare(&tmp_start, &start) > 0)
start = tmp_start;
} else {
if (!(former_req_len == UTextExtent_Full))
return -1;
}
}
} else {
return -1;
}
gtk_text_buffer_delete_interactive(gtk_text_view_get_buffer(text_view),
&start, &end, gtk_text_view_get_editable(text_view));
return 0;
}
int
im_uim_acquire_selection_text(IMUIMContext *uic, enum UTextOrigin origin,
int former_req_len, int latter_req_len,
char **former, char **latter)
{
gchar *former_start, *text = NULL, *p;
gint len, text_len;
int offset, err = 0;
gboolean cursor_at_beginning = FALSE;
if (GTK_IS_ENTRY(uic->widget)) {
gint start, end, current;
if (gtk_editable_get_selection_bounds(GTK_EDITABLE(uic->widget),
&start, &end)) {
text = gtk_editable_get_chars(GTK_EDITABLE(uic->widget), start, end);
current = gtk_editable_get_position(GTK_EDITABLE(uic->widget));
if (current == start)
cursor_at_beginning = TRUE;
}
} else if (GTK_IS_TEXT_VIEW(uic->widget)) {
GtkTextIter start, end, current;
if (gtk_text_view_get_buffer(GTK_TEXT_VIEW(uic->widget)) &&
gtk_text_buffer_get_selection_bounds(gtk_text_view_get_buffer(GTK_TEXT_VIEW(uic->widget)), &start, &end)) {
text = gtk_text_iter_get_visible_text(&start, &end);
gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(uic->widget)),
¤t,
gtk_text_buffer_get_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(uic->widget)), "insert"));
if (gtk_text_iter_compare(&start, ¤t) == 0)
cursor_at_beginning = TRUE;
}
} else {
/*
* We use GDK_SELECTION_PRIMARY for the rest of widget, which means it is
* impossible to guarantee whether the obtained one is the selected text on
* the target application.
*/
text = gtk_clipboard_wait_for_text(gtk_widget_get_clipboard(GTK_WIDGET(uic->widget), GDK_SELECTION_PRIMARY));
}
if (!text)
return -1;
len = strlen(text);
text_len = g_utf8_strlen(text, -1);
if (origin == UTextOrigin_Beginning ||
(origin == UTextOrigin_Cursor && cursor_at_beginning)) {
*former = NULL;
offset = 0;
if (latter_req_len >= 0) {
if (latter_req_len < text_len)
offset = text + len - g_utf8_offset_to_pointer(text, latter_req_len);
} else {
if (!(~latter_req_len & (~UTextExtent_Line | ~UTextExtent_Full))) {
g_free(text);
return -1;
}
}
*latter = g_strndup(text, len - offset);
if (latter_req_len == UTextExtent_Line && (p = strchr(*latter, '\n')))
*p = '\0';
} else if (origin == UTextOrigin_End ||
(origin == UTextOrigin_Cursor && !cursor_at_beginning)) {
offset = 0;
if (former_req_len >= 0) {
if (former_req_len < text_len)
offset = text_len - former_req_len;
} else {
if (!(~former_req_len & (~UTextExtent_Line | ~UTextExtent_Full))) {
g_free(text);
return -1;
}
}
former_start = g_utf8_offset_to_pointer(text, offset);
if (former_req_len == UTextExtent_Line &&
(p = strrchr(former_start, '\n')))
*former = g_strdup(p + 1);
else
*former = g_strndup(former_start, text + len - former_start);
*latter = NULL;
} else {
err = -1;
}
g_free(text);
return err;
}
static void
ide_editor_frame_actions_find (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
IdeEditorFrame *self = user_data;
GtkTextBuffer *buffer;
GtkDirectionType search_direction;
g_assert (IDE_IS_EDITOR_FRAME (self));
gtk_widget_set_visible (GTK_WIDGET (self->replace_entry), FALSE);
gtk_widget_set_visible (GTK_WIDGET (self->replace_button), FALSE);
gtk_widget_set_visible (GTK_WIDGET (self->replace_all_button), FALSE);
search_direction = (GtkDirectionType) g_variant_get_int32 (variant);
ide_source_view_set_search_direction (self->source_view,
search_direction);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self->source_view));
/*
* If the buffer currently has a selection, we prime the search entry with the
* selected text. If not, we use our previous search text in the case that it was
* cleared by the IdeSourceView internal state.
*/
if (gtk_text_buffer_get_has_selection (buffer))
{
GtkTextIter start_sel;
GtkTextIter end_sel;
g_autofree gchar *selected_text = NULL;
g_autofree gchar *escaped_selected_text = NULL;
GtkSourceSearchContext *search_context;
GtkSourceSearchSettings *search_settings;
gtk_text_buffer_get_selection_bounds (buffer, &start_sel, &end_sel);
selected_text = gtk_text_buffer_get_text (buffer, &start_sel, &end_sel, FALSE);
search_context = ide_source_view_get_search_context (self->source_view);
search_settings = gtk_source_search_context_get_settings (search_context);
if (gtk_source_search_settings_get_regex_enabled (search_settings))
escaped_selected_text = g_regex_escape_string (selected_text, -1);
else
escaped_selected_text = gtk_source_utils_escape_search_text (selected_text);
gtk_entry_set_text (GTK_ENTRY (self->search_entry), escaped_selected_text);
}
else
{
GtkSourceSearchContext *search_context;
GtkSourceSearchSettings *search_settings;
const gchar *search_text;
search_context = ide_source_view_get_search_context (self->source_view);
search_settings = gtk_source_search_context_get_settings (search_context);
search_text = gtk_source_search_settings_get_search_text (search_settings);
if ((search_text != NULL) && (search_text [0] != '\0'))
gtk_entry_set_text (GTK_ENTRY (self->search_entry), search_text);
else if (self->previous_search_string != NULL)
gtk_entry_set_text (GTK_ENTRY (self->search_entry), self->previous_search_string);
}
gtk_revealer_set_reveal_child (self->search_revealer, TRUE);
gtk_widget_grab_focus (GTK_WIDGET (self->search_entry));
}
gboolean
gimp_text_buffer_save (GimpTextBuffer *buffer,
GFile *file,
gboolean selection_only,
GError **error)
{
GOutputStream *output;
GtkTextIter start_iter;
GtkTextIter end_iter;
gchar *text_contents;
GError *my_error = NULL;
g_return_val_if_fail (GIMP_IS_TEXT_BUFFER (buffer), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
output = G_OUTPUT_STREAM (g_file_replace (file,
NULL, FALSE, G_FILE_CREATE_NONE,
NULL, &my_error));
if (! output)
{
g_set_error (error, my_error->domain, my_error->code,
_("Could not open '%s' for writing: %s"),
gimp_file_get_utf8_name (file), my_error->message);
g_clear_error (&my_error);
return FALSE;
}
if (selection_only)
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (buffer),
&start_iter, &end_iter);
else
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer),
&start_iter, &end_iter);
text_contents = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (buffer),
&start_iter, &end_iter, TRUE);
if (text_contents)
{
gint text_length = strlen (text_contents);
if (! g_output_stream_write_all (output, text_contents, text_length,
NULL, NULL, &my_error))
{
g_set_error (error, my_error->domain, my_error->code,
_("Writing palette file '%s' failed: %s"),
gimp_file_get_utf8_name (file), my_error->message);
g_clear_error (&my_error);
g_free (text_contents);
g_object_unref (output);
return FALSE;
}
g_free (text_contents);
}
g_object_unref (output);
return TRUE;
}
static gboolean
run_search (PlumaView *view,
gboolean wrap_around,
gboolean search_backwards)
{
PlumaDocument *doc;
GtkTextIter start_iter;
GtkTextIter match_start;
GtkTextIter match_end;
gboolean found = FALSE;
doc = PLUMA_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
if (!search_backwards)
{
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
NULL,
&start_iter);
found = pluma_document_search_forward (doc,
&start_iter,
NULL,
&match_start,
&match_end);
}
else
{
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start_iter,
NULL);
found = pluma_document_search_backward (doc,
NULL,
&start_iter,
&match_start,
&match_end);
}
if (!found && wrap_around)
{
if (!search_backwards)
found = pluma_document_search_forward (doc,
NULL,
NULL, /* FIXME: set the end_inter */
&match_start,
&match_end);
else
found = pluma_document_search_backward (doc,
NULL, /* FIXME: set the start_inter */
NULL,
&match_start,
&match_end);
}
if (found)
{
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc),
&match_start);
gtk_text_buffer_move_mark_by_name (GTK_TEXT_BUFFER (doc),
"selection_bound",
&match_end);
pluma_view_scroll_to_cursor (view);
}
else
{
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc),
&start_iter);
}
return found;
}
/**************************************************************************
Click a link.
**************************************************************************/
static gboolean event_after(GtkWidget *text_view, GdkEventButton *event)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
GSList *tags, *tagp;
gint x, y;
struct tile *ptile = NULL;
if (event->type != GDK_BUTTON_RELEASE || event->button != 1) {
return FALSE;
}
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
/* We shouldn't follow a link if the user has selected something. */
gtk_text_buffer_get_selection_bounds(buffer, &start, &end);
if (gtk_text_iter_get_offset(&start) != gtk_text_iter_get_offset(&end)) {
return FALSE;
}
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW (text_view),
GTK_TEXT_WINDOW_WIDGET,
event->x, event->y, &x, &y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(text_view), &iter, x, y);
if ((tags = gtk_text_iter_get_tags(&iter))) {
for (tagp = tags; tagp; tagp = tagp->next) {
GtkTextTag *tag = tagp->data;
enum text_link_type type =
GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tag), "type"));
if (type != 0) {
/* This is a link. */
int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tag), "id"));
ptile = NULL;
/* Real type is type - 1.
* See comment in apply_text_tag() for g_object_set_data(). */
type--;
switch (type) {
case TLT_CITY:
{
struct city *pcity = game_city_by_number(id);
if (pcity) {
ptile = client_city_tile(pcity);
} else {
output_window_append(ftc_client, _("This city isn't known!"));
}
}
break;
case TLT_TILE:
ptile = index_to_tile(id);
if (!ptile) {
output_window_append(ftc_client,
_("This tile doesn't exist in this game!"));
}
break;
case TLT_UNIT:
{
struct unit *punit = game_unit_by_number(id);
if (punit) {
ptile = unit_tile(punit);
} else {
output_window_append(ftc_client, _("This unit isn't known!"));
}
}
break;
}
if (ptile) {
center_tile_mapcanvas(ptile);
link_mark_restore(type, id);
gtk_widget_grab_focus(GTK_WIDGET(map_canvas));
}
}
}
g_slist_free(tags);
}
return FALSE;
}
static gboolean
gb_vim_command_search (GtkSourceView *source_view,
const gchar *command,
const gchar *options,
GError **error)
{
GtkTextBuffer *buffer;
const gchar *search_begin = NULL;
const gchar *search_end = NULL;
const gchar *replace_begin = NULL;
const gchar *replace_end = NULL;
gchar *search_text = NULL;
gchar *replace_text = NULL;
gunichar separator;
g_assert (g_str_has_prefix (command, "%s") || g_str_has_prefix (command, "s"));
if (*command == '%')
command++;
command++;
separator = g_utf8_get_char (command);
if (!separator)
goto invalid_request;
search_begin = command = g_utf8_next_char (command);
for (; *command; command = g_utf8_next_char (command))
{
if (*command == '\\')
{
command = g_utf8_next_char (command);
if (!*command)
goto invalid_request;
continue;
}
if (g_utf8_get_char (command) == separator)
{
search_end = command;
break;
}
}
if (!search_end)
goto invalid_request;
replace_begin = command = g_utf8_next_char (command);
for (; *command; command = g_utf8_next_char (command))
{
if (*command == '\\')
{
command = g_utf8_next_char (command);
if (!*command)
goto invalid_request;
continue;
}
if (g_utf8_get_char (command) == separator)
{
replace_end = command;
break;
}
}
if (!replace_end)
goto invalid_request;
command = g_utf8_next_char (command);
if (*command)
{
for (; *command; command++)
{
switch (*command)
{
case 'g':
break;
/* what other options are supported? */
default:
break;
}
}
}
search_text = g_strndup (search_begin, search_end - search_begin);
replace_text = g_strndup (replace_begin, replace_end - replace_begin);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view));
if (gtk_text_buffer_get_has_selection (buffer))
{
GtkTextIter begin;
GtkTextIter end;
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
gtk_text_iter_order (&begin, &end);
gb_vim_do_search_and_replace (buffer, &begin, &end, search_text, replace_text, FALSE);
}
else
gb_vim_do_search_and_replace (buffer, NULL, NULL, search_text, replace_text, TRUE);
g_free (search_text);
g_free (replace_text);
return TRUE;
invalid_request:
g_set_error (error,
GB_VIM_ERROR,
GB_VIM_ERROR_UNKNOWN_OPTION,
_("Invalid search and replace request"));
return FALSE;
}
bool gTextArea::isSelected()
{
return gtk_text_buffer_get_selection_bounds(_buffer, NULL, NULL);
//return gtk_text_buffer_get_has_selection(buf); // Only since 2.10
}
/*
static void cb_mark_set(GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextMark *mark)
{
if (gtk_text_mark_get_name(mark))
{g_print(gtk_text_mark_get_name(mark));
}else g_print("|");
menu_sensitivity_from_selection_bound(
gtk_text_buffer_get_selection_bounds(buffer, NULL, NULL));
}
*/
static void cb_mark_changed(GtkTextBuffer *buffer)
{
menu_sensitivity_from_selection_bound(
gtk_text_buffer_get_selection_bounds(buffer, NULL, NULL));
}
gboolean dump_selection_info(GtkWidget *calling_widget, text_dialog_widgets *text_widgets)
{
// Local variables
GtkTextIter buffer_end_iter;
gint buffer_end_offset;
gint end_offset;
gint i;
guint loop_counter;
GtkTextIter loop_iter;
guint num_tags;
GtkTextIter selection_end;
GtkTextIter selection_start;
gint start_offset;
GSList *tag_list;
gchar *tag_name;
GtkTextTag *tag_ptr;
GtkTextBuffer *text_buffer;
gboolean text_selected;
GtkWidget *text_view;
// Initialisation
text_view = text_widgets->text_view;
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
// If no text is selected then we skip the rest of the function
text_selected = gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(text_buffer), &selection_start, &selection_end);
gtk_text_iter_order(&selection_start, &selection_end);
// Dump a count of tags that are present from the start to the end of the selection
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER(text_buffer), &buffer_end_iter);
start_offset = gtk_text_iter_get_offset(&selection_start);
end_offset = gtk_text_iter_get_offset(&selection_end);
buffer_end_offset = gtk_text_iter_get_offset(&buffer_end_iter);
// Display separator
printf("*******************\n");
printf("*******************\n");
// Display the characters up to the start of the selection (if any)
for (i = 0; i < start_offset; i++)
{
gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(text_buffer), &loop_iter, i);
tag_list = gtk_text_iter_get_tags(&loop_iter);
num_tags = g_slist_length(tag_list);
printf("Offset: %d\t # tags at this offset: %d\n", i, num_tags);
for (loop_counter = 0; loop_counter < num_tags; loop_counter++)
{
tag_ptr = g_slist_nth_data(tag_list, loop_counter);
if (tag_ptr->name == NULL)
{
printf("Anonymous tag with no name\n");
}
else
{
tag_name = tag_ptr->name;
printf("Tag name: %s\n", tag_name);
}
}
g_slist_free(tag_list);
printf("Character at this offset: %c\n", gtk_text_iter_get_char(&loop_iter));
}
// Display separator
printf("*** Selection start ***\n");
// Display the characters in the selection (if any)
for (i = start_offset; i < end_offset; i++)
{
gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(text_buffer), &loop_iter, i);
tag_list = gtk_text_iter_get_tags(&loop_iter);
num_tags = g_slist_length(tag_list);
printf("Offset: %d\t # tags at this offset: %d\n", i, num_tags);
for (loop_counter = 0; loop_counter < num_tags; loop_counter++)
{
tag_ptr = g_slist_nth_data(tag_list, loop_counter);
if (tag_ptr->name == NULL)
{
printf("Anonymous tag with no name\n");
}
else
{
tag_name = tag_ptr->name;
printf("Tag name: %s\n", tag_name);
}
}
g_slist_free(tag_list);
printf("Character at this offset: %c\n", gtk_text_iter_get_char(&loop_iter));
}
// Display separator
printf("*** Selection end ***\n");
// Display the characters after the end of the selection (if any)
for (i = end_offset; i < buffer_end_offset; i++)
{
gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(text_buffer), &loop_iter, i);
tag_list = gtk_text_iter_get_tags(&loop_iter);
num_tags = g_slist_length(tag_list);
printf("Offset: %d\t # tags at this offset: %d\n", i, num_tags);
for (loop_counter = 0; loop_counter < num_tags; loop_counter++)
{
tag_ptr = g_slist_nth_data(tag_list, loop_counter);
if (tag_ptr->name == NULL)
{
printf("Anonymous tag with no name\n");
}
else
{
tag_name = tag_ptr->name;
printf("Tag name: %s\n", tag_name);
}
}
g_slist_free(tag_list);
printf("Character at this offset: %c\n", gtk_text_iter_get_char(&loop_iter));
}
// Add a newline separator to help space things visually in the dump
printf("\n");
return FALSE;
}
