//================================================================
int GUI_edi_sel__ (MemObj *mo, long von, long bis) {
//================================================================
/// \code
/// select_region from-curPos to-curPos
/// if(from-curPos < 0) - unsect all !
/// \endcode
GtkTextIter it1;
GtkTextMark *mk1;
// printf("GUI_edi_sel__ %d %d\n",von,bis);
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// get iter from offset
gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, von);
// move "insert" & "selection_bound"-marks
gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1);
// get iter from offset
gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, bis);
// set end - mark
gtk_text_buffer_move_mark_by_name (GUI_ed1_buff, "selection_bound", &it1);
return 0;
}
void undo_insert_text_cb(GtkTextBuffer *textbuf, GtkTextIter *iter,
gchar *new_text, gint new_text_length,
UndoMain *undostruct)
{
gchar *text_to_insert;
gint pos;
if (prefs_common.undolevels <= 0) return;
pos = gtk_text_iter_get_offset(iter);
if (undostruct->wrap && undostruct->undo) {
UndoInfo *last_undo = undostruct->undo->data;
if (last_undo && (last_undo->action == UNDO_ACTION_INSERT
|| last_undo->action == UNDO_ACTION_REPLACE_INSERT)
&& last_undo->start_pos < pos && last_undo->end_pos > pos) {
GtkTextIter start,end;
last_undo->end_pos += g_utf8_strlen(new_text, -1);
gtk_text_buffer_get_iter_at_offset(textbuf, &start, last_undo->start_pos);
gtk_text_buffer_get_iter_at_offset(textbuf, &end, last_undo->end_pos);
g_free(last_undo->text);
last_undo->text = gtk_text_buffer_get_text(textbuf, &start, &end, FALSE);
debug_print("add:undo upd %d-%d\n", last_undo->start_pos, last_undo->end_pos);
return;
} else if (last_undo)
debug_print("add:last: %d, %d-%d (%d)\n", last_undo->action,
last_undo->start_pos, last_undo->end_pos, pos);
}
Xstrndup_a(text_to_insert, new_text, new_text_length, return);
debug_print("add:undo add %d-%ld\n", pos, pos + g_utf8_strlen(text_to_insert, -1));
undo_add(text_to_insert, pos, pos + g_utf8_strlen(text_to_insert, -1),
UNDO_ACTION_INSERT, undostruct);
}
gboolean undo_redo_real(GtkTextBuffer *buffer)
{
GtkTextIter start_iter, end_iter;
UndoInfo *ri;
if (g_list_length(redo_list)) {
// undo_block_signal(buffer);
ri = g_list_last(redo_list)->data;
gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, ri->start);
switch (ri->command) {
case INS:
gtk_text_buffer_insert(buffer, &start_iter, ri->str, -1);
break;
default:
gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, ri->end);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
}
undo_list = g_list_append(undo_list, ri);
redo_list = g_list_delete_link(redo_list, g_list_last(redo_list));
DV(g_print("cb_edit_redo: undo left = %d, redo left = %d\n",
g_list_length(undo_list), g_list_length(redo_list)));
// undo_unblock_signal(buffer);
if (ri->seq) {
undo_set_sequency(TRUE);
return TRUE;
}
if (!g_list_length(redo_list))
gtk_widget_set_sensitive(redo_w, FALSE);
gtk_widget_set_sensitive(undo_w, TRUE);
gtk_text_buffer_place_cursor(buffer, &start_iter);
scroll_to_cursor(buffer, 0.05);
}
undo_check_modified_step(buffer);
return FALSE;
}
// On Windows, when tags are applied, 38% of CPU time is used for
// seven oovBuilder source modules open. This is true even though the
// applyTags function is not normally running while idle. When only half
// the tags for each file is applied, then it drops to 25% usage.
bool Highlighter::applyTags(GtkTextBuffer *textBuffer,
int topOffset, int botOffset)
{
DUMP_THREAD("applyTags");
mHighlightTags.initTags(textBuffer);
const TokenRange &tokens = mHighlightTokens;
if(mTokenState != TS_HighlightRequest)
{
if(mTokenState == TS_GotTokens)
{
mTokenState = TS_AppliedTokens;
}
GtkTextIter start;
GtkTextIter end;
gtk_text_buffer_get_bounds(textBuffer, &start, &end);
gtk_text_buffer_remove_all_tags(textBuffer, &start, &end);
for(size_t i=0; i<tokens.size(); i++)
{
if(isBetween(tokens[i].mStartOffset, topOffset, botOffset) ||
isBetween(tokens[i].mEndOffset, topOffset, botOffset) ||
isBetween(topOffset, tokens[i].mStartOffset, tokens[i].mEndOffset))
{
gtk_text_buffer_get_iter_at_offset(textBuffer, &start,
static_cast<gint>(tokens[i].mStartOffset));
gtk_text_buffer_get_iter_at_offset(textBuffer, &end,
static_cast<gint>(tokens[i].mEndOffset));
gtk_text_buffer_apply_tag(textBuffer,
mHighlightTags.getTag(tokens[i].mTokenKind), &start, &end);
}
}
}
DUMP_THREAD("applyTags-end");
return(mTokenState == TS_AppliedTokens);
}
void
cainteoir_document_view_select_text(CainteoirDocumentView *view,
gint start_pos,
gint end_pos,
GtkAlign anchor)
{
GtkTextView *text_view = GTK_TEXT_VIEW(CAINTEOIR_DOCUMENT_VIEW_PRIVATE(view)->text_view);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(text_view);
GtkTextIter start;
gtk_text_buffer_get_iter_at_offset(buffer, &start, start_pos);
GtkTextIter end;
gtk_text_buffer_get_iter_at_offset(buffer, &end, end_pos);
gtk_text_buffer_select_range(buffer, &start, &end);
switch (anchor)
{
case GTK_ALIGN_START:
gtk_text_view_scroll_to_iter(text_view, &start, 0.0, TRUE, 0.0, 0.0);
break;
case GTK_ALIGN_CENTER:
gtk_text_view_scroll_to_iter(text_view, &start, 0.0, TRUE, 0.0, 0.5);
break;
case GTK_ALIGN_END:
gtk_text_view_scroll_to_iter(text_view, &end, 0.0, TRUE, 0.0, 1.0);
break;
default:
break;
}
}
void
viewlog (gpointer data)
{
char *tempstr, *txt, *pos;
gint textlen;
ssize_t len;
int fd;
#if GTK_MAJOR_VERSION > 1
GtkTextBuffer * textbuf;
GtkTextIter iter, iter2;
#endif
tempstr = g_strconcat (g_get_tmp_dir (), "/gftp-view.XXXXXXXXXX", NULL);
if ((fd = mkstemp (tempstr)) < 0)
{
ftp_log (gftp_logging_error, NULL,
_("Error: Cannot open %s for writing: %s\n"), tempstr,
g_strerror (errno));
g_free (tempstr);
return;
}
chmod (tempstr, S_IRUSR | S_IWUSR);
#if GTK_MAJOR_VERSION == 1
textlen = gtk_text_get_length (GTK_TEXT (logwdw));
txt = gtk_editable_get_chars (GTK_EDITABLE (logwdw), 0, -1);
#else
textbuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (logwdw));
textlen = gtk_text_buffer_get_char_count (textbuf);
gtk_text_buffer_get_iter_at_offset (textbuf, &iter, 0);
gtk_text_buffer_get_iter_at_offset (textbuf, &iter2, textlen);
txt = gtk_text_buffer_get_text (textbuf, &iter, &iter2, 0);
/* gtk_text_buffer_get_char_count() returns the number of characters,
not bytes. So get the number of bytes that need to be written out */
textlen = strlen (txt);
#endif
pos = txt;
while (textlen > 0)
{
if ((len = write (fd, pos, textlen)) == -1)
{
ftp_log (gftp_logging_error, NULL,
_("Error: Error writing to %s: %s\n"),
tempstr, g_strerror (errno));
break;
}
textlen -= len;
pos += len;
}
fsync (fd);
lseek (fd, 0, SEEK_SET);
view_file (tempstr, fd, 1, 1, 0, 1, NULL, NULL);
close (fd);
g_free (tempstr);
g_free (txt);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkTextAreaPeer_select
(JNIEnv *env, jobject obj, jint start, jint end)
{
void *ptr;
GtkWidget *text = NULL;
GtkTextBuffer *buf;
GtkTextIter iter;
gdk_threads_enter ();
ptr = NSA_GET_PTR (env, obj);
text = gtk_bin_get_child (GTK_BIN (ptr));
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
gtk_text_buffer_get_iter_at_offset (buf, &iter, start);
/* quickly move both 'insert' and 'selection_bound' to the
same position */
gtk_text_buffer_place_cursor (buf, &iter);
gtk_text_buffer_get_iter_at_offset (buf, &iter, end);
gtk_text_buffer_move_mark_by_name (buf, "selection_bound", &iter);
gdk_threads_leave ();
}
static gchar*
ev_view_accessible_get_text (AtkText *text,
gint start_pos,
gint end_pos)
{
GtkWidget *widget;
GtkTextIter start, end;
GtkTextBuffer *buffer;
gchar *retval;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return NULL;
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return NULL;
gtk_text_buffer_get_iter_at_offset (buffer, &start, start_pos);
gtk_text_buffer_get_iter_at_offset (buffer, &end, end_pos);
retval = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
return retval;
}
void EditorActionDeleteText::undo (GtkWidget *& to_focus)
{
// Undo the text deletion action, that means, re-insert the text.
// Get initial insert position.
gint accumulated_offset = offset;
// Go through the text to re-insert.
for (unsigned int i = 0; i < deleted_text.size(); i++) {
// Get the position where to insert.
GtkTextIter startiter;
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &startiter, accumulated_offset);
// Re-insert the text.
gtk_text_buffer_insert (paragraph->textbuffer, &startiter, deleted_text[i].c_str(), -1);
// Apply the paragraph style to the new inserted text.
// It is important that paragraph styles are applied first, and character styles last.
// Since this is new inserted text, there's no character style yet,
// so the paragraph style can be applied normally.
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &startiter, accumulated_offset);
GtkTextIter enditer;
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &enditer, accumulated_offset + deleted_text[i].length());
gtk_text_buffer_apply_tag_by_name (paragraph->textbuffer, paragraph->style.c_str(), &startiter, &enditer);
// Apply the character style.
if (!deleted_styles[i].empty()) {
gtk_text_buffer_apply_tag_by_name (paragraph->textbuffer, deleted_styles[i].c_str(), &startiter, &enditer);
}
// Modify the accumulated offset for the next iteration.
accumulated_offset += deleted_text[i].length();
}
// Focus widget.
to_focus = paragraph->textview;
}
static void
linkify_cb (GtkTextBuffer *buf, GRegex *regex)
{
gchar *text;
GtkTextIter start, end;
GMatchInfo *match;
gtk_text_buffer_get_bounds (buf, &start, &end);
text = gtk_text_buffer_get_text (buf, &start, &end, FALSE);
gtk_text_buffer_remove_all_tags (buf, &start, &end);
if (g_regex_match (regex, text, G_REGEX_MATCH_NOTEMPTY, &match))
{
do
{
gint sp, ep, spos, epos;
g_match_info_fetch_pos (match, 0, &sp, &ep);
/* positions are in bytes, not character, so here we must normalize it*/
spos = g_utf8_pointer_to_offset (text, text + sp);
epos = g_utf8_pointer_to_offset (text, text + ep);
gtk_text_buffer_get_iter_at_offset (buf, &start, spos);
gtk_text_buffer_get_iter_at_offset (buf, &end, epos);
gtk_text_buffer_apply_tag (buf, tag, &start, &end);
}
while (g_match_info_next (match, NULL));
}
g_match_info_free (match);
g_free(text);
}
static void treeViewSelChanged(GtkTreeView* treeView, gpointer userData)
{
GtkTreePath* path = NULL;
GtkTreeViewColumn* col = NULL;
gtk_tree_view_get_cursor(treeView, &path, &col);
GtkTreeIter iter;
gtk_tree_model_get_iter(GTK_TREE_MODEL(treeModel), &iter, path);
vmime::component* comp = NULL;
gtk_tree_model_get(GTK_TREE_MODEL(treeModel), &iter, 1, &comp, -1);
GtkTextBuffer* textBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textArea));
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_offset(textBuffer, &start, comp->getParsedOffset());
gtk_text_buffer_get_iter_at_offset(textBuffer, &end, comp->getParsedOffset() + comp->getParsedLength());
gtk_text_buffer_select_range(textBuffer, &start, &end);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textArea), &start, 0.0, FALSE, 0.0, 0.0);
gtk_tree_path_free(path);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkTextAreaPeer_replaceRange
(JNIEnv *env, jobject obj, jstring contents, jint start, jint end)
{
GtkWidget *text;
GtkTextBuffer *buf;
GtkTextIter iter, startIter, endIter;
void *ptr;
const char *str;
int mystart = start;
int myend = end;
gdk_threads_enter ();
ptr = NSA_GET_PTR (env, obj);
str = (*env)->GetStringUTFChars (env, contents, NULL);
text = gtk_bin_get_child (GTK_BIN (ptr));
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
gtk_text_buffer_get_iter_at_offset (buf, &startIter, mystart);
gtk_text_buffer_get_iter_at_offset (buf, &endIter, myend);
gtk_text_buffer_delete (buf, &startIter, &endIter);
gtk_text_buffer_get_iter_at_offset (buf, &iter, mystart);
gtk_text_buffer_insert(buf, &iter, str, strlen (str));
(*env)->ReleaseStringUTFChars (env, contents, str);
gdk_threads_leave ();
}
static void
restrict_message_length (GtkTextBuffer *buffer,
MessageDetails *details)
{
gchar *text;
GtkTextIter start, end;
gtk_text_buffer_get_bounds (buffer,
&start, &end);
text = gtk_text_buffer_get_slice (buffer,
&start, &end, TRUE);
if (strlen(text) > details->character_limit)
{
gint cursor_position;
g_object_get (buffer,
"cursor-position", &cursor_position,
NULL);
gtk_text_buffer_get_iter_at_offset (buffer,
&start,
cursor_position-1);
gtk_text_buffer_get_iter_at_offset (buffer,
&end,
cursor_position);
gtk_text_buffer_delete (buffer,
&start, &end);
}
g_free (text);
}
// side effect: changes the edit mode (XML or Form)
// maybe we should try form mode only when option "Always try Form mode" enabled
void set_edited_node(const xmlNodePtr n)
{
// XXX nb1 could be a global var inited at startup
GtkWidget *nb1 = glade_xml_get_widget(my_glade_xml, "notebook1");
gtk_widget_set_sensitive(nb1, n!=NULL);
gboolean is_entry = n && !strcmp((char *) n->name, "entry");
gtk_widget_set_sensitive(glade_xml_get_widget(my_glade_xml, "delete_button"), is_entry);
gtk_widget_set_sensitive(glade_xml_get_widget(my_glade_xml, "delete_entry1"), is_entry);
// XXX maybe we should refuse to set a new edited_node when
// the currently edited one is not saved yet (or try to auto-save it)
// this should ease the problem of on_notebook1_switch_page()
// that it has to prevent switching if auto-save fails.
// but then, how to handle the user switching to the other view?
// temporarily set edited_node to NULL so on_notebook1_switch_page()
// doesn't disturb us
edited_node = NULL;
// en-/disable switching to Form View
gtk_widget_set_sensitive(glade_xml_get_widget(my_glade_xml, "form_view_label"), is_entry);
if(n)
{
if(!is_entry || !xml2form(n, senses))
{
show_in_textview1(n);
gtk_notebook_set_current_page(GTK_NOTEBOOK(nb1), 0);
}
else
gtk_notebook_set_current_page(GTK_NOTEBOOK(nb1), 1);
}
else
{
GtkTextView *textview1 = GTK_TEXT_VIEW(glade_xml_get_widget(my_glade_xml, "textview1"));
GtkTextBuffer* b = gtk_text_view_get_buffer(textview1);
// XXX make a wizard out of this?
// should show only "No XML chunk currently edited."
char text[] =
N_("1. Open a TEI file\n"
"2. Modify the XPath select expression to match\n"
"\tthe entries you desire to edit\n"
"3. Double-click on an entry headword in the list\n"
"\tof matching entries to the right!");
gtk_text_buffer_set_text(b, _(text), -1);
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_offset(b, &start, 0);
gtk_text_buffer_get_iter_at_offset(b, &end, sizeof(text));
gtk_text_buffer_apply_tag_by_name(b, "instructions", &start, &end);
}
edited_node = n;
if(form_modified) {
form_modified = FALSE;
on_form_modified_changed();
}
}
static void help_window_load_text(GtkWidget *text, const gchar *path)
{
gchar *pathl;
FILE *f;
gchar s_buf[1024];
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextIter start, end;
if (!text || !path) return;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
pathl = path_from_utf8(path);
f = fopen(pathl, "r");
g_free(pathl);
if (!f)
{
gchar *buf;
buf = g_strdup_printf(_("Unable to load:\n%s"), path);
gtk_text_buffer_insert(buffer, &iter, buf, -1);
g_free(buf);
}
else
{
while (fgets(s_buf, sizeof(s_buf), f))
{
gchar *buf;
gint l;
l = strlen(s_buf);
if (!g_utf8_validate(s_buf, l, NULL))
{
buf = g_locale_to_utf8(s_buf, l, NULL, NULL, NULL);
if (!buf) buf = g_strdup("\n");
}
else
{
buf = NULL;
}
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
(buf) ? buf : s_buf, -1,
"monospace", NULL);
g_free(buf);
}
fclose(f);
}
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
gtk_text_buffer_place_cursor(buffer, &iter);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(text), &iter, 0.0, TRUE, 0, 0);
}
char *sg_get_text(GtkWidget *w, int start, int end)
{
GtkTextIter s, e;
GtkTextBuffer *buf;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
gtk_text_buffer_get_iter_at_offset(buf, &s, start);
gtk_text_buffer_get_iter_at_offset(buf, &e, end); /* this is utterly idiotic!!! */
return(gtk_text_buffer_get_text(buf, &s, &e, true));
}
void sg_text_delete(GtkWidget *w, int start, int end)
{
GtkTextIter s, e;
GtkTextBuffer *buf;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
gtk_text_buffer_get_iter_at_offset(buf, &s, start);
gtk_text_buffer_get_iter_at_offset(buf, &e, end);
gtk_text_buffer_delete(buf, &s, &e);
}
void EditorActionInsertText::undo (GtkWidget *& to_focus)
{
// Undo the insertion of text, that is, remove it again.
GtkTextIter startiter, enditer;
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &startiter, offset);
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &enditer, offset + text.length());
gtk_text_buffer_delete (paragraph->textbuffer, &startiter, &enditer);
// Focus widget.
to_focus = paragraph->textview;
}
gboolean
gimp_text_buffer_load (GtkTextBuffer *buffer,
const gchar *filename,
GError **error)
{
FILE *file;
gchar buf[2048];
gint remaining = 0;
GtkTextIter iter;
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
g_return_val_if_fail (filename != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
file = g_fopen (filename, "r");
if (! file)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
g_strerror (errno));
return FALSE;
}
gtk_text_buffer_set_text (buffer, "", 0);
gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
while (! feof (file))
{
const char *leftover;
gint count;
gint to_read = sizeof (buf) - remaining - 1;
count = fread (buf + remaining, 1, to_read, file);
buf[count + remaining] = '\0';
g_utf8_validate (buf, count + remaining, &leftover);
gtk_text_buffer_insert (buffer, &iter, buf, leftover - buf);
gtk_text_buffer_get_iter_at_offset (buffer, &iter, -1);
remaining = (buf + remaining + count) - leftover;
g_memmove (buf, leftover, remaining);
if (remaining > 6 || count < to_read)
break;
}
if (remaining)
g_message (_("Invalid UTF-8 data in file '%s'."),
gimp_filename_to_utf8 (filename));
fclose (file);
return TRUE;
}
/*---------------------------------------------------------------------*/
void
clear_hop_console() {
GtkTextIter start_del;
GtkTextIter end_del;
gtk_text_buffer_get_iter_at_offset( console_buffer, &start_del, 0 );
gtk_text_buffer_get_iter_at_offset( console_buffer, &end_del, -1 );
gtk_text_buffer_delete( console_buffer, &start_del, &end_del );
gtk_text_buffer_get_iter_at_offset( console_buffer, &end_of_buffer, -1 );
}
static void
gb_color_picker_document_monitor_colorize (GbColorPickerDocumentMonitor *self,
GtkTextBuffer *buffer,
GtkTextIter *begin,
GtkTextIter *end)
{
g_autofree gchar *text = NULL;
g_autoptr(GPtrArray) items = NULL;
GstyleColorItem *item;
GtkTextTag *tag;
GtkTextIter real_begin;
GtkTextIter real_end;
GtkTextIter tag_begin;
GtkTextIter tag_end;
gint offset;
gint len;
gint pos;
g_return_if_fail (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self));
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
if (begin == NULL)
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &real_begin);
else
real_begin = *begin;
if (end == NULL)
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (buffer), &real_end);
else
real_end = *end;
if (gtk_text_iter_equal (&real_begin, &real_end))
return;
offset = gtk_text_iter_get_offset (&real_begin);
text = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (buffer), &real_begin, &real_end, TRUE);
items = gstyle_color_parse (text);
for (guint n = 0; n < items->len; ++n)
{
GstyleColor *color;
item = g_ptr_array_index (items, n);
pos = offset + gstyle_color_item_get_start (item);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &tag_begin, pos);
len = gstyle_color_item_get_len (item);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &tag_end, pos + len);
color = (GstyleColor *)gstyle_color_item_get_color (item);
tag = gb_color_picker_helper_create_color_tag (GTK_TEXT_BUFFER (buffer), color);
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (buffer), tag, &tag_begin, &tag_end);
/* FIXME: is the tag added to the tag table or should we handle a hash table/tag table ourself ? */
}
}
void EditorActionDeleteText::redo (GtkWidget *& to_focus)
{
// Limit the area.
GtkTextIter startiter, enditer;
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &startiter, offset);
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &enditer, offset + length);
// Delete text.
gtk_text_buffer_delete (paragraph->textbuffer, &startiter, &enditer);
// Focus widget.
to_focus = paragraph->textview;
}
static void set_selection_bound(GtkTextBuffer *buffer, gint start, gint end)
{
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, start);
if (end < 0)
gtk_text_buffer_get_end_iter(buffer, &end_iter);
else
gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, end);
gtk_text_buffer_place_cursor(buffer, &end_iter);
gtk_text_buffer_move_mark_by_name(buffer, "selection_bound", &start_iter);
}
/* searching */
static void
do_search (GtkWidget *e, GtkWidget *w)
{
static gchar *text = NULL;
static guint offset;
static GRegex *regex = NULL;
GMatchInfo *match = NULL;
GtkTextIter begin, end;
g_free (pattern);
pattern = g_strdup (gtk_entry_get_text (GTK_ENTRY (e)));
gtk_widget_destroy (w);
gtk_widget_queue_draw (text_view);
if (new_search || gtk_text_buffer_get_modified (text_buffer))
{
/* get the text */
g_free (text);
gtk_text_buffer_get_bounds (text_buffer, &begin, &end);
text = gtk_text_buffer_get_text (text_buffer, &begin, &end, FALSE);
offset = 0;
/* compile new regex */
if (regex)
g_regex_unref (regex);
regex = g_regex_new (pattern, G_REGEX_EXTENDED | G_REGEX_OPTIMIZE, G_REGEX_MATCH_NOTEMPTY, NULL);
new_search = FALSE;
}
/* search and select if found */
if (g_regex_match (regex, text + offset, G_REGEX_MATCH_NOTEMPTY, &match))
{
gint sp, ep, spos, epos;
g_match_info_fetch_pos (match, 0, &sp, &ep);
/* positions are in bytes, not character, so here we must normalize it*/
spos = g_utf8_pointer_to_offset (text, text + sp + offset);
epos = g_utf8_pointer_to_offset (text, text + ep + offset);
gtk_text_buffer_get_iter_at_offset (text_buffer, &begin, spos);
gtk_text_buffer_get_iter_at_offset (text_buffer, &end, epos);
gtk_text_buffer_select_range (text_buffer, &begin, &end);
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (text_view), &begin, 0, FALSE, 0, 0);
offset += epos;
g_match_info_free (match);
match = NULL;
}
else
new_search = TRUE;
}
static void
change_cb (GeditSpellCheckerDialog *dlg,
const gchar *word,
const gchar *change,
GeditView *view)
{
GeditDocument *doc;
CheckRange *range;
gchar *w = NULL;
GtkTextIter start, end;
gedit_debug (DEBUG_PLUGINS);
g_return_if_fail (view != NULL);
g_return_if_fail (word != NULL);
g_return_if_fail (change != NULL);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
g_return_if_fail (doc != NULL);
range = get_check_range (doc);
g_return_if_fail (range != NULL);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &start, range->mw_start);
if (range->mw_end < 0)
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end);
else
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &end, range->mw_end);
w = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (doc), &start, &end, TRUE);
g_return_if_fail (w != NULL);
if (strcmp (w, word) != 0)
{
g_free (w);
return;
}
g_free (w);
gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER(doc));
gtk_text_buffer_delete (GTK_TEXT_BUFFER (doc), &start, &end);
gtk_text_buffer_insert (GTK_TEXT_BUFFER (doc), &start, change, -1);
gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER(doc));
update_current (doc, range->mw_start + g_utf8_strlen (change, -1));
/* go to next misspelled word */
ignore_cb (dlg, word, view);
}
static void
change_all_cb (GeditSpellCheckerDialog *dlg,
const gchar *word,
const gchar *change,
GeditView *view)
{
GeditDocument *doc;
CheckRange *range;
gchar *w = NULL;
GtkTextIter start, end;
gint flags = 0;
gedit_debug (DEBUG_PLUGINS);
g_return_if_fail (view != NULL);
g_return_if_fail (word != NULL);
g_return_if_fail (change != NULL);
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
g_return_if_fail (doc != NULL);
range = get_check_range (doc);
g_return_if_fail (range != NULL);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &start, range->mw_start);
if (range->mw_end < 0)
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end);
else
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &end, range->mw_end);
w = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (doc), &start, &end, TRUE);
g_return_if_fail (w != NULL);
if (strcmp (w, word) != 0)
{
g_free (w);
return;
}
g_free (w);
GEDIT_SEARCH_SET_CASE_SENSITIVE (flags, TRUE);
GEDIT_SEARCH_SET_ENTIRE_WORD (flags, TRUE);
/* CHECK: currently this function does escaping etc */
gedit_document_replace_all (doc, word, change, flags);
update_current (doc, range->mw_start + g_utf8_strlen (change, -1));
/* go to next misspelled word */
ignore_cb (dlg, word, view);
}
void EditorActionDeleteText::apply (GtkWidget *& to_focus)
{
// Limit the area.
GtkTextIter startiter, enditer;
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &startiter, offset);
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &enditer, offset + length);
// Save existing content.
get_text_and_styles_between_iterators(&startiter, &enditer, deleted_text, deleted_styles);
// Delete text.
gtk_text_buffer_delete (paragraph->textbuffer, &startiter, &enditer);
// Focus widget.
to_focus = paragraph->textview;
}
static GdkAtom
setup_buffer (GtkTextBuffer *buffer)
{
const guint tlen = strlen (example_text);
const guint tcount = 17;
GtkTextTag **tags;
GtkTextTagTable *ttable = gtk_text_buffer_get_tag_table (buffer);
GSList *node, *slist = NULL;
GdkAtom atom;
guint i;
tags = g_malloc (sizeof (GtkTextTag *) * tcount);
/* cleanup */
gtk_text_buffer_set_text (buffer, "", 0);
gtk_text_tag_table_foreach (ttable, text_tag_enqueue, &slist);
for (node = slist; node; node = node->next)
gtk_text_tag_table_remove (ttable, node->data);
g_slist_free (slist);
/* create new tags */
for (i = 0; i < tcount; i++)
{
char *s = g_strdup_printf ("tag%u", i);
tags[i] = gtk_text_buffer_create_tag (buffer, s,
"weight", quick_rand32() >> 31 ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL,
"style", quick_rand32() >> 31 ? PANGO_STYLE_OBLIQUE : PANGO_STYLE_NORMAL,
"underline", quick_rand32() >> 31,
NULL);
g_free (s);
}
/* assign text and tags */
gtk_text_buffer_set_text (buffer, example_text, -1);
for (i = 0; i < tcount * 5; i++)
{
gint a = quick_rand32() % tlen, b = quick_rand32() % tlen;
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_offset (buffer, &start, MIN (a, b));
gtk_text_buffer_get_iter_at_offset (buffer, &end, MAX (a, b));
gtk_text_buffer_apply_tag (buffer, tags[i % tcount], &start, &end);
}
/* return serialization format */
atom = gtk_text_buffer_register_deserialize_tagset (buffer, NULL);
gtk_text_buffer_deserialize_set_can_create_tags (buffer, atom, TRUE);
g_free (tags);
return atom;
}
void
ap_assistant_finish (GtkAssistant *assistant, gpointer user_data)
{
AcctPeriodInfo *info = user_data;
GtkTextBuffer * buffer;
GtkTextIter startiter, enditer;
gint len;
const char *btitle;
char *bnotes;
Timespec closing_date;
ENTER("info=%p", info);
btitle = gtk_entry_get_text (GTK_ENTRY(info->book_title));
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(info->book_notes));
len = gtk_text_buffer_get_char_count (buffer);
gtk_text_buffer_get_iter_at_offset(buffer, &startiter, 0);
gtk_text_buffer_get_iter_at_offset(buffer, &enditer, len);
bnotes = gtk_text_buffer_get_text(buffer, &startiter, &enditer , 0);
PINFO("Book title is - %s\n", btitle);
timespecFromTime64 (&closing_date,
gnc_time64_get_day_end_gdate (&info->closing_date));
g_free(bnotes);
/* Report the status back to the user. */
info->close_status = 0; /* XXX fixme success or failure? */
/* Find the next closing date ... */
info->prev_closing_date = info->closing_date;
recurrenceListNextInstance (info->period, &info->prev_closing_date,
&info->closing_date);
/* FIXME Test for valid closing date, not sure why it won't be!!! */
if (g_date_valid(&info->closing_date) == TRUE)
{
/* If the next closing date is in the future, then we are done. */
if (gnc_time (NULL) >
gnc_time64_get_day_end_gdate (&info->closing_date))
{
/* Load up the GUI for the next closing period. */
gnc_frequency_setup_recurrence (info->period_menu, NULL,
&info->closing_date);
/* Jump back to the Close Book page. */
gtk_assistant_set_current_page (GTK_ASSISTANT(info->window), 1);
}
}
}
static void
clear_fortune_text (FishApplet *fish)
{
GtkTextIter begin, end;
gtk_text_buffer_get_iter_at_offset (fish->fortune_buffer, &begin, 0);
gtk_text_buffer_get_iter_at_offset (fish->fortune_buffer, &end, -1);
gtk_text_buffer_delete (fish->fortune_buffer, &begin, &end);
gtk_text_buffer_remove_tag_by_name (fish->fortune_buffer,
"monospace_tag", &begin, &end);
/* insert an empty line */
insert_fortune_text (fish, "\n");
}
