void snippets_activate (GuSnippets* sc, GuEditor* ec, gchar* key) {
gchar* snippet = NULL;
GuSnippetInfo* new_info = NULL;
GtkTextIter start, end;
slog (L_DEBUG, "Snippet `%s' activated\n", key);
snippet = snippets_get_value (sc, key);
g_return_if_fail (snippet != NULL);
new_info = snippets_parse (snippet);
gtk_text_buffer_get_selection_bounds (ec_buffer, &start, &end);
new_info->start_offset = gtk_text_iter_get_offset (&start);
new_info->sel_text = gtk_text_iter_get_text (&start, &end);
GSList* marks = gtk_text_iter_get_marks (&start);
new_info->sel_start = *GTK_TEXT_MARK (marks->data);
g_slist_free (marks);
gtk_text_buffer_insert (ec_buffer, &start, new_info->expanded, -1);
snippet_info_create_marks (new_info, ec);
snippet_info_initial_expand (new_info, ec);
gtk_text_buffer_set_modified (ec_buffer, TRUE);
if (sc->info) {
snippet_info_sync_group (sc->info, ec);
sc->stackframe = g_list_append (sc->stackframe, sc->info);
}
sc->info = new_info;
if (!snippet_info_goto_next_placeholder (sc->info, ec))
snippets_deactivate (sc, ec);
}
/**
Kolorowanie słów.
Słowa nie znajdujące się w słowniku - potencjalnie błędne - zostają
oznaczone na czerwono.
*/
static void show_errors() {
GtkTextIter start, end, text_end;
int i, range;
char *word;
gunichar *wword;
gtk_text_buffer_create_tag(editor_buf, "red_fg",
"foreground", "red",
"weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_get_end_iter(editor_buf, &text_end);
gtk_text_buffer_get_start_iter(editor_buf, &end);
range = gtk_text_buffer_get_char_count(editor_buf);
while (!gtk_text_iter_is_end(&end)) {
gtk_text_iter_forward_word_end(&end);
start = end;
gtk_text_iter_backward_word_start(&start);
word = gtk_text_iter_get_text(&start, &end);
wword = g_utf8_to_ucs4_fast(word, -1, NULL);
if (make_lowercase(wword)) {
if (!dictionary_find(dict, wword))
gtk_text_buffer_apply_tag_by_name(editor_buf, "red_fg",
&start, &end);
}
g_free(word);
g_free(wword);
}
}
static gboolean
tag_event_cb (GtkTextTag *tag, GObject *obj, GdkEvent *ev,
GtkTextIter *iter, gpointer d)
{
GtkTextIter start = *iter;
GtkTextIter end = *iter;
gchar *url, *cmdline;
if (ev->type == GDK_BUTTON_PRESS)
{
GdkEventButton *bev = (GdkEventButton *) ev;
if (bev->button == 1)
{
gtk_text_iter_backward_to_tag_toggle (&start, tag);
gtk_text_iter_forward_to_tag_toggle (&end, tag);
url = gtk_text_iter_get_text (&start, &end);
cmdline = g_strdup_printf ("xdg-open '%s'", url);
g_free (url);
g_spawn_command_line_async (cmdline, NULL);
g_free (cmdline);
return TRUE;
}
}
return FALSE;
}
static gchar *
get_word (GtkSourceCompletionProvider *provider,
GtkTextIter *iter)
{
GtkTextIter *end;
gboolean moved = FALSE;
gunichar c;
gchar *word;
end = gtk_text_iter_copy(iter);
do {
if (!gtk_text_iter_backward_char(iter)) {
break;
}
c = gtk_text_iter_get_char(iter);
moved = TRUE;
} while (!is_stop_char(c));
if (moved && !gtk_text_iter_is_start(iter)) {
gtk_text_iter_forward_char(iter);
}
word = g_strstrip(gtk_text_iter_get_text(iter, end));
gtk_text_iter_free(end);
return word;
}
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);
}
}
static gboolean about_textview_uri_clicked(GtkTextTag *tag, GObject *obj,
GdkEvent *event, GtkTextIter *iter,
GtkWidget *textview)
{
GtkTextIter start_iter, end_iter;
GdkEventButton *bevent;
gchar *link = NULL;
if (!event || !tag) {
return FALSE;
}
if (event->type != GDK_BUTTON_PRESS && event->type != GDK_2BUTTON_PRESS
&& event->type != GDK_BUTTON_RELEASE) {
return FALSE;
}
/* get link text from tag */
if (get_tag_range(iter, tag, &start_iter,
&end_iter) == FALSE) {
return FALSE;
}
link = gtk_text_iter_get_text(&start_iter, &end_iter);
if (link == NULL) {
return FALSE;
}
bevent = (GdkEventButton *) event;
if (bevent->button == 1 && event->type == GDK_BUTTON_RELEASE) {
GtkTextBuffer *buffer;
/* we shouldn't follow a link if the user has selected something */
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);
if (gtk_text_iter_get_offset(&start_iter) != gtk_text_iter_get_offset(&end_iter)) {
return FALSE;
}
/* open link and do *not* return TRUE so that
further gtk processing of the signal is done */
open_uri(link, prefs_common_get_uri_cmd());
} else {
if (bevent->button == 3 && event->type == GDK_BUTTON_PRESS) {
link_popupmenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(
gtk_ui_manager_get_widget(gtkut_ui_manager(), "/Menus/TextviewPopupLink")));
g_object_set_data(
G_OBJECT(link_popupmenu),
"raw_url", link);
gtk_menu_popup(GTK_MENU(link_popupmenu),
NULL, NULL, NULL, NULL,
bevent->button, bevent->time);
return TRUE;
}
}
return FALSE;
}
ustring CheckCapitalization::get_context(GtkTextIter iter)
// Returns the context at iter: A couple of words before and after.
{
GtkTextIter iter1 = iter;
GtkTextIter iter2 = iter;
gtk_text_iter_backward_word_starts(&iter1, 2);
gtk_text_iter_forward_word_ends(&iter2, 2);
return gtk_text_iter_get_text(&iter1, &iter2);
}
void Highlight::searchwords_in_area(GtkTextBuffer * textbuffer, vector < GtkTextIter > &start, vector < GtkTextIter > &end, bool area_id, bool area_intro, bool area_heading, bool area_chapter, bool area_study, bool area_notes, bool area_xref, bool area_verse)
/*
Finds out whether the text within the "start" and "end" iterators is inside
one of the given areas. If not, it removes the iterator from the containers.
*/
{
// Categorization data
CategorizeLine categorize("");
// Go through the iterators, starting at the end (to make erasing it easier).
for (int it = start.size() - 1; it >= 0; it--) {
// Get line number of the iterator.
gint linenumber = gtk_text_iter_get_line(&start[it]);
// Get the usfm this line starts with.
ustring usfm;
{
GtkTextIter line1;
gtk_text_buffer_get_iter_at_line(textbuffer, &line1, linenumber);
GtkTextIter line2 = line1;
gtk_text_iter_forward_chars(&line2, 10);
ustring line = gtk_text_iter_get_text(&line1, &line2);
usfm = usfm_extract_marker(line);
}
// See if this usfm is in one of the areas given.
bool in_area = false;
if (area_id)
if (categorize.is_id_marker(usfm))
in_area = true;
if (area_intro)
if (categorize.is_intro_marker(usfm))
in_area = true;
if (area_heading)
if (categorize.is_head_marker(usfm))
in_area = true;
if (area_chapter)
if (categorize.is_chap_marker(usfm))
in_area = true;
if (area_study)
if (categorize.is_study_marker(usfm))
in_area = true;
// The variables "area_notes" and "area_xref" are not relevant.
if (area_verse)
if (categorize.is_verse_marker(usfm))
in_area = true;
// If not in one of the areas, remove this iterator from the container.
if (!in_area) {
vector < GtkTextIter >::iterator startiter = start.begin();
vector < GtkTextIter >::iterator enditer = end.begin();
for (int i = 0; i < it; i++) {
startiter++;
enditer++;
}
start.erase(startiter);
end.erase(enditer);
}
}
}
/**
* gsc_utils_get_word_iter:
*
* @text_buffer: The #GtkTextBuffer
* @start_word: if != NULL then assign it the start position of the word
* @end_word: if != NULL then assing it the end position of the word
*
* Returns: the current word
*
*/
gchar *
gsc_utils_get_word_iter (GtkTextBuffer *text_buffer,
GtkTextIter *current,
GtkTextIter *start_word,
GtkTextIter *end_word)
{
gunichar ch;
gboolean no_doc_start;
if (current == NULL)
{
gtk_text_buffer_get_iter_at_mark (text_buffer,
start_word,
gtk_text_buffer_get_insert (text_buffer));
}
else
{
*start_word = *current;
}
*end_word = *start_word;
while ((no_doc_start = gtk_text_iter_backward_char (start_word)) == TRUE)
{
ch = gtk_text_iter_get_char (start_word);
if (gsc_utils_is_separator (ch))
{
break;
}
}
if (!no_doc_start)
{
gtk_text_buffer_get_start_iter (text_buffer, start_word);
return gtk_text_iter_get_text (start_word, end_word);
}
else
{
gtk_text_iter_forward_char (start_word);
return gtk_text_iter_get_text (start_word, end_word);
}
}
static gchar *compute_indentation(GtkTextBuffer *buffer, GtkTextIter *iter, gint line)
{
GtkTextIter start_iter, end_iter;
gunichar ch;
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, line);
end_iter = start_iter;
ch = gtk_text_iter_get_char(&end_iter);
while (g_unichar_isspace(ch) && ch != '\n') {
if (!gtk_text_iter_forward_char(&end_iter))
break;
ch = gtk_text_iter_get_char(&end_iter);
}
if (gtk_text_iter_equal(&start_iter, &end_iter))
return NULL;
if (iter && gtk_text_iter_compare(iter, &end_iter) < 0)
return gtk_text_iter_get_text(&start_iter, iter);
return gtk_text_iter_get_text(&start_iter, &end_iter);
}
static void
text_buffer_undo_delete_range_cb (GtkTextBuffer *text_buffer,
GtkTextIter *start,
GtkTextIter *end,
gpointer user_data)
{
push_delete_undo (
G_OBJECT (text_buffer),
gtk_text_iter_get_text (start, end),
gtk_text_iter_get_offset (start),
gtk_text_iter_get_offset (end));
}
/**
* 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);
}
static gchar *
get_word_at_iter (GscProviderDevhelp *devhelp,
GtkTextIter *iter)
{
GtkTextIter start = *iter;
gint line = gtk_text_iter_get_line (iter);
gboolean went_back = TRUE;
GtkTextMark *mark;
if (!gtk_text_iter_backward_char (&start))
{
return NULL;
}
while (went_back &&
line == gtk_text_iter_get_line (&start) &&
is_word_char (gtk_text_iter_get_char (&start)))
{
went_back = gtk_text_iter_backward_char (&start);
}
if (went_back)
{
gtk_text_iter_forward_char (&start);
}
if (gtk_text_iter_equal (iter, &start))
{
return NULL;
}
mark = gtk_text_buffer_get_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME);
if (mark)
{
gtk_text_buffer_move_mark (gtk_text_iter_get_buffer (iter),
mark,
&start);
}
else
{
mark = gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME,
&start,
TRUE);
}
return gtk_text_iter_get_text (&start, iter);
}
//================================================================
int GUI_edi_Rd2it (char* txbuf, long txlen,
GtkTextIter *it1, GtkTextIter *it2) {
//================================================================
/// \code
/// get text between 2 iters INTERNAL
/// p1, p2 character-offset, not byte offsets !
/// get whole window with: p1=0L, p2=-1L
/// Input:
/// txlen size of txbuf
/// \endcode
char *text;
long sSiz;
// printf("GUI_edi_Rd2it %ld\n",txlen);
// get textPointer;
text = gtk_text_iter_get_text (it1, it2);
if(!text) { // 2013-12-29
TX_Error("GUI_edi_Rd2it E001");
return -1;
}
sSiz = strlen(text); // g_utf8_strlen
// printf(" sSiz=%ld\n",sSiz);
if(sSiz < txlen) {
// remove '\n'
// if(text[sSiz - 1] == '\n') --sSiz; // 2012-11-18 removed
// copy out
strncpy(txbuf, text, sSiz);
txbuf[sSiz] = '\0';
} else {
sSiz = -1;
}
g_free (text);
// printf("ex GUI_edi_Rd2it %ld\n",sSiz);
// printf("|"); UTX_dump_s__(txbuf,*txlen+1);printf("|");
return sSiz;
}
static gboolean check_selection_bound(GtkTextBuffer *buffer)
{
GtkTextIter start, end;
gchar *str, *p;
if (gtk_text_buffer_get_selection_bounds(buffer, &start, &end)) {
str = gtk_text_iter_get_text(&start, &end);
p = strchr(str, '\n');
g_free(str);
if (p)
return TRUE;
}
return FALSE;
}
gboolean snippets_key_press_cb (GuSnippets* sc, GuEditor* ec, GdkEventKey* ev) {
GtkTextIter current, start;
if (ev->keyval == GDK_KEY_Tab) {
gchar* key = NULL;
editor_get_current_iter (ec, ¤t);
if (gtk_text_iter_ends_word (¤t)) {
start = current;
gtk_text_iter_backward_word_start (&start);
key = gtk_text_iter_get_text (&start, ¤t);
if (snippets_get_value (sc, key)) {
gtk_text_buffer_delete (ec_buffer, &start, ¤t);
snippets_activate (sc, ec, key);
g_free (key);
return TRUE;
}
g_free (key);
}
}
if (sc->info) {
if (ev->keyval == GDK_KEY_Tab) {
if (!snippet_info_goto_next_placeholder (sc->info, ec))
snippets_deactivate (sc, ec);
return TRUE;
} else if (ev->keyval == GDK_KEY_ISO_Left_Tab
&& ev->state & GDK_SHIFT_MASK) {
if (!snippet_info_goto_prev_placeholder (sc->info, ec))
snippets_deactivate (sc, ec);
return TRUE;
}
/* Deactivate snippet if the current insert range is not within the
* snippet */
editor_get_current_iter (ec, ¤t);
gint offset = gtk_text_iter_get_offset (¤t);
GList* last = g_list_last (sc->info->einfo);
if (last) {
gtk_text_buffer_get_iter_at_mark (ec_buffer, ¤t,
GU_SNIPPET_EXPAND_INFO (last->data)->left_mark);
gint bound_end = gtk_text_iter_get_offset (¤t);
if (offset < sc->info->start_offset || offset > bound_end)
snippets_deactivate (sc, ec);
}
}
return FALSE;
}
/* While not as cool as c-mode, this will do as a quick attempt at highlighting */
static void
fontify (GtkTextBuffer *source_buffer)
{
GtkTextIter start_iter, next_iter, tmp_iter;
gint state;
gchar *text;
gchar *start_ptr, *end_ptr;
gchar *tag;
gtk_text_buffer_get_bounds (source_buffer, &start_iter, &tmp_iter);
gtk_text_buffer_apply_tag_by_name (source_buffer, "source", &start_iter, &tmp_iter);
state = STATE_NORMAL;
gtk_text_buffer_get_iter_at_offset (source_buffer, &start_iter, 0);
next_iter = start_iter;
while (gtk_text_iter_forward_line (&next_iter))
{
gboolean start = TRUE;
start_ptr = text = gtk_text_iter_get_text (&start_iter, &next_iter);
do
{
parse_chars (start_ptr, &end_ptr, &state, &tag, start);
start = FALSE;
if (end_ptr)
{
tmp_iter = start_iter;
gtk_text_iter_forward_chars (&tmp_iter, end_ptr - start_ptr);
}
else
{
tmp_iter = next_iter;
}
if (tag)
gtk_text_buffer_apply_tag_by_name (source_buffer, tag, &start_iter, &tmp_iter);
start_iter = tmp_iter;
start_ptr = end_ptr;
}
while (end_ptr);
g_free (text);
start_iter = next_iter;
}
}
static void
directions_buffer_changed (GtkTextBuffer *textbuffer,
gpointer user_data)
{
GPInstructLessonTestMultiChoiceEditor *editor = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data);
GPInstructLessonTestMultiChoiceEditorPrivate *priv = editor->priv;
GtkTextIter start, end;
gchar *text;
gtk_text_buffer_get_bounds (textbuffer, &start, &end);
text = gtk_text_iter_get_text (&start, &end);
gpinstruct_lesson_test_set_directions (GPINSTRUCT_LESSON_TEST (priv->test),
text);
g_free (text);
gpinstruct_editor_window_set_modified (priv->window, TRUE);
}
bool CheckCapitalization::is_reference(GtkTextIter iter)
/*
Looks whether the text at iter looks like a reference.
A reference, e.g. Mt.5.5 or Mt.5:5 or John 10:5 follows a certain pattern,
while going through it. Some references are given without the bookname, e.g.
"10.5". Handle these too.
Patterns:
- digit, dot/colon, digit.
*/
{
GtkTextIter iter0 = iter;
gtk_text_iter_backward_chars(&iter0, 4);
gtk_text_iter_forward_chars(&iter, 4);
ustring reference = gtk_text_iter_get_text(&iter0, &iter);
return text_contains_reference(reference);
}
/* TODO: Move to ConboyNoteBuffer
* The return value needs to be freed by the caller.
*/
gchar* note_extract_title_from_buffer(GtkTextBuffer *buffer)
{
GtkTextIter start, end;
gchar* title;
/* Set end iter depending on if we have one or more lines */
if (gtk_text_buffer_get_line_count(buffer) == 1) {
gtk_text_buffer_get_end_iter(buffer, &end);
} else {
gtk_text_buffer_get_iter_at_line(buffer, &end, 1);
gtk_text_iter_backward_char(&end);
}
gtk_text_buffer_get_start_iter(buffer, &start);
title = gtk_text_iter_get_text(&start, &end);
return title;
}
//================================================================
int GUI_edi_sel_wrf (MemObj *mo, char *fnam) {
//================================================================
/// \code
/// GUI_edi_sel_wrf write selected -> file
/// returns nr of chars
/// \endcode
GtkTextIter it1, it2;
int i1;
char *text;
FILE *fpo;
// printf("GUI_Ed_sel_wrf |%s|\n",fnam);
if((fpo=fopen(fnam,"wb")) == NULL) {
TX_Print("GUI_Ed_sel_wrf E001 |%s|",fnam);
return -2;
}
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// get get iters for "insert" & "selection_bound"
gtk_text_buffer_get_selection_bounds (GUI_ed1_buff, &it1, &it2);
// get text
text = gtk_text_iter_get_text (&it1, &it2);
// printf("/%s/\n",text);
i1 = strlen(text);
fwrite(text, i1, 1, fpo);
g_free (text);
fclose(fpo);
return i1;
}
static gchar *
get_url_at_iter (GtkTextBuffer *buffer,
GtkTextIter *iter)
{
GtkTextTagTable *tag_table;
GtkTextTag *tag;
GtkTextIter start, end;
gchar *url = NULL;
g_return_val_if_fail (buffer != NULL, NULL);
tag_table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (tag_table, E_BUFFER_TAGGER_LINK_TAG);
g_return_val_if_fail (tag != NULL, NULL);
if (get_tag_bounds (iter, tag, &start, &end))
url = gtk_text_iter_get_text (&start, &end);
return url;
}
// Koloruje słowa nie ze słownika na czerwono
static void ColorMistakes (GtkMenuItem *item, gpointer data) {
GtkTextIter start, end, buffEnd;
gtk_text_buffer_get_start_iter(editor_buf, &end);
//Teraz sztuczką przesuwamy końcowy iterator na koniec ostatniego słowa
gtk_text_buffer_get_end_iter(editor_buf, &buffEnd);
gtk_text_iter_backward_word_start(&buffEnd);
gtk_text_iter_forward_word_end(&buffEnd);
gtk_text_buffer_create_tag(editor_buf, "red_fg",
"foreground", "red",
"weight", PANGO_WEIGHT_BOLD, NULL);
// Aktualizacja słownika
if(update_actual_dict() < 0)
return;
start = end;
while (!gtk_text_iter_equal(&end, &buffEnd)) {
// Inkrementacja zmiennych
gtk_text_iter_forward_word_end(&end);
start = end;
gtk_text_iter_backward_word_start(&start);
// Usuwamy etykietkę ze słowa jeśli jest
gtk_text_buffer_remove_tag_by_name(editor_buf, "red_fg",
&start, &end);
// Separujemy słowo
char* word = gtk_text_iter_get_text(&start, &end);
gunichar* wword = g_utf8_to_ucs4_fast(word, -1, NULL);
// Jeśli znaleziono w słowniku to kolorujemy
if(!dictionary_find(dict, (const wchar_t*)wword))
gtk_text_buffer_apply_tag_by_name(editor_buf, "red_fg",
&start, &end);
g_free(word);
}
}
void insert_open_brace(GtkWidget **tip_win, GtkWidget *text_view, GtkTextIter *arg1)
{
GdkWindow *win;
GtkTextIter start;
GdkRectangle buf_loc;
gint x, y;
gint win_x, win_y;
gchar *text;
gchar *tip_text;
start = *arg1;
if (!gtk_text_iter_backward_word_start (&start))
return;
text = gtk_text_iter_get_text (&start, arg1);
g_strstrip (text);
tip_text = get_tip(text);
if (tip_text == NULL)
return;
gtk_text_view_get_iter_location (GTK_TEXT_VIEW (text_view), arg1, &buf_loc);
g_printf ("Buffer: %d, %d\n", buf_loc.x, buf_loc.y);
gtk_text_view_buffer_to_window_coords (GTK_TEXT_VIEW (text_view),
GTK_TEXT_WINDOW_WIDGET,
buf_loc.x, buf_loc.y,
&win_x, &win_y);
g_printf ("Window: %d, %d\n", win_x, win_y);
win = gtk_text_view_get_window (GTK_TEXT_VIEW (text_view),
GTK_TEXT_WINDOW_WIDGET);
gdk_window_get_origin (win, &x, &y);
if (*tip_win != NULL)
gtk_widget_destroy (GTK_WIDGET (*tip_win));
*tip_win = tip_window_new (tip_text);
g_free(tip_text);
gtk_window_move (GTK_WINDOW (*tip_win), win_x + x,
win_y + y + buf_loc.height);
gtk_widget_show_all (*tip_win);
}
gboolean search_tools_active_search_entry(GtkWidget* widget, GdkEventFocus* event, SearchTools* self) {
GtkTextBuffer* buf;
gint page_num;
page_num = gtk_notebook_get_current_page(puss_get_doc_panel(self->app));
if( page_num >= 0 ) {
buf = self->app->doc_get_buffer_from_page_num(page_num);
if( buf ) {
GtkTextIter ps, pe;
if( gtk_text_buffer_get_selection_bounds(buf, &ps, &pe) ) {
gchar* text = gtk_text_iter_get_text(&ps, &pe);
if( text ) {
gtk_entry_set_text(self->search_entry, text);
g_free(text);
}
}
}
}
gtk_widget_grab_focus(GTK_WIDGET(self->search_entry));
return TRUE;
}
ParseWords::ParseWords(const ustring & text)
// Parses a line of text in its separate words.
// Note: This is comparable to object Parse, but does a better job.
{
// 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;
// Parse into 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);
ustring word = gtk_text_iter_get_text(&startiter, &enditer);
words.push_back(word);
}
// Free memory
g_object_unref(textbuffer);
}
ustring CheckMatchingPairs::get_context(ustring & line, unsigned int offset)
// Returns the context at offset: A couple of words before and after.
{
// Result.
ustring returnvalue;
// Load text into buffer.
GtkTextBuffer *textbuffer;
textbuffer = gtk_text_buffer_new(NULL);
gtk_text_buffer_set_text(textbuffer, line.c_str(), -1);
// Iterators.
GtkTextIter iter1;
GtkTextIter iter2;
// Find boundaries of context to return.
gtk_text_buffer_get_iter_at_offset(textbuffer, &iter1, offset);
iter2 = iter1;
gtk_text_iter_backward_word_starts(&iter1, 2);
gtk_text_iter_forward_word_ends(&iter2, 2);
return gtk_text_iter_get_text(&iter1, &iter2);
// Free memory
g_object_unref(textbuffer);
// Give us the result.
return returnvalue;
}
/* 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);
}
}
/**
Sprawdzenie słowa, na którym aktualnie znajduje się kursor. Ewentualne dodanie do słownika.
@param[in] item element menu.
@param[in] data wskaźnik na wartość.
*/
static void WhatCheck (GtkMenuItem *item, gpointer data) {
GtkWidget *dialog;
GtkTextIter start, end;
char *word;
gunichar *wword;
//load_dictionary_from_menu(&dict);
// Znajdujemy pozycję kursora
gtk_text_buffer_get_iter_at_mark(editor_buf, &start,
gtk_text_buffer_get_insert(editor_buf));
// Jeśli nie wewnątrz słowa, kończymy
if (!gtk_text_iter_inside_word(&start)) {
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"Kursor musi być w środku słowa");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
// Znajdujemy początek i koniec słowa, a potem samo słowo
end = start;
gtk_text_iter_backward_word_start(&start);
gtk_text_iter_forward_word_end(&end);
word = gtk_text_iter_get_text(&start, &end);
// Zamieniamy na wide char (no prawie)
wword = g_utf8_to_ucs4_fast(word, -1, NULL);
if (!make_lowercase(wword)) {
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"Podane słowo nie jest słowem słownikowym.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
else {
// Sprawdzamy
if (dictionary_find(dict, (wchar_t *)wword)) {
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"Wszystko w porządku,\nśpij spokojnie");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
else {
// Czas korekty
GtkWidget *vbox, *label, *combo;
struct word_list hints;
int i;
wchar_t **words;
dictionary_hints(dict, (wchar_t *)wword, &hints);
words = (wchar_t **) word_list_get(&hints);
dialog = gtk_dialog_new_with_buttons("Korekta", NULL, 0,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_ADD,
GTK_RESPONSE_APPLY,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL);
// W treści dialogu dwa elementy
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
// Tekst
label = gtk_label_new("Słowo nie znajduje się w słowniku. Wybierz \njedną z propozycji lub dodaj słowa do słownika.");
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 1);
// Spuszczane menu
combo = gtk_combo_box_text_new();
for (i = 0; i < word_list_size(&hints); i++) {
// Combo box lubi mieć Gtk
char *uword = g_ucs4_to_utf8((gunichar *)words[i], -1, NULL, NULL, NULL);
// Dodajemy kolejny element
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), uword);
g_free(uword);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 1);
gtk_widget_show(combo);
gint click = gtk_dialog_run(GTK_DIALOG(dialog));
if (click == GTK_RESPONSE_ACCEPT) {
char *korekta =
gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
// Usuwamy stare
gtk_text_buffer_delete(editor_buf, &start, &end);
// Wstawiamy nowe
gtk_text_buffer_insert(editor_buf, &start, korekta, -1);
g_free(korekta);
}
// Proponujemy dodanie słowa do słownika
else if (click == GTK_RESPONSE_APPLY)
dictionary_insert(dict, wword);
gtk_widget_destroy(dialog);
}
}
g_free(word);
g_free(wword);
}
static void about_textview_uri_update(GtkWidget *textview, gint x, gint y)
{
GtkTextBuffer *buffer;
GtkTextIter start_iter, end_iter;
gchar *uri = NULL;
gboolean same;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
if (x != -1 && y != -1) {
gint bx, by;
GtkTextIter iter;
GSList *tags;
GSList *cur;
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(textview),
GTK_TEXT_WINDOW_WIDGET,
x, y, &bx, &by);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(textview),
&iter, bx, by);
tags = gtk_text_iter_get_tags(&iter);
for (cur = tags; cur != NULL; cur = cur->next) {
GtkTextTag *tag = cur->data;
char *name;
g_object_get(G_OBJECT(tag), "name", &name, NULL);
if (strcmp(name, "link") == 0
&& get_tag_range(&iter, tag, &start_iter, &end_iter)) {
uri = gtk_text_iter_get_text(&start_iter, &end_iter);
}
g_free(name);
if (uri) {
break;
}
}
g_slist_free(tags);
}
/* compare previous hovered link and this one
(here links must be unique in text buffer otherwise ClickableText structures should be
used as in textview.c) */
same = (uri != NULL && uri_hover != NULL
&& strcmp((char*)uri, (char*)uri_hover) == 0);
if (same == FALSE) {
GdkWindow *window;
if (uri_hover) {
gtk_text_buffer_remove_tag_by_name(buffer,
"link-hover",
&uri_hover_start_iter,
&uri_hover_end_iter);
}
uri_hover = uri;
if (uri) {
uri_hover_start_iter = start_iter;
uri_hover_end_iter = end_iter;
gtk_text_buffer_apply_tag_by_name(buffer,
"link-hover",
&start_iter,
&end_iter);
}
window = gtk_text_view_get_window(GTK_TEXT_VIEW(textview),
GTK_TEXT_WINDOW_TEXT);
if (!hand_cursor)
hand_cursor = gdk_cursor_new(GDK_HAND2);
if (!text_cursor)
text_cursor = gdk_cursor_new(GDK_XTERM);
gdk_window_set_cursor(window, uri ? hand_cursor : text_cursor);
}
}