static gint
ev_view_accessible_get_n_selections (AtkText *text)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
GtkTextIter start, end;
gint select_start, select_end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return -1;
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return -1;
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
select_start = gtk_text_iter_get_offset (&start);
select_end = gtk_text_iter_get_offset (&end);
if (select_start != select_end)
return 1;
else
return 0;
}
/* returns the number of bytes
that are already present in the text.
this is used to avoid for example inserting "return;" in a location where ';' is already the
character directly beyond the insert position.
*/
static gint
get_existing_end_len(BluefishTextView * btv, const gchar *string, gint prefix_bytelen)
{
gchar *tmp;
GtkTextIter it1, it2;
gint i,len;
gint string_len = g_utf8_strlen(string, -1);
gtk_text_buffer_get_iter_at_mark(btv->buffer, &it1, gtk_text_buffer_get_insert(btv->buffer));
it2 = it1;
DBG_AUTOCOMP("get_existing_end_len, forward %d chars\n",string_len - prefix_bytelen);
gtk_text_iter_forward_chars(&it2,string_len - prefix_bytelen);
DBG_AUTOCOMP("get the text %d:%d\n",gtk_text_iter_get_offset(&it1),gtk_text_iter_get_offset(&it2));
tmp = gtk_text_buffer_get_text(btv->buffer, &it1, &it2, TRUE);
/*g_print("got tmp='%s'\n",tmp);*/
len = strlen(tmp);
i = len-1;
do {
DBG_AUTOCOMP("get_existing_end_len, compare %d characters of %s and %s\n",i,string+prefix_bytelen+len-i,tmp);
if (strncmp(string+prefix_bytelen+len-i, tmp, i)==0) {
DBG_AUTOCOMP("get_existing_end_len, found %d existing characters\n",i);
g_free(tmp);
return i;
}
i--;
} while(i>0);
g_free(tmp);
DBG_AUTOCOMP("get_existing_end_len, found no existing characters\n");
return 0;
}
gTextAreaAction *gTextAreaAction::deleteAction(GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end)
{
GtkTextIter insert_iter;
int insert_offset;
GtkTextMark *mark;
gTextAreaAction *action = new gTextAreaAction;
char *text;
action->type = ACTION_DELETE;
text = gtk_text_buffer_get_text(buffer, start, end, FALSE);
action->text = g_string_new(text);
action->length = g_utf8_strlen(action->text->str, action->text->len);
g_free(text);
action->start = gtk_text_iter_get_offset(start);
action->end = gtk_text_iter_get_offset(end);
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &insert_iter, mark);
insert_offset = gtk_text_iter_get_offset(&insert_iter);
action->delete_key_used = insert_offset < action->start;
action->mergeable = (action->length == 1) && *(action->text->str) != '\r' && *(action->text->str) != '\n' && *(action->text->str) != ' ';
return action;
}
static gboolean locate_color(Tdocument *doc, const GtkTextIter *iter) {
Tin_html_tag iht;
gboolean retval=FALSE;
GtkTextIter leftiter=*iter, rightiter, maxiter = *iter;
DEBUG_MSG("locate_color, started\n");
rec_color.found = FALSE;
gtk_text_iter_backward_chars(&maxiter, 8);
/* first we look to the left for a #, and we look back at max. 8 chars (7 would be good enough) */
iht.findchar = '#';
iht.prevchar = '\n';
iht.ignore_if_prevchar = '\0';
if (gtk_text_iter_backward_find_char(&leftiter,
(GtkTextCharPredicate)iter_char_search_lcb,&iht,&maxiter))
{
gchar *text;
rightiter = leftiter;
gtk_text_iter_forward_chars(&rightiter, 7);
text = gtk_text_buffer_get_text(doc->buffer,&leftiter,&rightiter,FALSE);
DEBUG_MSG("locate_color,is '%s' a color?\n",text);
if (text) {
retval = string_is_color(text);
if (retval) {
rec_color.so = gtk_text_iter_get_offset(&leftiter);
rec_color.eo = gtk_text_iter_get_offset(&rightiter);
rec_color.found = TRUE;
rec_color.doc = doc;
DEBUG_MSG("found color from so=%d to eo=%d\n",rec_color.so, rec_color.eo);
}
g_free(text);
}
}
return retval;
}
static void
select_range (Movement *mv,
GtkTextIter *insert_iter,
GtkTextIter *selection_iter)
{
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextMark *selection;
gint insert_off;
gint selection_off;
g_assert (insert_iter);
g_assert (selection_iter);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
insert = gtk_text_buffer_get_insert (buffer);
selection = gtk_text_buffer_get_selection_bound (buffer);
mv->ignore_select = TRUE;
/*
* If the caller is requesting that we select a single character, we will
* keep the iter before that character. This more closely matches the visual
* mode in VIM.
*/
insert_off = gtk_text_iter_get_offset (insert_iter);
selection_off = gtk_text_iter_get_offset (selection_iter);
if ((insert_off - selection_off) == 1)
gtk_text_iter_order (insert_iter, selection_iter);
gtk_text_buffer_move_mark (buffer, insert, insert_iter);
gtk_text_buffer_move_mark (buffer, selection, selection_iter);
}
/*
* Links can also be activated by clicking.
*/
static void
event_after (GtkWidget *text_view, GdkEvent *ev, GdauiCloud *cloud)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
GdkEventButton *event;
gint x, y;
if (ev->type != GDK_BUTTON_RELEASE)
return;
event = (GdkEventButton *)ev;
if (event->button != 1)
return;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
/* we shouldn't follow a link if the user has selected something */
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
if (gtk_text_iter_get_offset (&start) != gtk_text_iter_get_offset (&end))
return;
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),
GTK_TEXT_WINDOW_WIDGET,
event->x, event->y, &x, &y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (text_view), &iter, x, y);
follow_if_link (text_view, &iter, cloud);
return;
}
//================================================================
int GUI_edi_sel_get (long *p1, long *p2, MemObj *mo) {
//================================================================
/// \code
/// write selected -> file
/// txlen input = size of txbuf; Output = nr of characters read
/// \endcode
GtkTextIter it1, it2;
long i1;
char *text;
// printf("GUI_edi_sel_wrf |%s|\n",fnam);
// set GUI_ed1_view GUI_ed1_buff
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 offsets
*p1 = (long)gtk_text_iter_get_offset (&it1);
*p2 = (long)gtk_text_iter_get_offset (&it2);
return 0;
}
static gboolean
event_after (GtkWidget *text_view,
GdkEvent *ev)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
GdkEventButton *event;
gint x, y;
if (ev->type != GDK_BUTTON_RELEASE)
return FALSE;
event = (GdkEventButton *)ev;
if (event->button != 1)
return FALSE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
if (gtk_text_iter_get_offset (&start) != gtk_text_iter_get_offset (&end))
return FALSE;
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),
GTK_TEXT_WINDOW_WIDGET,
event->x, event->y, &x, &y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (text_view), &iter, x, y);
follow_if_link (text_view, &iter);
return FALSE;
}
static gchar*
ev_view_accessible_get_selection (AtkText *text,
gint selection_num,
gint *start_pos,
gint *end_pos)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
GtkTextIter start, end;
gchar *retval = NULL;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return NULL;
if (selection_num != 0)
return NULL;
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return NULL;
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
*start_pos = gtk_text_iter_get_offset (&start);
*end_pos = gtk_text_iter_get_offset (&end);
if (*start_pos != *end_pos)
retval = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
return retval;
}
/**
* undo_get_selection:
* @text: Text to get the selection from
* @start: return here the start position of the selection
* @end: return here the end position of the selection
*
* Gets the current selection for View
*
* Return Value: TRUE if there is a selection active, FALSE if not
**/
static gint undo_get_selection(GtkTextView *textview, guint *start, guint *end)
{
GtkTextBuffer *buffer;
GtkTextIter start_iter, end_iter;
guint start_pos, end_pos;
buffer = gtk_text_view_get_buffer(textview);
gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);
start_pos = gtk_text_iter_get_offset(&start_iter);
end_pos = gtk_text_iter_get_offset(&end_iter);
/* The user can select from end to start too. If so, swap it*/
if (end_pos < start_pos) {
guint swap_pos;
swap_pos = end_pos;
end_pos = start_pos;
start_pos = swap_pos;
}
if (start != NULL)
*start = start_pos;
if (end != NULL)
*end = end_pos;
if ((start_pos > 0 || end_pos > 0) && (start_pos != end_pos))
return TRUE;
else
return FALSE;
}
void
ide_source_snippet_before_delete_range (IdeSourceSnippet *self,
GtkTextBuffer *buffer,
GtkTextIter *begin,
GtkTextIter *end)
{
IdeSourceSnippetChunk *chunk;
gchar *new_text;
gint *run;
gint len;
gint n;
gint i;
gint lower_bound = -1;
gint upper_bound = -1;
g_return_if_fail (IDE_IS_SOURCE_SNIPPET (self));
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (begin);
g_return_if_fail (end);
len = gtk_text_iter_get_offset (end) - gtk_text_iter_get_offset (begin);
n = ide_source_snippet_get_index (self, begin);
self->current_chunk = n;
while (len && n < self->runs->len)
{
if (lower_bound == -1 || n < lower_bound)
lower_bound = n;
if (n > upper_bound)
upper_bound = n;
run = &g_array_index (self->runs, gint, n);
if (len > *run)
{
len -= *run;
*run = 0;
n++;
continue;
}
*run -= len;
len = 0;
break;
}
for (i = lower_bound; i <= upper_bound; i++)
{
chunk = g_ptr_array_index (self->chunks, i);
new_text = ide_source_snippet_get_nth_text (self, i);
ide_source_snippet_chunk_set_text (chunk, new_text);
ide_source_snippet_chunk_set_text_set (chunk, TRUE);
g_free (new_text);
}
#if 0
g_print ("D: ");
for (n = 0; n < self->runs->len; n++)
g_print ("%d ", g_array_index (self->runs, gint, n));
g_print ("\n");
#endif
}
static guint
get_selection_anchor_point (FcitxIMContext *fcitxcontext,
guint cursor_pos,
guint surrounding_text_len)
{
GtkWidget *widget;
if (fcitxcontext->client_window == NULL) {
return cursor_pos;
}
gdk_window_get_user_data (fcitxcontext->client_window, (gpointer *)&widget);
if (!GTK_IS_TEXT_VIEW (widget)) {
return cursor_pos;
}
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
if (!gtk_text_buffer_get_has_selection (buffer)) {
return cursor_pos;
}
GtkTextIter start_iter, end_iter, cursor_iter;
if (!gtk_text_buffer_get_selection_bounds (buffer, &start_iter, &end_iter)) {
return cursor_pos;
}
gtk_text_buffer_get_iter_at_mark (buffer,
&cursor_iter,
gtk_text_buffer_get_insert (buffer));
guint start_index = gtk_text_iter_get_offset (&start_iter);
guint end_index = gtk_text_iter_get_offset (&end_iter);
guint cursor_index = gtk_text_iter_get_offset (&cursor_iter);
guint anchor;
if (start_index == cursor_index) {
anchor = end_index;
} else if (end_index == cursor_index) {
anchor = start_index;
} else {
return cursor_pos;
}
// Change absolute index to relative position.
guint relative_origin = cursor_index - cursor_pos;
if (anchor < relative_origin) {
return cursor_pos;
}
anchor -= relative_origin;
if (anchor > surrounding_text_len) {
return cursor_pos;
}
return anchor;
}
void
dma_data_view_refresh (DmaDataView *view)
{
gchar *data = "";
gint offset;
GtkTextIter cur;
GtkTextMark *mark;
GtkTextBuffer *buffer;
/* Save all cursor offset */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view->address));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
offset = gtk_text_iter_get_offset (&cur);
data = dma_data_buffer_get_address (view->buffer, view->start, view->line_by_page * view->bytes_by_line, view->bytes_by_line, sizeof(view->start) * 2);
gtk_text_buffer_set_text (buffer, data, -1);
g_free (data);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
gtk_text_iter_set_offset (&cur, offset);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &cur);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cur);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view->data));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
offset = gtk_text_iter_get_offset (&cur);
data = dma_data_buffer_get_data (view->buffer, view->start, view->line_by_page * view->bytes_by_line, view->bytes_by_line, DMA_HEXADECIMAL_BASE);
gtk_text_buffer_set_text (buffer, data, -1);
g_free (data);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
gtk_text_iter_set_offset (&cur, offset);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &cur);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cur);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view->ascii));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
offset = gtk_text_iter_get_offset (&cur);
data = dma_data_buffer_get_data (view->buffer, view->start, view->line_by_page * view->bytes_by_line, view->bytes_by_line, DMA_ASCII_BASE);
gtk_text_buffer_set_text (buffer, data, -1);
g_free (data);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
gtk_text_iter_set_offset (&cur, offset);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &cur);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cur);
}
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;
}
static gboolean locate_current_tag(Tdocument *doc, const GtkTextIter *iter) {
GtkTextIter gtiter, ltiter;
gboolean ltfound, gtfound;
Tin_html_tag iht;
gtiter = ltiter = *iter;
rec_tag.found = FALSE;
/* backward search for tag start */
iht.findchar = '>';
iht.prevchar = '\n';
iht.ignore_if_prevchar = 0;
gtfound = gtk_text_iter_backward_find_char(>iter,(GtkTextCharPredicate)iter_char_search_lcb,
&iht,NULL);
/* perhaps we should limit the search fto 50 charcters or so */
iht.findchar = '<';
iht.prevchar = '\n';
iht.ignore_if_prevchar = '?';
ltfound = gtk_text_iter_backward_find_char(<iter,(GtkTextCharPredicate)iter_char_search_lcb,
&iht,NULL);
rec_tag.so = rec_tag.eo = -1;
rec_tag.doc = doc;
if ((ltfound && gtfound && gtk_text_iter_compare(<iter,>iter) > 0)
|| (ltfound && !gtfound)) {
rec_tag.so = gtk_text_iter_get_offset(<iter);
DEBUG_MSG("a tag is started on the left side at %d\n",rec_tag.so);
} else {
DEBUG_MSG("no tag start found on the left side\n");
}
if (rec_tag.so >=0) {
/* forward search for end tag */
iht.findchar = 62;/* 62 = > */
iht.prevchar = 10; /* \n */
iht.ignore_if_prevchar = 63 /* ? */;
gtfound = gtk_text_iter_forward_find_char(>iter,(GtkTextCharPredicate)iter_char_search_lcb,
&iht,NULL);
/* perhaps we should limit the search fto 50 charcters or so */
iht.findchar = 60;/* 60 = < */
iht.prevchar = 10; /* \n */
iht.ignore_if_prevchar = 0;
ltfound = gtk_text_iter_forward_find_char(<iter,(GtkTextCharPredicate)iter_char_search_lcb,
&iht,NULL);
if ((ltfound && gtfound && gtk_text_iter_compare(<iter,>iter) > 0)
|| (gtfound && !ltfound)) {
rec_tag.eo = gtk_text_iter_get_offset(>iter)+1;
DEBUG_MSG("a tag is ended on the right side at %d\n",rec_tag.eo);
rec_tag.found = TRUE;
return TRUE;
} else {
DEBUG_MSG("no tag end found on the right side\n");
}
}
return FALSE;
}
/* vers=0: right == NOOPS*/
static void doc_shift_selection( Tdocument *doc, gboolean vers ) {
GtkTextIter itstart, itend;
if ( gtk_text_buffer_get_selection_bounds( doc->buffer, &itstart, &itend ) ) {
GtkTextMark * end;
doc_unbind_signals( doc );
doc_unre_new_group( doc );
/* we have a selection, now we loop trough the characters, and for every newline
we add or remove a tab, we set the end with a mark */
end = gtk_text_buffer_create_mark( doc->buffer, NULL, &itend, TRUE );
/* set to: the fist char of the fist line */
if ( gtk_text_iter_get_line_offset( &itstart ) > 0 ) {
gtk_text_iter_set_line_index( &itstart, 0 );
}
/* remove one line from current selection for each step*/
while ( gtk_text_iter_compare( &itstart, &itend ) < 0 ) {
GtkTextMark * cur;
cur = gtk_text_buffer_create_mark( doc->buffer, NULL, &itstart, TRUE );
if ( vers ) {
itend = itstart;
gtk_text_iter_forward_chars( &itend, 1 );
gchar *buf = gtk_text_buffer_get_text( doc->buffer, &itstart, &itend, FALSE );
if ( !strstr( buf, "\n" ) ) {
gint offsetstart, offsetend;
offsetstart = gtk_text_iter_get_offset( &itstart );
offsetend = gtk_text_iter_get_offset( &itend );
gtk_text_buffer_delete( doc->buffer, &itstart, &itend );
doc_unre_add( doc, buf, offsetstart, offsetend, UndoDelete );
}
g_free( buf );
}
gtk_text_buffer_get_iter_at_mark( doc->buffer, &itstart, cur );
gtk_text_buffer_get_iter_at_mark( doc->buffer, &itend, end );
gtk_text_buffer_delete_mark( doc->buffer, cur );
/* forward one more line */
gtk_text_iter_forward_line( &itstart );
}
gtk_text_buffer_delete_mark( doc->buffer, end );
doc_bind_signals( doc );
doc_set_modified( doc, 1 );
} else {
/* there is no selection, work on the current line */
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark( doc->buffer, &iter, gtk_text_buffer_get_insert( doc->buffer ) );
if ( vers ) {
GtkTextIter itend;
gtk_text_iter_set_line_offset( &iter, 0 );
itend = iter;
gtk_text_iter_forward_chars( &itend, 1 );
gtk_text_buffer_delete( doc->buffer, &iter, &itend );
}
}
}
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));
}
Highlight::Highlight(GtkTextBuffer * buffer, GtkWidget * textview, const ustring & project, GtkTextTag * tag, const ustring & verse)
{
// Save and initialize variables.
maintextbuffer = buffer;
maintextview = GTK_TEXT_VIEW(textview);
mytag = tag;
locations_ready = false;
interrupt_thread = false;
// Remove any previous highlights.
remove_previous_highlights(maintextbuffer);
// Determine the boundaries between which to highlight,
// in order to highlight only the words that are within the right verse.
{
GtkTextIter startiter;
GtkTextIter enditer;
gtk_text_buffer_get_start_iter(maintextbuffer, &startiter);
gtk_text_buffer_get_end_iter(maintextbuffer, &enditer);
GtkTextIter iter = startiter;
bool started = false;
bool ended = false;
bool start = true;
ustring verse_style = style_get_verse_marker(project);
while (!gtk_text_iter_is_end(&iter)) {
ustring paragraph_style, character_style;
get_styles_at_iterator(iter, paragraph_style, character_style);
if (start || (character_style == verse_style)) {
ustring verse_at_iter = get_verse_number_at_iterator(iter, verse_style, "", NULL);
if (verse == verse_at_iter) {
if (!started) {
started = true;
startiter = iter;
}
} else {
if (started) {
if (!ended) {
ended = true;
enditer = iter;
}
}
}
}
start = false;
gtk_text_iter_forward_char(&iter);
}
main_start_offset = gtk_text_iter_get_offset(&startiter);
main_end_offset = gtk_text_iter_get_offset(&enditer);
}
}
/* Links can also be activated by clicking or tapping.
*/
static gboolean
event_after (GtkWidget *text_view,
GdkEvent *ev)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
gdouble ex, ey;
gint x, y;
if (ev->type == GDK_BUTTON_RELEASE)
{
GdkEventButton *event;
event = (GdkEventButton *)ev;
if (event->button != GDK_BUTTON_PRIMARY)
return FALSE;
ex = event->x;
ey = event->y;
}
else if (ev->type == GDK_TOUCH_END)
{
GdkEventTouch *event;
event = (GdkEventTouch *)ev;
ex = event->x;
ey = event->y;
}
else
return FALSE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
/* we shouldn't follow a link if the user has selected something */
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
if (gtk_text_iter_get_offset (&start) != gtk_text_iter_get_offset (&end))
return FALSE;
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),
GTK_TEXT_WINDOW_WIDGET,
ex, ey, &x, &y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (text_view), &iter, x, y);
follow_if_link (text_view, &iter);
return TRUE;
}
static void cb_delete_range(GtkTextBuffer *buffer, GtkTextIter *start_iter, GtkTextIter *end_iter)
{
gint start, end;
gchar command;
DV( g_print("delete-range\n"));
start = gtk_text_iter_get_offset(start_iter);
end = gtk_text_iter_get_offset(end_iter);
if (get_current_keyval() == GDK_BackSpace)
command = BS;
else
command = DEL;
undo_create_undo_info(buffer, command, start, end);
}
/* Links can also be activated by clicking.
*/
static gboolean
event_after (GtkWidget* text_view, GdkEvent* ev, UgBanner* banner)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
GdkEventButton *event;
gint x, y;
GSList* slist;
if (ev->type != GDK_BUTTON_RELEASE)
return FALSE;
event = (GdkEventButton *)ev;
if (event->button != GDK_BUTTON_PRIMARY)
return FALSE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
/* we shouldn't follow a link if the user has selected something */
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
if (gtk_text_iter_get_offset (&start) != gtk_text_iter_get_offset (&end))
return FALSE;
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),
GTK_TEXT_WINDOW_WIDGET,
event->x, event->y, &x, &y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (text_view), &iter, x, y);
slist = gtk_text_iter_get_tags (&iter);
if (slist) {
switch (banner->status) {
case UG_BANNER_DONATION:
// ug_launch_uri ("https://sourceforge.net/p/urlget/donate/?source=navbar");
ug_launch_uri ("http://ugetdm.com/donate");
break;
case UG_BANNER_SURVEY:
ug_launch_uri ("http://ugetdm.com/survey");
break;
}
}
if (slist)
g_slist_free (slist);
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;
}
static void
save_metadata (GeditDocument *doc)
{
const gchar *language = NULL;
GtkTextIter iter;
gchar *position;
if (doc->priv->language_set_by_user)
{
language = get_language_string (doc);
}
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
&iter,
gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (doc)));
position = g_strdup_printf ("%d", gtk_text_iter_get_offset (&iter));
if (language == NULL)
{
gedit_document_set_metadata (doc,
GEDIT_METADATA_ATTRIBUTE_POSITION, position,
NULL);
}
else
{
gedit_document_set_metadata (doc,
GEDIT_METADATA_ATTRIBUTE_POSITION, position,
GEDIT_METADATA_ATTRIBUTE_LANGUAGE, language,
NULL);
}
g_free (position);
}
JNIEXPORT jint JNICALL
Java_gnu_java_awt_peer_gtk_GtkTextAreaPeer_getCaretPosition
(JNIEnv *env, jobject obj)
{
void *ptr;
int pos = 0;
GtkWidget *text = NULL;
GtkTextBuffer *buf;
GtkTextMark *mark;
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));
mark = gtk_text_buffer_get_insert (buf);
gtk_text_buffer_get_iter_at_mark (buf, &iter, mark);
pos = gtk_text_iter_get_offset (&iter);
gdk_threads_leave ();
return pos;
}
/*****************************************************************************
Appends the string to the chat output window. The string should be
inserted on its own line, although it will have no newline.
*****************************************************************************/
void real_luaconsole_append(const char *astring,
const struct text_tag_list *tags)
{
GtkTextBuffer *buf;
GtkTextIter iter;
GtkTextMark *mark;
ft_offset_t text_start_offset;
struct luaconsole_data *pdialog = luaconsole_dialog_get();
fc_assert_ret(pdialog);
buf = pdialog->message_buffer;
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_insert(buf, &iter, "\n", -1);
mark = gtk_text_buffer_create_mark(buf, NULL, &iter, TRUE);
if (gui_gtk2_show_chat_message_time) {
char timebuf[64];
time_t now;
struct tm *now_tm;
now = time(NULL);
now_tm = localtime(&now);
strftime(timebuf, sizeof(timebuf), "[%H:%M:%S] ", now_tm);
gtk_text_buffer_insert(buf, &iter, timebuf, -1);
}
text_start_offset = gtk_text_iter_get_offset(&iter);
gtk_text_buffer_insert(buf, &iter, astring, -1);
text_tag_list_iterate(tags, ptag) {
apply_text_tag(ptag, buf, text_start_offset, astring);
} text_tag_list_iterate_end;
static gboolean
goto_next_word (GeditDocument *doc)
{
CheckRange *range;
GtkTextIter current_iter;
GtkTextIter old_current_iter;
GtkTextIter end_iter;
gedit_debug (DEBUG_PLUGINS);
g_return_val_if_fail (doc != NULL, FALSE);
range = get_check_range (doc);
g_return_val_if_fail (range != NULL, FALSE);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
¤t_iter,
range->current_mark);
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end_iter);
old_current_iter = current_iter;
gtk_text_iter_forward_word_ends (¤t_iter, 2);
gtk_text_iter_backward_word_start (¤t_iter);
if (gedit_spell_utils_skip_no_spell_check (¤t_iter, &end_iter) &&
(gtk_text_iter_compare (&old_current_iter, ¤t_iter) < 0) &&
(gtk_text_iter_compare (¤t_iter, &end_iter) < 0))
{
update_current (doc, gtk_text_iter_get_offset (¤t_iter));
return TRUE;
}
return FALSE;
}
void Gobby::UserJoinCommands::UserJoinInfo::
add_text_user_properties(std::vector<GParameter>& params,
TextSessionView& view)
{
InfTextSession* session = view.get_session();
GParameter hue_param = { "hue", { 0 } };
g_value_init(&hue_param.value, G_TYPE_DOUBLE);
g_value_set_double(&hue_param.value,
m_commands.m_preferences.user.hue);
params.push_back(hue_param);
GParameter vector_param = { "vector", { 0 } };
g_value_init(&vector_param.value, INF_ADOPTED_TYPE_STATE_VECTOR);
g_value_take_boxed(&vector_param.value, inf_adopted_state_vector_copy(
inf_adopted_algorithm_get_current(
inf_adopted_session_get_algorithm(
INF_ADOPTED_SESSION(session)))));
params.push_back(vector_param);
GParameter caret_param = { "caret-position", { 0 } };
g_value_init(&caret_param.value, G_TYPE_UINT);
GtkTextBuffer* buffer = GTK_TEXT_BUFFER(view.get_text_buffer());
GtkTextMark* mark = gtk_text_buffer_get_insert(buffer);
GtkTextIter caret_iter;
gtk_text_buffer_get_iter_at_mark(buffer, &caret_iter, mark);
g_value_set_uint(&caret_param.value,
gtk_text_iter_get_offset(&caret_iter));
params.push_back(caret_param);
}
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);
}
/**
* \fn add_message_iter
* \brief Stores the current position in the chat window
*/
void add_message_iter(PurpleConnection *gc, const char* to, const gchar* messageid, int newlines)
{
#ifdef DEBUG
printf("to: %s \n", to);
#endif
PurpleAccount *acct = purple_connection_get_account (gc);
if(!acct) return;
PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY, to, acct);
if(!conv) return;
PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv);
GtkIMHtml *imhtml = GTK_IMHTML(gtkconv->imhtml);
message_info *info = g_new(message_info, 1);
info->textbuffer = imhtml->text_buffer;
GtkTextIter location;
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &location);
info->offset = gtk_text_iter_get_offset (&location);
info->lines = newlines;
//Insert the location to the table, use messageid as key
g_hash_table_insert(ht_locations, strdup(messageid), info);
#ifdef DEBUG
printf("attached key: %s, table size now %d \n", messageid, g_hash_table_size(ht_locations));
#endif
}
static void
print_iter(char *name, GtkTextIter *iter) {
g_print("%1s[%d%c%c%c] ", name, gtk_text_iter_get_offset(iter),
gtk_text_iter_starts_word(iter) ? 's' : ' ',
gtk_text_iter_inside_word(iter) ? 'i' : ' ',
gtk_text_iter_ends_word(iter) ? 'e' : ' ');
}
