static void
smartquotes_delete_cb(GtkTextBuffer *buffer, GtkTextIter *i1, GtkTextIter *i2) {
gunichar c;
GtkTextIter i = *i1;
while (gtk_text_iter_in_range(&i, i1, i2)) {
c = gtk_text_iter_get_char(&i);
if (count_quotes(c)) {
smartquotes_begin(buffer);
break;
}
gtk_text_iter_forward_char(&i);
}
}
static void bmark_popup_menu_goto_lcb(GtkWidget * widget, gpointer user_data)
{
Tbmark *b;
GtkTextIter it;
if (!user_data)
return;
b = get_current_bmark(BFWIN(user_data));
if (!b)
return;
if (b->filepath && !b->doc) {
/* check if that document _is_ open */
Tdocument *tmpdoc;
GList *doclist = return_allwindows_documentlist();
tmpdoc = documentlist_return_document_from_filename(doclist, b->filepath);
g_list_free(doclist);
if (tmpdoc == NULL) {
if (!g_file_test(b->filepath, G_FILE_TEST_EXISTS)) {
gchar *string = g_strdup_printf(_("Could not find the file \"%s\"."), b->filepath);
error_dialog(BFWIN(user_data)->main_window, string,
_("This bookmark is set in a file that no longer exists."));
g_free(string);
return;
}
tmpdoc = doc_new_with_file(BFWIN(user_data), b->filepath, FALSE, TRUE);
}
/* now I have to check all bookmarks */
bmark_set_for_doc(tmpdoc);
}
if (b->doc) {
GdkRectangle visirect;
GtkTextIter visi_so, visi_eo;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(b->doc->view),&visirect);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_so, visirect.x, visirect.y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_eo, visirect.x + visirect.width, visirect.y + visirect.height);
gtk_text_buffer_get_iter_at_mark(b->doc->buffer, &it, b->mark);
gtk_text_buffer_place_cursor(b->doc->buffer, &it);
if (!gtk_text_iter_in_range(&it,&visi_so,&visi_eo)) {
DEBUG_MSG("bmark_popup_menu_goto_lcb, cursor NOT visible!\n");
/* gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(b->doc->view), b->mark); */
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(b->doc->view),b->mark,0.0,
TRUE,0.5,0.5);
}
if (b->doc != BFWIN(user_data)->current_document)
switch_to_document_by_pointer(BFWIN(user_data), b->doc);
gtk_widget_grab_focus(b->doc->view);
}
}
static gboolean cb_button_press_event(GtkWidget *view, GdkEventButton *event)
{
GtkTextIter iter, start, end;
gint x, y;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
if ((event->button) == 3 && (event->type == GDK_BUTTON_PRESS)) {
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(view),
gtk_text_view_get_window_type(GTK_TEXT_VIEW(view), event->window),
(gint)event->x, (gint)event->y, &x, &y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(view), &iter, x, y);
gtk_text_buffer_get_selection_bounds(buffer, &start, &end);
if (!gtk_text_iter_in_range(&iter, &start, &end))
gtk_text_buffer_place_cursor(buffer, &iter);
}
return FALSE;
}
/**
* bmark_text_for_offset:
*
* will use offset if itoffset is NULL
* will use itoffset if not NULL
*/
static gchar *bmark_text_for_offset(Tdocument *doc, GtkTextIter *itoffset, gint offset) {
GtkTextIter it, eit, sit;
if (itoffset) {
it = *itoffset;
} else {
gtk_text_buffer_get_iter_at_offset(doc->buffer,&it,offset);
}
sit = eit = it;
gtk_text_iter_forward_to_line_end(&eit);
gtk_text_iter_forward_chars(&sit, BMARK_SHOW_NUM_TEXT_CHARS);
if (!gtk_text_iter_in_range(&sit, &it, &eit))
sit = eit;
#ifdef DEBUG
{
gchar *tmp = gtk_text_iter_get_text(&it, &sit);
DEBUG_MSG("bmark_text_for_offset, text=%s\n",tmp);
g_free(tmp);
}
#endif
return gtk_text_iter_get_text(&it, &sit);
}
/* this function will add a bookmark to the current document at current cursor / selection */
static void bmark_add_current_doc_backend(Tbfwin *bfwin, const gchar *name, gint offset, gboolean is_temp) {
GtkTextIter it, eit, sit;
DEBUG_MSG("bmark_add_backend, adding bookmark at offset=%d for bfwin=%p\n",offset,bfwin);
/* create bookmark */
gtk_text_buffer_get_iter_at_offset(DOCUMENT(bfwin->current_document)->buffer,&it,offset);
/* if there is a selection, and the offset is within the selection, we'll use it as text content */
if (gtk_text_buffer_get_selection_bounds(DOCUMENT(bfwin->current_document)->buffer,&sit,&eit)
&& gtk_text_iter_in_range(&it,&sit,&eit)) {
gchar *text = gtk_text_iter_get_text(&sit, &eit);
bmark_add_backend(DOCUMENT(bfwin->current_document), &sit, offset, name, text, is_temp);
g_free(text);
} else {
gchar *text;
text = bmark_text_for_offset(DOCUMENT(bfwin->current_document), &it, offset);
bmark_add_backend(DOCUMENT(bfwin->current_document), &it, offset, name, text, is_temp);
g_free(text);
}
if (bfwin->bmark) {
/* only if there is a left panel we should do this */
gtk_tree_view_expand_all(bfwin->bmark);
gtk_widget_grab_focus(bfwin->current_document->view);
}
}
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;
}
GtkTextRegion *
gtk_text_region_intersect (GtkTextRegion *region,
const GtkTextIter *_start,
const GtkTextIter *_end)
{
GList *start_node, *end_node, *node;
GtkTextIter sr_start_iter, sr_end_iter;
Subregion *sr, *new_sr;
gboolean done;
GtkTextRegion *new_region;
GtkTextIter start, end;
g_return_val_if_fail (region != NULL && _start != NULL && _end != NULL, NULL);
start = *_start;
end = *_end;
gtk_text_iter_order (&start, &end);
/* find bounding subregions */
start_node = find_nearest_subregion (region, &start, NULL, FALSE, FALSE);
end_node = find_nearest_subregion (region, &end, start_node, TRUE, FALSE);
/* easy case first */
if (start_node == NULL || end_node == NULL || end_node == start_node->prev)
return NULL;
new_region = gtk_text_region_new (region->buffer);
done = FALSE;
sr = start_node->data;
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_start_iter, sr->start);
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_end_iter, sr->end);
/* starting node */
if (gtk_text_iter_in_range (&start, &sr_start_iter, &sr_end_iter)) {
new_sr = g_new0 (Subregion, 1);
new_region->subregions = g_list_prepend (new_region->subregions, new_sr);
new_sr->start = gtk_text_buffer_create_mark (new_region->buffer, NULL,
&start, TRUE);
if (start_node == end_node) {
/* things will finish shortly */
done = TRUE;
if (gtk_text_iter_in_range (&end, &sr_start_iter, &sr_end_iter))
new_sr->end = gtk_text_buffer_create_mark (new_region->buffer,
NULL, &end, FALSE);
else
new_sr->end = gtk_text_buffer_create_mark (new_region->buffer,
NULL, &sr_end_iter,
FALSE);
} else {
new_sr->end = gtk_text_buffer_create_mark (new_region->buffer, NULL,
&sr_end_iter, FALSE);
}
node = start_node->next;
} else {
/* start should be the same as the subregion, so copy it in the loop */
node = start_node;
}
if (!done) {
while (node != end_node) {
/* copy intermediate subregions verbatim */
sr = node->data;
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_start_iter,
sr->start);
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_end_iter, sr->end);
new_sr = g_new0 (Subregion, 1);
new_region->subregions = g_list_prepend (new_region->subregions, new_sr);
new_sr->start = gtk_text_buffer_create_mark (new_region->buffer, NULL,
&sr_start_iter, TRUE);
new_sr->end = gtk_text_buffer_create_mark (new_region->buffer, NULL,
&sr_end_iter, FALSE);
/* next node */
node = node->next;
}
/* ending node */
sr = node->data;
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_start_iter, sr->start);
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_end_iter, sr->end);
new_sr = g_new0 (Subregion, 1);
new_region->subregions = g_list_prepend (new_region->subregions, new_sr);
new_sr->start = gtk_text_buffer_create_mark (new_region->buffer, NULL,
&sr_start_iter, TRUE);
if (gtk_text_iter_in_range (&end, &sr_start_iter, &sr_end_iter))
new_sr->end = gtk_text_buffer_create_mark (new_region->buffer, NULL,
&end, FALSE);
else
new_sr->end = gtk_text_buffer_create_mark (new_region->buffer, NULL,
&sr_end_iter, FALSE);
}
new_region->subregions = g_list_reverse (new_region->subregions);
return new_region;
}
void
gtk_text_region_subtract (GtkTextRegion *region,
const GtkTextIter *_start,
const GtkTextIter *_end)
{
GList *start_node, *end_node, *node;
GtkTextIter sr_start_iter, sr_end_iter;
gboolean done;
gboolean start_is_outside, end_is_outside;
Subregion *sr;
GtkTextIter start, end;
g_return_if_fail (region != NULL && _start != NULL && _end != NULL);
start = *_start;
end = *_end;
DEBUG (g_print ("---\n"));
DEBUG (gtk_text_region_debug_print (region));
DEBUG (g_message ("region_substract (%d, %d)",
gtk_text_iter_get_offset (&start),
gtk_text_iter_get_offset (&end)));
gtk_text_iter_order (&start, &end);
/* find bounding subregions */
start_node = find_nearest_subregion (region, &start, NULL, FALSE, FALSE);
end_node = find_nearest_subregion (region, &end, start_node, TRUE, FALSE);
/* easy case first */
if (start_node == NULL || end_node == NULL || end_node == start_node->prev)
return;
/* deal with the start point */
start_is_outside = end_is_outside = FALSE;
sr = start_node->data;
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_start_iter, sr->start);
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_end_iter, sr->end);
if (gtk_text_iter_in_range (&start, &sr_start_iter, &sr_end_iter) &&
!gtk_text_iter_equal (&start, &sr_start_iter)) {
/* the starting point is inside the first subregion */
if (gtk_text_iter_in_range (&end, &sr_start_iter, &sr_end_iter) &&
!gtk_text_iter_equal (&end, &sr_end_iter)) {
/* the ending point is also inside the first
subregion: we need to split */
Subregion *new_sr = g_new0 (Subregion, 1);
new_sr->end = sr->end;
new_sr->start = gtk_text_buffer_create_mark (region->buffer,
NULL, &end, TRUE);
start_node = g_list_insert_before (start_node, start_node->next, new_sr);
sr->end = gtk_text_buffer_create_mark (region->buffer,
NULL, &start, FALSE);
/* no further processing needed */
DEBUG (g_message ("subregion splitted"));
return;
} else {
/* the ending point is outside, so just move
the end of the subregion to the starting point */
gtk_text_buffer_move_mark (region->buffer, sr->end, &start);
}
} else {
/* the starting point is outside (and so to the left)
of the first subregion */
DEBUG (g_message ("start is outside"));
start_is_outside = TRUE;
}
/* deal with the end point */
if (start_node != end_node) {
sr = end_node->data;
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_start_iter, sr->start);
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_end_iter, sr->end);
}
if (gtk_text_iter_in_range (&end, &sr_start_iter, &sr_end_iter) &&
!gtk_text_iter_equal (&end, &sr_end_iter)) {
/* ending point is inside, move the start mark */
gtk_text_buffer_move_mark (region->buffer, sr->start, &end);
} else {
end_is_outside = TRUE;
DEBUG (g_message ("end is outside"));
}
/* finally remove any intermediate subregions */
done = FALSE;
node = start_node;
while (!done) {
if (node == end_node)
/* we are done, exit in the next iteration */
done = TRUE;
if ((node == start_node && !start_is_outside) ||
(node == end_node && !end_is_outside)) {
/* skip starting or ending node */
node = node->next;
} else {
GList *l = node->next;
sr = node->data;
gtk_text_buffer_delete_mark (region->buffer, sr->start);
gtk_text_buffer_delete_mark (region->buffer, sr->end);
g_free (sr);
region->subregions = g_list_delete_link (region->subregions,
node);
node = l;
}
}
++region->time_stamp;
DEBUG (gtk_text_region_debug_print (region));
/* now get rid of empty subregions */
gtk_text_region_clear_zero_length_subregions (region);
DEBUG (gtk_text_region_debug_print (region));
}
void CheckCapitalization::check_suspicious_capitalization(ustring & text)
/*
Checks on suspicious capitalization, like "bOat" or "BOat".
There are exceptions to this check.
*/
{
// Load text into buffer.
ustring text2(text);
text2.append(" ");
GtkTextBuffer *textbuffer;
textbuffer = gtk_text_buffer_new(NULL);
gtk_text_buffer_set_text(textbuffer, text2.c_str(), -1);
// Iterators.
GtkTextIter startiter, enditer;
// Check all separate words.
gtk_text_buffer_get_start_iter(textbuffer, &enditer);
while (gtk_text_iter_forward_word_end(&enditer)) {
startiter = enditer;
gtk_text_iter_backward_word_start(&startiter);
vector < bool > capspattern;
unsigned int capscount = 0;
GtkTextIter iter = startiter;
while (gtk_text_iter_in_range(&iter, &startiter, &enditer)) {
bool upper = g_unichar_isupper(gtk_text_iter_get_char(&iter));
capspattern.push_back(upper);
if (upper)
capscount++;
gtk_text_iter_forward_char(&iter);
}
// No further checking if words are too short.
if (capspattern.size() < 2)
continue;
// No further checking if only small letters.
if (capscount == 0)
continue;
// No further checking if all capitals.
if (capscount == capspattern.size())
continue;
// No further checking if first letter capitalized only.
if ((capspattern[0]) && (capscount == 1))
continue;
// Ok, there could be a problem of mixed capitalization.
// Get the prefix before the first capital, and the suffix after it.
ustring word = gtk_text_iter_get_text(&startiter, &enditer);
ustring uncapitalized_prefix;
ustring capitalized_suffix;
for (unsigned int i = 1; i < capspattern.size(); i++) {
if (capspattern[i]) {
uncapitalized_prefix = word.substr(0, i);
capitalized_suffix = word.substr(i, word.length() - i);
break;
}
}
// See whether the suffix is properly capitalized.
unsigned int suffix_capital_count = 0;
for (unsigned int i = 0; i < capitalized_suffix.length(); i++) {
if (g_unichar_isupper(g_utf8_get_char(capitalized_suffix.substr(i, 1).c_str())))
suffix_capital_count++;
}
bool suffix_properly_capitalized = false;
if (suffix_capital_count == 1)
suffix_properly_capitalized = true;
if (suffix_capital_count == capitalized_suffix.length())
suffix_properly_capitalized = true;
// Give message and continue if capitalization error in suffix, but only
// if this so-called wrongly capitalized suffix has not been approved af.
if (!suffix_properly_capitalized) {
if (capitalized_suffixes.find(capitalized_suffix) == capitalized_suffixes.end()) {
mixed_capitalization_message(word);
continue;
}
}
// No further checking if this uncapitalized prefix is in the list,
// or any is allowed.
if (uncapitalized_prefixes.find(uncapitalized_prefix) != uncapitalized_prefixes.end())
continue;
if (allow_any_uncapitalized_prefixes)
continue;
// Ok, not in the list. Try again with lower case initial.
ustring initial = uncapitalized_prefix.substr(0, 1);
initial = initial.casefold();
uncapitalized_prefix.replace(0, 1, initial);
if (uncapitalized_prefixes.find(uncapitalized_prefix) != uncapitalized_prefixes.end())
continue;
// No further checking if the suffix is in the list of approved suffixes.
if (capitalized_suffixes.find(capitalized_suffix) != capitalized_suffixes.end())
continue;
// Ok, not found, but it could be this suffix is in all capitals. Handle that.
initial = capitalized_suffix.substr(0, 1);
capitalized_suffix.erase(0, 1);
capitalized_suffix = capitalized_suffix.casefold();
capitalized_suffix.insert(0, initial);
if (capitalized_suffixes.find(capitalized_suffix) != capitalized_suffixes.end())
continue;
// Ok, it appears we've got an error here -> give message.
mixed_capitalization_message(word);
}
// Free memory
g_object_unref(textbuffer);
}
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;
}
