/* \brief callback on a style button (h1, h2, h3, p)
*
*
*/
static void
item_event(GtkWidget *button, gchar *data)
{
GtkTextIter iter_start, iter_end;
gchar *current_style_name;
if(board_paused)
return;
current_style_name = (char *)data;
selected_tag = get_tag_from_name(current_style_name);
set_default_tag(buffer, selected_tag);
gtk_text_buffer_get_iter_at_mark(buffer,
&iter_start,
gtk_text_buffer_get_insert (buffer));
gtk_text_iter_set_line_offset(&iter_start, 0);
iter_end = iter_start;
gtk_text_iter_forward_to_line_end(&iter_end);
gtk_text_buffer_remove_all_tags(buffer,
&iter_start,
&iter_end);
gtk_text_buffer_apply_tag_by_name(buffer,
current_style_name,
&iter_start,
&iter_end);
gtk_widget_grab_focus(view);
return;
}
static void
wrap_line (GtkTextBuffer *buffer,
GtkTextIter *iter,
gchar *text,
gint count,
gpointer data)
{
gint chars = gtk_text_iter_get_chars_in_line (iter);
if ( chars > DOC_LINE_LENGTH )
{
GtkTextIter line_fold = *iter;
GtkTextIter cursor;
gtk_text_iter_set_line_offset (&line_fold, DOC_LINE_LENGTH);
gtk_text_buffer_insert (buffer, &line_fold, "\r\n", 2);
cursor = line_fold;
gtk_text_iter_forward_to_line_end (&cursor);
gtk_text_buffer_place_cursor (buffer, &cursor);
}
}
void
gui_editor_toggle_mark_at_line (GUIEditor * self, gint line_no)
{
g_assert (self);
GtkTextIter line_start, line_end;
GSList *marker_list;
GtkSourceMark *marker;
/* get line bounds */
gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (self->buffer), &line_start, line_no);
line_end = line_start;
gtk_text_iter_forward_to_line_end (&line_end);
/* get the breakpoint markers already in the line */
marker_list = gtk_source_buffer_get_source_marks_at_line (self->buffer, line_no, MARKER_BREAKPOINT);
if (marker_list != NULL && g_slist_length(marker_list)!=0)
{
/* markers were found, so delete them */
gtk_source_buffer_remove_source_marks (self->buffer, &line_start, &line_end, MARKER_BREAKPOINT);
}
else
{
/* no marker found -> create one */
marker = gtk_source_buffer_create_source_mark (self->buffer, NULL, MARKER_BREAKPOINT, &(line_start));
}
g_slist_free (marker_list);
}
gboolean
gui_editor_is_marked (GUIEditor * self, gint ln)
{
GtkTextIter line_start, line_end;
GSList *list_iter;
/* get line bounds */
gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (self->buffer), &line_start, ln);
line_end = line_start;
gtk_text_iter_forward_to_line_end (&line_end);
/* get the markers already in the line */
list_iter = gtk_source_buffer_get_source_marks_at_iter (self->buffer, &line_start, NULL);
/* search for the breakpoint marker */
while (list_iter != NULL)
{
GtkSourceMark *tmp = list_iter->data;
const gchar *tmp_type = gtk_source_mark_get_category (tmp);
if (tmp_type && !strcmp (tmp_type, MARKER_BREAKPOINT))
{
return TRUE;
}
list_iter = g_slist_next (list_iter);
}
return FALSE;
}
void
apotheke_highlight_buffer_diff (GtkTextBuffer *buffer, GtkTextIter *start)
{
GtkTextIter *end;
GtkTextIter *word_end;
gchar *c;
if (!gtk_text_iter_starts_line (start))
gtk_text_iter_set_line_offset (start, 0);
while (!gtk_text_iter_is_end (start)) {
end = gtk_text_iter_copy (start);
if (!gtk_text_iter_forward_to_line_end (end))
break;
word_end = gtk_text_iter_copy (start);
gtk_text_iter_forward_char (word_end);
c = gtk_text_iter_get_text (start, word_end);
if (g_ascii_strcasecmp ("+", c) == 0) {
gtk_text_buffer_apply_tag_by_name (buffer,
"diff-added",
start, end);
}
else if (g_ascii_strcasecmp ("-", c) == 0) {
gtk_text_buffer_apply_tag_by_name (buffer,
"diff-removed",
start, end);
}
gtk_text_iter_forward_line (start);
}
}
/* Links can also be activated by clicking */
static void
follow_if_link (GtkWidget *text_view, GtkTextIter *iter)
{
GSList *tags = NULL, *tagp = NULL;
tags = gtk_text_iter_get_tags (iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next)
{
gchar *tag_name;
GtkTextTag *tag = tagp->data;
g_object_get (G_OBJECT (tag), "name", &tag_name, NULL);
if ( g_ascii_strcasecmp(tag_name, "link") == 0)
{
GtkTextIter iter_end = *iter;
GtkTextIter iter_start = iter_end;
gtk_text_iter_backward_sentence_start(&iter_start);
gtk_text_iter_forward_to_line_end(&iter_end);
char *result = \
escape(gtk_text_buffer_get_text(buffer,
&iter_start,
&iter_end,
0));
gtk_show_uri(NULL, result, GDK_CURRENT_TIME, NULL);
g_free(result);
}
}
if(tags)
g_slist_free (tags);
}
/* If the last char is a newline, remove it from the buffer (otherwise
GtkTextView shows it as an empty line). See bug #324942. */
static void
remove_ending_newline (GeditDocumentOutputStream *stream)
{
GtkTextIter end;
GtkTextIter start;
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (stream->priv->doc), &end);
start = end;
gtk_text_iter_set_line_offset (&start, 0);
if (gtk_text_iter_ends_line (&start) &&
gtk_text_iter_backward_line (&start))
{
if (!gtk_text_iter_ends_line (&start))
{
gtk_text_iter_forward_to_line_end (&start);
}
/* Delete the empty line which is from 'start' to 'end' */
gtk_text_buffer_delete (GTK_TEXT_BUFFER (stream->priv->doc),
&start,
&end);
}
}
static void
text_inserted_after_cb (GbColorPickerDocumentMonitor *self,
GtkTextIter *iter,
gchar *text,
gint len,
GtkTextBuffer *buffer)
{
GtkTextIter begin, end;
gint offset;
g_assert (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self));
g_assert (GTK_IS_TEXT_BUFFER (buffer));
g_assert (iter != NULL);
begin = *iter;
offset = gtk_text_iter_get_offset (&begin);
gtk_text_iter_set_offset (&begin, offset - len);
gtk_text_iter_set_line_offset (&begin, 0);
end = *iter;
if (!gtk_text_iter_ends_line (&end))
gtk_text_iter_forward_to_line_end (&end);
gb_color_picker_document_monitor_queue_colorize (self, &begin, &end);
}
static void
text_inserted_cb (GbColorPickerDocumentMonitor *self,
GtkTextIter *cursor,
gchar *text,
gint len,
GtkTextBuffer *buffer)
{
g_autoptr(GstyleColor) color = NULL;
GtkTextTag *tag;
GtkTextIter begin, end;
g_assert (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self));
g_assert (GTK_IS_TEXT_BUFFER (buffer));
g_assert (cursor != NULL);
tag = gb_color_picker_helper_get_tag_at_iter (cursor, &color, &begin, &end);
if (tag != NULL )
{
gtk_text_iter_set_line_offset (&begin, 0);
if (!gtk_text_iter_ends_line (&end))
gtk_text_iter_forward_to_line_end (&end);
gb_color_picker_document_monitor_queue_uncolorize (self, &begin, &end);
}
}
static void log_window_clip(LogWindow *logwin, guint clip_length)
{
guint length;
guint point;
GtkTextBuffer *textbuf = logwin->buffer;
GtkTextIter start_iter, end_iter;
length = gtk_text_buffer_get_line_count(textbuf);
/* debug_print("Log window length: %u\n", length); */
if (length > clip_length) {
/* find the end of the first line after the cut off
* point */
point = length - clip_length;
gtk_text_buffer_get_iter_at_line(textbuf, &end_iter, point);
if (!gtk_text_iter_forward_to_line_end(&end_iter))
return;
gtk_text_buffer_get_start_iter(textbuf, &start_iter);
gtk_text_buffer_delete(textbuf, &start_iter, &end_iter);
if (logwin->has_error) {
gtk_text_buffer_get_start_iter(textbuf, &start_iter);
if (mainwindow_get_mainwindow() && !gtk_text_iter_forward_to_tag_toggle(&start_iter, logwin->error_tag)) {
mainwindow_clear_error(mainwindow_get_mainwindow());
logwin->has_error = FALSE;
}
}
}
}
/* Get the boundary, on @iter's line, between the end of the text and trailing
* spaces.
*/
void
_gtk_source_iter_get_trailing_spaces_start_boundary (const GtkTextIter *iter,
GtkTextIter *trailing_start)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (trailing_start != NULL);
*trailing_start = *iter;
if (!gtk_text_iter_ends_line (trailing_start))
{
gtk_text_iter_forward_to_line_end (trailing_start);
}
while (!gtk_text_iter_starts_line (trailing_start))
{
GtkTextIter prev;
gunichar ch;
prev = *trailing_start;
gtk_text_iter_backward_char (&prev);
ch = gtk_text_iter_get_char (&prev);
if (!g_unichar_isspace (ch))
{
break;
}
*trailing_start = prev;
}
}
void
gimp_text_tool_editor_button_press (GimpTextTool *text_tool,
gdouble x,
gdouble y,
GimpButtonPressType press_type)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
GtkTextIter cursor;
GtkTextIter selection;
gimp_text_tool_xy_to_iter (text_tool, x, y, &cursor);
selection = cursor;
text_tool->select_start_iter = cursor;
text_tool->select_words = FALSE;
text_tool->select_lines = FALSE;
switch (press_type)
{
case GIMP_BUTTON_PRESS_NORMAL:
gtk_text_buffer_place_cursor (buffer, &cursor);
break;
case GIMP_BUTTON_PRESS_DOUBLE:
text_tool->select_words = TRUE;
if (! gtk_text_iter_starts_word (&cursor))
gtk_text_iter_backward_visible_word_starts (&cursor, 1);
if (! gtk_text_iter_ends_word (&selection) &&
! gtk_text_iter_forward_visible_word_ends (&selection, 1))
gtk_text_iter_forward_to_line_end (&selection);
gtk_text_buffer_select_range (buffer, &cursor, &selection);
break;
case GIMP_BUTTON_PRESS_TRIPLE:
text_tool->select_lines = TRUE;
gtk_text_iter_set_line_offset (&cursor, 0);
gtk_text_iter_forward_to_line_end (&selection);
gtk_text_buffer_select_range (buffer, &cursor, &selection);
break;
}
}
Gobby::OperationSave::OperationSave(Operations& operations,
TextSessionView& view,
const Glib::RefPtr<Gio::File>& file,
const std::string& encoding,
DocumentInfoStorage::EolStyle eol_style):
Operation(operations), m_file(file), m_view(&view),
m_start_time(std::time(NULL)), m_current_line_index(0),
m_encoding(encoding), m_eol_style(eol_style),
m_storage_key(view.get_info_storage_key()),
m_iconv(encoding.c_str(), "UTF-8"),
m_buffer_size(0), m_buffer_index(0)
{
const Folder& folder = get_folder_manager().get_text_folder();
folder.signal_document_removed().connect(
sigc::mem_fun(*this, &OperationSave::on_document_removed));
// Load content so that the session can go on while saving
GtkTextBuffer* buffer = GTK_TEXT_BUFFER(view.get_text_buffer());
GtkTextIter prev;
GtkTextIter pos;
GtkTextIter old_pos;
gtk_text_buffer_get_start_iter(buffer, &prev);
pos = prev;
if(!gtk_text_iter_ends_line(&pos))
gtk_text_iter_forward_to_line_end(&pos);
do
{
Line line;
line.first =
gtk_text_buffer_get_text(buffer, &prev, &pos, TRUE);
line.second = gtk_text_iter_get_line_index(&pos);
m_lines.push_back(line);
//if(gtk_text_iter_is_end(&prev))
// break;
old_pos = pos;
gtk_text_iter_forward_line(&prev);
gtk_text_iter_forward_to_line_end(&pos);
} while(!gtk_text_iter_equal(&pos, &old_pos));
m_current_line = m_lines.begin();
}
static void
ide_source_view_movements_line_end (Movement *mv)
{
if (!gtk_text_iter_ends_line (&mv->insert))
gtk_text_iter_forward_to_line_end (&mv->insert);
if (!mv->exclusive)
gtk_text_iter_forward_char (&mv->insert);
}
void highlight_code(int line, GtkTextTag *hightag)
{
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_line(code_textbuffer, &start, line);
end = start;
gtk_text_iter_forward_to_line_end(&end);
gtk_text_buffer_apply_tag(code_textbuffer, hightag, &start, &end);
}
static gboolean
smie_gtk_source_buffer_forward_to_line_end (gpointer data)
{
smie_gtk_source_buffer_context_t *context = data;
/* If we are already on the EOL, do nothing. */
if (gtk_text_iter_ends_line (&context->iter))
return FALSE;
return gtk_text_iter_forward_to_line_end (&context->iter);
}
static void
ide_source_view_movements_last_char (Movement *mv)
{
if (!gtk_text_iter_ends_line (&mv->insert))
{
gtk_text_iter_forward_to_line_end (&mv->insert);
if (mv->exclusive && !gtk_text_iter_starts_line (&mv->insert))
gtk_text_iter_backward_char (&mv->insert);
}
}
static char *
generate_syntax (const struct comment_dialog *cd)
{
gint i;
GString *str;
gchar *text;
GtkWidget *tv = get_widget_assert (cd->xml, "comments-textview1");
GtkWidget *check = get_widget_assert (cd->xml, "comments-checkbutton1");
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tv));
str = g_string_new ("\n* Data File Comments.\n\n");
if (dict_get_documents (cd->dict->dict) != NULL)
g_string_append (str, "DROP DOCUMENTS.\n");
g_string_append (str, "ADD DOCUMENT\n");
for (i = 0 ; i < gtk_text_buffer_get_line_count (buffer) ; ++i )
{
struct string tmp;
GtkTextIter start;
char *line;
gtk_text_buffer_get_iter_at_line (buffer, &start, i);
if (gtk_text_iter_ends_line (&start))
line = g_strdup ("");
else
{
GtkTextIter end = start;
gtk_text_iter_forward_to_line_end (&end);
line = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
}
ds_init_empty (&tmp);
syntax_gen_string (&tmp, ss_cstr (line));
g_free (line);
g_string_append_printf (str, " %s\n", ds_cstr (&tmp));
ds_destroy (&tmp);
}
g_string_append (str, " .\n");
if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check)))
g_string_append (str, "DISPLAY DOCUMENTS.\n");
text = str->str;
g_string_free (str, FALSE);
return text;
}
/* Always process start and end by init_boudaries before */
static GHashTable *
gbp_spell_navigator_count_words (GbpSpellNavigator *self,
GtkTextIter *start,
GtkTextIter *end)
{
GHashTable *table;
GtkSourceRegion *words_count_region;
WordsCountState *state;
GtkTextIter start_subregion;
GtkTextIter end_subregion;
gint line_start;
gint line_end;
gint nb_subregion;
g_assert (GBP_IS_SPELL_NAVIGATOR (self));
g_assert (start != NULL);
g_assert (end != NULL);
words_count_region = gtk_source_region_new (self->buffer);
line_start = gtk_text_iter_get_line (start);
line_end = gtk_text_iter_get_line (end);
nb_subregion = (line_end - line_start + 1) / SPELLCHECKER_SUBREGION_LENGTH;
if (nb_subregion > 1)
{
for (gint i = 0; i < nb_subregion; ++i)
{
line_end = line_start + SPELLCHECKER_SUBREGION_LENGTH - 1;
gtk_text_buffer_get_iter_at_line_offset (self->buffer, &start_subregion, line_start, 0);
gtk_text_buffer_get_iter_at_line_offset (self->buffer, &end_subregion, line_end, 0);
if (!gtk_text_iter_ends_line (&end_subregion))
gtk_text_iter_forward_to_line_end (&end_subregion);
gtk_source_region_add_subregion (words_count_region, &start_subregion, &end_subregion);
line_start = line_end + 1;
}
}
gtk_text_buffer_get_iter_at_line_offset (self->buffer, &start_subregion, line_start, 0);
gtk_source_region_add_subregion (words_count_region, &start_subregion, end);
table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
state = g_slice_new0 (WordsCountState);
state->navigator = g_object_ref (self);
state->words_count_region = words_count_region;
gtk_source_region_get_start_region_iter (words_count_region, &state->iter);
g_idle_add_full (G_PRIORITY_LOW,
(GSourceFunc)gbp_spell_navigator_words_count_cb,
state,
(GDestroyNotify)words_count_state_free);
return table;
}
static gchar *console_get_current_line (GtkTextBuffer *buf,
GtkTextIter *iter)
{
GtkTextIter start, end;
start = end = *iter;
gtk_text_iter_set_line_index(&start, 2);
gtk_text_iter_forward_to_line_end(&end);
return gtk_text_buffer_get_text(buf, &start, &end, FALSE);
}
/* TODO:
can we make this function faster? when adding bookmarks from a search this function uses
a lot of time, perhaps that can be improved
*/
static Tbmark *bmark_get_bmark_at_line(Tdocument *doc, gint offset) {
GtkTextIter sit, eit;
GtkTreeIter tmpiter;
gint linenum;
gtk_text_buffer_get_iter_at_offset(doc->buffer,&sit,offset);
linenum = gtk_text_iter_get_line(&sit);
eit = sit;
gtk_text_iter_set_line_offset(&sit, 0);
gtk_text_iter_forward_to_line_end(&eit);
#ifdef DEBUG
{
gchar *tmp = gtk_text_buffer_get_text(doc->buffer, &sit,&eit,FALSE);
DEBUG_MSG("bmark_get_bmark_at_line, searching bookmarks at line %d between offsets %d - %d --> '%s'\n",linenum,gtk_text_iter_get_offset(&sit),gtk_text_iter_get_offset(&eit),tmp);
g_free(tmp);
}
#endif
/* check for existing bookmark in this place */
if (DOCUMENT(doc)->bmark_parent) {
GtkTextIter testit;
Tbmark *m, *m2;
m = bmark_find_bookmark_before_offset(BFWIN(doc->bfwin), offset, doc->bmark_parent);
if (m == NULL) {
DEBUG_MSG("bmark_get_bmark_at_line, m=NULL, get first child\n");
if (gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter,doc->bmark_parent)) {
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN, &m2, -1);
gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m2->mark);
if (gtk_text_iter_get_line(&testit) == linenum) {
return m2;
}
}
} else {
gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m->mark);
DEBUG_MSG("bmark_get_bmark_at_line, m=%p, has linenum=%d\n",m,gtk_text_iter_get_line(&testit));
if (gtk_text_iter_get_line(&testit) == linenum) {
return m;
}
tmpiter = m->iter;
if (gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore),&tmpiter)) {
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN, &m2, -1);
gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m2->mark);
if (gtk_text_iter_get_line(&testit) == linenum) {
return m2;
}
}
}
DEBUG_MSG("bmark_get_bmark_at_line, nothing found at this line, return NULL\n");
return NULL;
}
DEBUG_MSG("bmark_get_bmark_at_line, no existing bookmark found, return NULL\n");
return NULL;
}
static gboolean search_elem_locate(GtkTextBuffer* buf, gint* pline, gint* poffset, CppElem* elem) {
GtkTextIter iter;
GtkTextIter limit;
GtkTextIter ps;
GtkTextIter pe;
guint ch;
gboolean full_matched;
gboolean need_move_cursor;
*pline = elem->sline - 1;
*poffset = -1;
gtk_text_buffer_get_iter_at_line(buf, &iter, *pline);
limit = iter;
gtk_text_iter_forward_to_line_end(&limit);
need_move_cursor = TRUE;
full_matched = FALSE;
while( gtk_text_iter_forward_search(&iter, elem->name->buf, 0, &ps, &pe, &limit) ) {
*poffset = gtk_text_iter_get_line_offset(&pe);
gtk_text_buffer_select_range(buf, &pe, &ps);
need_move_cursor = FALSE;
if( gtk_text_iter_starts_line(&ps) ) {
full_matched = TRUE;
} else {
iter = ps;
gtk_text_iter_backward_char(&iter);
ch = gtk_text_iter_get_char(&iter);
if( !g_unichar_isalnum(ch) && ch!='_' )
full_matched = TRUE;
}
if( full_matched && !gtk_text_iter_ends_line(&pe) ) {
iter = pe;
gtk_text_iter_forward_char(&iter);
ch = gtk_text_iter_get_char(&iter);
if( g_unichar_isalnum(ch) || ch=='_' )
full_matched = FALSE;
}
if( full_matched )
break;
iter = ps;
gtk_text_iter_forward_char(&iter);
}
return need_move_cursor;
}
static void
ide_source_view_movements_next_match_modifier (Movement *mv)
{
GtkTextIter insert;
GtkTextIter bounds;
bounds = insert = mv->insert;
gtk_text_iter_forward_to_line_end (&bounds);
if (gtk_text_iter_forward_find_char (&insert, find_match, mv, &bounds))
{
if (!mv->exclusive)
gtk_text_iter_forward_char (&insert);
mv->insert = insert;
}
}
void
gui_editor_set_highlight (GUIEditor * self, guint line_no, gboolean set)
{
g_assert (self);
GtkTextIter line_start, line_end;
/* get line bounds */
gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (self->buffer), &line_start, (line_no -1));
line_end = line_start;
gtk_text_iter_forward_to_line_end (&line_end);
if (set)
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER(self->buffer), self->hltag, &line_start, &line_end);
else
gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER(self->buffer), self->hltag, &line_start, &line_end);
}
void darken_code(int line, GtkTextTag *tag)
{
GtkTextIter start, end;
if (line == -1)
{
gtk_text_buffer_get_start_iter(code_textbuffer, &start);
gtk_text_buffer_get_end_iter(code_textbuffer, &end);
}
else
{
gtk_text_buffer_get_iter_at_line(code_textbuffer, &start, line);
end = start;
gtk_text_iter_forward_to_line_end(&end);
}
gtk_text_buffer_remove_tag(code_textbuffer, tag, &start, &end);
}
static void
select_line (GtkSourceGutterRendererLines *renderer,
GtkTextIter *line_start)
{
GtkTextIter iter;
GtkTextBuffer *buffer;
buffer = get_buffer (renderer);
iter = *line_start;
if (!gtk_text_iter_ends_line (&iter))
{
gtk_text_iter_forward_to_line_end (&iter);
}
/* Select the line, put the cursor at the end of the line */
gtk_text_buffer_select_range (buffer, &iter, line_start);
}
static void
extend_selection_to_line (GtkSourceGutterRendererLines *renderer,
GtkTextIter *line_start)
{
GtkTextIter start;
GtkTextIter end;
GtkTextIter line_end;
GtkTextBuffer *buffer;
buffer = get_buffer (renderer);
gtk_text_buffer_get_selection_bounds (buffer,
&start,
&end);
line_end = *line_start;
if (!gtk_text_iter_ends_line (&line_end))
{
gtk_text_iter_forward_to_line_end (&line_end);
}
if (gtk_text_iter_compare (&start, line_start) < 0)
{
gtk_text_buffer_select_range (buffer,
&start,
&line_end);
}
else if (gtk_text_iter_compare (&end, &line_end) < 0)
{
/* if the selection is in this line, extend
* the selection to the whole line */
gtk_text_buffer_select_range (buffer,
&line_end,
line_start);
}
else
{
gtk_text_buffer_select_range (buffer,
&end,
line_start);
}
}
GeditDocumentNewlineType
gedit_document_output_stream_detect_newline_type (GeditDocumentOutputStream *stream)
{
GeditDocumentNewlineType type;
GtkTextIter iter;
g_return_val_if_fail (GEDIT_IS_DOCUMENT_OUTPUT_STREAM (stream),
GEDIT_DOCUMENT_NEWLINE_TYPE_DEFAULT);
type = GEDIT_DOCUMENT_NEWLINE_TYPE_DEFAULT;
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (stream->priv->doc),
&iter);
if (gtk_text_iter_ends_line (&iter) || gtk_text_iter_forward_to_line_end (&iter))
{
type = get_newline_type (&iter);
}
return type;
}
/**
* 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);
}
/**
* \fn display_message_receipt
* \brief Displays the received receipt at the correct position
*/
void display_message_receipt(const char* strId){
#ifdef DEBUG
if(strId == NULL)
printf("NO ID\n");
else
printf("id is: %s \n", strId);
#endif
if(strId == NULL)
return;
message_info* info = (message_info*) g_hash_table_lookup(ht_locations, strId);
#ifdef DEBUG
printf("insert...");
#endif
if(info != NULL)
{
GtkTextIter location;
gtk_text_buffer_get_iter_at_offset (info->textbuffer,
&location,
info->offset);
gtk_text_iter_forward_lines (&location, info->lines);
gtk_text_iter_forward_to_line_end (&location);
gtk_text_buffer_insert (info->textbuffer,
&location,
" ✓",
-1);
g_hash_table_remove (ht_locations, strId);
}
#ifdef DEBUG
else
printf("failed: id not found\n");
#endif
}
