static void bmark_popup_menu_goto_lcb(GtkWidget * widget, gpointer user_data)
{
Tbmark *b;
GtkTextIter it;
if (!user_data)
return;
b = get_current_bmark(BFWIN(user_data));
if (!b)
return;
if (b->filepath && !b->doc) {
/* check if that document _is_ open */
Tdocument *tmpdoc;
GList *doclist = return_allwindows_documentlist();
tmpdoc = documentlist_return_document_from_filename(doclist, b->filepath);
g_list_free(doclist);
if (tmpdoc == NULL) {
if (!g_file_test(b->filepath, G_FILE_TEST_EXISTS)) {
gchar *string = g_strdup_printf(_("Could not find the file \"%s\"."), b->filepath);
error_dialog(BFWIN(user_data)->main_window, string,
_("This bookmark is set in a file that no longer exists."));
g_free(string);
return;
}
tmpdoc = doc_new_with_file(BFWIN(user_data), b->filepath, FALSE, TRUE);
}
/* now I have to check all bookmarks */
bmark_set_for_doc(tmpdoc);
}
if (b->doc) {
GdkRectangle visirect;
GtkTextIter visi_so, visi_eo;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(b->doc->view),&visirect);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_so, visirect.x, visirect.y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_eo, visirect.x + visirect.width, visirect.y + visirect.height);
gtk_text_buffer_get_iter_at_mark(b->doc->buffer, &it, b->mark);
gtk_text_buffer_place_cursor(b->doc->buffer, &it);
if (!gtk_text_iter_in_range(&it,&visi_so,&visi_eo)) {
DEBUG_MSG("bmark_popup_menu_goto_lcb, cursor NOT visible!\n");
/* gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(b->doc->view), b->mark); */
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(b->doc->view),b->mark,0.0,
TRUE,0.5,0.5);
}
if (b->doc != BFWIN(user_data)->current_document)
switch_to_document_by_pointer(BFWIN(user_data), b->doc);
gtk_widget_grab_focus(b->doc->view);
}
}
void scroll_mainview_up(){
GtkTextIter iter;
GdkRectangle rect;
gint distance;
gint i;
LOG(LOG_DEBUG, "IN : scroll_mainview_up()");
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(main_view), &rect);
distance = rect.height - scroll_margin;
if(bsmooth_scroll == TRUE){
for(i=0 ; i < scroll_step; i ++){
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(main_view),
&iter,
rect.x,
rect.y - (distance / scroll_step)*(i+1));
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(main_view),
&iter,
0.0,
TRUE,
0.0, 0.0);
#ifdef __WIN32__
Sleep(scroll_time / scroll_step / 1000);
#else
usleep(scroll_time / scroll_step);
#endif
}
} else {
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(main_view),
&iter,
rect.x,
rect.y - distance);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(main_view),
&iter,
0.0,
TRUE,
0.0, 0.0);
}
LOG(LOG_DEBUG, "OUT : scroll_mainview_up()");
}
static gboolean
link_clicked (GtkWidget *widget,
GdkEventButton *event,
EventLog *log)
{
int x, y;
GtkTextIter iter;
GSList *tags, *l;
if (event->button != 1 ||
event->type != GDK_2BUTTON_PRESS)
return FALSE;
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (log->text_view),
GTK_TEXT_WINDOW_WIDGET,
event->x, event->y, &x, &y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (log->text_view), &iter, x, y);
for (l = tags = gtk_text_iter_get_tags (&iter); l; l = l->next) {
Accessible *accessible;
if ((accessible = g_object_get_data (l->data, "accessible")))
{
poke (accessible);
return TRUE;
}
}
g_slist_free (tags);
return FALSE;
}
static void
set_cursor_if_appropriate (GtkTextView *text_view,
gint x,
gint y)
{
GSList *tags = NULL;
GSList *tagp = NULL;
GtkTextIter iter;
gboolean hovering = FALSE;
gtk_text_view_get_iter_at_location (text_view, &iter, x, y);
tags = gtk_text_iter_get_tags (&iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next) {
GtkTextTag *tag = tagp->data;
gchar *url = (gchar*)(g_object_get_data (G_OBJECT (tag), "url"));
if (url) {
hovering = TRUE;
break;
}
}
if (hovering != hovering_over_link) {
hovering_over_link = hovering;
if (hovering_over_link)
gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), hand_cursor);
else
gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), regular_cursor);
}
if (tags)
g_slist_free (tags);
}
static VALUE
textview_get_iter_at_location(VALUE self, VALUE x, VALUE y)
{
GtkTextIter iter;
gtk_text_view_get_iter_at_location(_SELF(self), &iter, NUM2INT(x), NUM2INT(y));
return ITR2RVAL(&iter);
}
static gint popup_button_press_event(GtkWidget *widget, GdkEventButton *event)
{
RESULT *rp;
GtkTextIter iter;
guint offset;
gint buffer_x, buffer_y;
LOG(LOG_DEBUG, "IN : popup_button_press_event()");
if(event->type == GDK_BUTTON_PRESS){
if (event->button == 1){
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(widget),
GTK_TEXT_WINDOW_TEXT,
(gint)(event->x),
(gint)(event->y),
&buffer_x,
&buffer_y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(widget),
&iter,
buffer_x,
buffer_y);
offset = gtk_text_iter_get_offset(&iter);
if(follow_link(offset) == TRUE){
LOG(LOG_DEBUG, "OUT : popup_button_press_event() = TRUE");
return(TRUE);
} else {
if(bpushpin_down == FALSE){
gtk_widget_destroy(popup);
popup = NULL;
}
}
} else if ((event->button == 2) || (event->button == 3)){
if(!current_in_result)
return(TRUE);
if (event->button == 2) {
if(g_list_previous(current_in_result) == NULL){
return(TRUE);
}
current_in_result = g_list_previous(current_in_result);
} else {
if(g_list_next(current_in_result) == NULL){
return(TRUE);
}
current_in_result = g_list_next(current_in_result);
}
if(current_in_result == NULL)
return(TRUE);
rp = (RESULT *)(current_in_result->data);
if(current_in_result){
show_popup(rp);
}
}
}
LOG(LOG_DEBUG, "OUT : popup_button_press_event()");
return(TRUE);
}
/*
* 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;
}
static gboolean ygtk_text_view_button_press_event (GtkWidget *widget, GdkEventButton *event)
{ // on right-click, select word under cursor if there is no selection
if (event->button == 3) {
GtkTextView *view = GTK_TEXT_VIEW (widget);
GtkTextBuffer *buffer = gtk_text_view_get_buffer (view);
if (!gtk_text_buffer_get_has_selection (buffer)) {
gint buffer_x, buffer_y;
gtk_text_view_window_to_buffer_coords (view,
GTK_TEXT_WINDOW_WIDGET, (gint) event->x, (gint) event->y, &buffer_x, &buffer_y);
GtkTextIter iter;
gtk_text_view_get_iter_at_location (view, &iter, buffer_x, buffer_y);
if (!is_space (gtk_text_iter_get_char (&iter))) {
GtkTextIter start, end = iter, temp = iter;
do {
start = temp;
if (!gtk_text_iter_backward_char (&temp))
break;
} while (!is_space (gtk_text_iter_get_char (&temp)));
do {
if (!gtk_text_iter_forward_char (&end))
break;
} while (!is_space (gtk_text_iter_get_char (&end)));
gtk_text_buffer_select_range (buffer, &start, &end);
}
}
}
return GTK_WIDGET_CLASS (ygtk_text_view_parent_class)->button_press_event (widget, event);
}
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;
}
/* Looks at all tags covering the position (x, y) in the text view,
* and if one of them is a link, change the cursor to the "hands" cursor
* typically used by web browsers.
*/
static void
set_cursor_if_appropriate (GtkTextView *text_view, gint x, gint y)
{
GSList *tags = NULL, *tagp = NULL;
GtkTextIter iter;
gboolean hovering = FALSE;
gtk_text_view_get_iter_at_location (text_view, &iter, x, y);
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)
{
hovering = TRUE;
break;
}
}
GdkCursor *cursor;
if (hovering)
cursor = gdk_cursor_new (GDK_LEFT_PTR);
else
cursor = gdk_cursor_new (GDK_XTERM);
gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT),
cursor);
gdk_cursor_unref (cursor);
if (tags)
g_slist_free (tags);
}
/* When the user right-clicks on a word, they want to check that word.
* Here, we do NOT move the cursor to the location of the clicked-upon word
* since that prevents the use of edit functions on the context menu.
*/
static gboolean
button_press_event (GtkTextView *view,
GdkEventButton *event,
GeditAutomaticSpellChecker *spell)
{
if (event->button == GDK_BUTTON_SECONDARY)
{
gint x, y;
GtkTextIter iter;
GtkTextBuffer *buffer = gtk_text_view_get_buffer (view);
/* handle deferred check if it exists */
if (spell->deferred_check)
check_deferred_range (spell, TRUE);
gtk_text_view_window_to_buffer_coords (view,
GTK_TEXT_WINDOW_TEXT,
event->x, event->y,
&x, &y);
gtk_text_view_get_iter_at_location (view, &iter, x, y);
gtk_text_buffer_move_mark (buffer, spell->mark_click, &iter);
}
return FALSE; /* false: let gtk process this event, too.
we don't want to eat any events. */
}
gint button_press_event(GtkWidget *widget, GdkEventButton *event)
{
GtkTextIter iter;
guint offset;
gint buffer_x, buffer_y;
GdkRectangle location;
gboolean too_far=FALSE;
LOG(LOG_DEBUG, "IN : button_press_event()");
if((event->type == GDK_BUTTON_PRESS) &&
(event->button == 1)){
// If you don't convert position as buffer origin,
// position will be invalid when scrolling
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(widget),
GTK_TEXT_WINDOW_TEXT,
(gint)(event->x),
(gint)(event->y),
&buffer_x,
&buffer_y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(widget),
&iter,
buffer_x,
buffer_y);
offset = gtk_text_iter_get_offset(&iter);
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(widget),
&iter,
&location);
if((buffer_x >= location.x + font_width) || (buffer_x <= location.x - font_width))
too_far = TRUE;
else
too_far = FALSE;
if(scan_link(offset) && !too_far){
if(follow_link(offset) == TRUE)
return(TRUE);
}
} else if((event->type == GDK_BUTTON_PRESS) &&
((event->button == 2) || (event->button == 3))){
gtk_item_factory_popup(GTK_ITEM_FACTORY(text_item_factory),
event->x_root, event->y_root,
event->button, event->time);
LOG(LOG_DEBUG, "OUT : button_press_event() = TRUE");
return(TRUE);
}
//gdk_window_get_pointer(widget->window, &x, &y, &mask);
LOG(LOG_DEBUG, "OUT : button_press_event() = FALSE");
return(FALSE);
}
static void
update_mouse_cursor (GtkTextView *text_view,
gint x,
gint y)
{
static GdkCursor *hand_cursor = NULL;
static GdkCursor *regular_cursor = NULL;
gboolean hovering = FALSE, hovering_over_link = FALSE, hovering_real;
guint32 state;
GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
GtkTextTagTable *tag_table;
GtkTextTag *tag;
GtkTextIter iter;
if (!hand_cursor) {
hand_cursor = gdk_cursor_new (GDK_HAND2);
regular_cursor = gdk_cursor_new (GDK_XTERM);
}
g_return_if_fail (buffer != 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_if_fail (tag != NULL);
state = get_state (buffer);
gtk_text_view_get_iter_at_location (text_view, &iter, x, y);
hovering_real = gtk_text_iter_has_tag (&iter, tag);
hovering_over_link = (state & E_BUFFER_TAGGER_STATE_IS_HOVERING) != 0;
if ((state & E_BUFFER_TAGGER_STATE_CTRL_DOWN) == 0) {
hovering = FALSE;
} else {
hovering = hovering_real;
}
if (hovering != hovering_over_link) {
update_state (buffer, E_BUFFER_TAGGER_STATE_IS_HOVERING, hovering);
if (hovering && gtk_widget_has_focus (GTK_WIDGET (text_view)))
gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), hand_cursor);
else
gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), regular_cursor);
/* XXX Is this necessary? Appears to be a no-op. */
get_pointer_position (text_view, NULL, NULL);
}
hovering_over_link = (state & E_BUFFER_TAGGER_STATE_IS_HOVERING_TOOLTIP) != 0;
if (hovering_real != hovering_over_link) {
update_state (buffer, E_BUFFER_TAGGER_STATE_IS_HOVERING_TOOLTIP, hovering_real);
gtk_widget_trigger_tooltip_query (GTK_WIDGET (text_view));
}
}
static void
ide_source_view_movements_screen_bottom (Movement *mv)
{
GtkTextView *text_view = (GtkTextView *)mv->self;
GdkRectangle rect;
ide_source_view_get_visible_rect (mv->self, &rect);
gtk_text_view_get_iter_at_location (text_view, &mv->insert, rect.x, rect.y + rect.height - 1);
gtk_text_iter_set_line_offset (&mv->insert, 0);
}
CAMLprim value ml_gtk_text_view_get_iter_at_location (value tv,
value x,
value y)
{
CAMLparam3(tv,x,y);
GtkTextIter res;
gtk_text_view_get_iter_at_location(GtkTextView_val(tv),&res,
Int_val(x),Int_val(y));
CAMLreturn(Val_GtkTextIter(&res));
}
static void
set_cursor_if_appropriate(MarkdownTextView * self, gint x, gint y)
{
GSList *tags = NULL, *tagp = NULL;
GtkTextIter iter;
gboolean hovering = FALSE;
gchar *link_uri = NULL;
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(self), &iter, x,
y);
tags = gtk_text_iter_get_tags(&iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next) {
GtkTextTag *tag = tagp->data;
gint is_underline = 0;
gchar *lang = NULL;
g_object_get(G_OBJECT(tag),
"underline", &is_underline,
"language", &lang,
NULL);
if (is_underline == 1 && lang) {
link_uri = egg_markdown_get_link_uri(self->markdown, atoi(lang));
g_free(lang);
hovering = TRUE;
break;
}
g_free(lang);
}
if (hovering != self->hovering_over_link) {
self->hovering_over_link = hovering;
if (self->hovering_over_link) {
g_signal_emit(self, markdown_textview_signals[HOVERING_OVER_LINK],
0, link_uri);
gdk_window_set_cursor(gtk_text_view_get_window
(GTK_TEXT_VIEW(self),
GTK_TEXT_WINDOW_TEXT), hand_cursor);
} else {
g_signal_emit(self, markdown_textview_signals[HOVERING_OVER_TEXT], 0);
gdk_window_set_cursor(gtk_text_view_get_window
(GTK_TEXT_VIEW(self),
GTK_TEXT_WINDOW_TEXT), NULL);
}
}
if (link_uri)
g_free(link_uri);
if (tags)
g_slist_free(tags);
}
static gboolean
chat_text_view_event_cb (EmpathyChatTextView *view,
GdkEventMotion *event,
GtkTextTag *tag)
{
static GdkCursor *hand = NULL;
static GdkCursor *beam = NULL;
GtkTextWindowType type;
GtkTextIter iter;
GdkWindow *win;
gint x, y, buf_x, buf_y;
type = gtk_text_view_get_window_type (GTK_TEXT_VIEW (view),
event->window);
if (type != GTK_TEXT_WINDOW_TEXT) {
return FALSE;
}
/* Get where the pointer really is. */
win = gtk_text_view_get_window (GTK_TEXT_VIEW (view), type);
if (!win) {
return FALSE;
}
gdk_window_get_pointer (win, &x, &y, NULL);
/* Get the iter where the cursor is at */
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (view), type,
x, y,
&buf_x, &buf_y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (view),
&iter,
buf_x, buf_y);
if (gtk_text_iter_has_tag (&iter, tag)) {
if (!hand) {
hand = gdk_cursor_new (GDK_HAND2);
beam = gdk_cursor_new (GDK_XTERM);
}
gdk_window_set_cursor (win, hand);
} else {
if (!beam) {
beam = gdk_cursor_new (GDK_XTERM);
}
gdk_window_set_cursor (win, beam);
}
return FALSE;
}
/**************************************************************************
Set the "hand" cursor when moving over a link.
**************************************************************************/
static void set_cursor_if_appropriate(GtkTextView *text_view, gint x, gint y)
{
static gboolean hovering_over_link = FALSE;
static GdkCursor *hand_cursor = NULL;
static GdkCursor *regular_cursor = NULL;
GSList *tags, *tagp;
GtkTextIter iter;
gboolean hovering = FALSE;
/* Initialize the cursors. */
if (!hand_cursor) {
hand_cursor = gdk_cursor_new_for_display(
gdk_screen_get_display(gdk_screen_get_default()), GDK_HAND2);
}
if (!regular_cursor) {
regular_cursor = gdk_cursor_new_for_display(
gdk_screen_get_display(gdk_screen_get_default()), GDK_XTERM);
}
gtk_text_view_get_iter_at_location(text_view, &iter, x, y);
tags = gtk_text_iter_get_tags(&iter);
for (tagp = tags; tagp; tagp = tagp->next) {
enum text_link_type type =
GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tagp->data), "type"));
if (type != 0) {
hovering = TRUE;
break;
}
}
if (hovering != hovering_over_link) {
hovering_over_link = hovering;
if (hovering_over_link) {
gdk_window_set_cursor(gtk_text_view_get_window(text_view,
GTK_TEXT_WINDOW_TEXT),
hand_cursor);
} else {
gdk_window_set_cursor(gtk_text_view_get_window(text_view,
GTK_TEXT_WINDOW_TEXT),
regular_cursor);
}
}
if (tags) {
g_slist_free(tags);
}
}
/* 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;
}
/* 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;
}
static void
update_scrubber_position (GtkSourceMap *map)
{
GtkSourceMapPrivate *priv;
GtkTextIter iter;
GdkRectangle visible_area;
GdkRectangle iter_area;
GdkRectangle scrubber_area;
GtkAllocation alloc;
GtkAllocation view_alloc;
gint child_height;
gint view_height;
gint y;
priv = gtk_source_map_get_instance_private (map);
if (priv->view == NULL)
{
return;
}
gtk_widget_get_allocation (GTK_WIDGET (priv->view), &view_alloc);
gtk_widget_get_allocation (GTK_WIDGET (map), &alloc);
gtk_widget_get_preferred_height (GTK_WIDGET (priv->view), NULL, &view_height);
gtk_widget_get_preferred_height (GTK_WIDGET (priv->child_view), NULL, &child_height);
gtk_text_view_get_visible_rect (GTK_TEXT_VIEW (priv->view), &visible_area);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (priv->view), &iter,
visible_area.x, visible_area.y);
gtk_text_view_get_iter_location (GTK_TEXT_VIEW (priv->child_view), &iter, &iter_area);
gtk_text_view_buffer_to_window_coords (GTK_TEXT_VIEW (priv->child_view),
GTK_TEXT_WINDOW_WIDGET,
iter_area.x, iter_area.y,
NULL, &y);
scrubber_area.x = 0;
scrubber_area.width = alloc.width;
scrubber_area.y = y;
scrubber_area.height = (gdouble)view_alloc.height / (gdouble)view_height * (gdouble)child_height;
if (memcmp (&scrubber_area, &priv->scrubber_area, sizeof scrubber_area) != 0)
{
priv->scrubber_area = scrubber_area;
gtk_widget_queue_draw (GTK_WIDGET (map));
}
}
static gboolean
textview_query_tooltip (GtkTextView *text_view,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
{
GtkTextBuffer *buffer;
guint32 state;
gboolean res = FALSE;
if (keyboard_mode)
return FALSE;
buffer = gtk_text_view_get_buffer (text_view);
g_return_val_if_fail (buffer != NULL, FALSE);
state = get_state (buffer);
if ((state & E_BUFFER_TAGGER_STATE_IS_HOVERING_TOOLTIP) != 0) {
gchar *url;
GtkTextIter iter;
gtk_text_view_window_to_buffer_coords (
text_view,
GTK_TEXT_WINDOW_WIDGET,
x, y, &x, &y);
gtk_text_view_get_iter_at_location (text_view, &iter, x, y);
url = get_url_at_iter (buffer, &iter);
res = url && *url;
if (res) {
gchar *str;
/* To Translators: The text is concatenated to a form: "Ctrl-click to open a link http://www.example.com" */
str = g_strconcat (_("Ctrl-click to open a link"), " ", url, NULL);
gtk_tooltip_set_text (tooltip, str);
g_free (str);
}
g_free (url);
}
return res;
}
static void
SetText(
GtkWidget *widget,
WidgetData *wdata,
_Text *data)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
ENTER_FUNC;
SetCommon(widget,wdata);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_set_text(buffer, data->text, strlen(data->text));
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(widget), &iter, 0, 0);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(widget), &iter,
0.0, TRUE, 0.0, 0.0);
LEAVE_FUNC;
}
gboolean
utl_gui_url_event_after (GtkWidget *textview, GdkEvent *ev, GSList **links_list)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
GdkEventButton *event;
gint x, y;
GSList *tags = NULL, *tagp = NULL;
GtkTextTag *tag;
gchar *link;
gint slink;
gchar tmpbuf[BUFFER_SIZE];
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 (textview));
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 (textview), GTK_TEXT_WINDOW_WIDGET,
event->x, event->y, &x, &y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (textview), &iter, x, y);
tags = gtk_text_iter_get_tags (&iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next) {
tag = tagp->data;
slink = (gint) g_object_get_data (G_OBJECT (tag), "link");
if (slink != 0) {
link = g_slist_nth_data (*links_list, slink-1);
g_snprintf (tmpbuf, BUFFER_SIZE, "\"%s\"", link);
utl_run_helper (tmpbuf, utl_get_link_type (link));
break;
}
}
if (tags) g_slist_free (tags);
return FALSE;
}
/* when the user right-clicks on a word, they want to check that word.
* here, we move the cursor to the location of the clicked-upon word.
* is this necessary? we could maybe just check the word from its
* existing location... */
static gboolean
button_press_event(GtkTextView *view, GdkEventButton *event, gpointer data) {
if (event->button == 3) {
gint x, y;
GtkTextIter iter;
gtk_text_view_window_to_buffer_coords(view,
GTK_TEXT_WINDOW_TEXT,
(int)event->x, (int)event->y,
&x, &y);
gtk_text_view_get_iter_at_location(view, &iter, x, y);
gtk_text_buffer_place_cursor(gtk_text_view_get_buffer(view),
&iter);
}
return FALSE; /* false: let gtk process this event, too.
we don't want to eat any events. */
}
static gboolean
motion_cb (GtkWidget *w, GdkEventMotion *ev, gpointer d)
{
gint x, y;
GSList *tags = NULL, *tagp = NULL;
GtkTextIter iter;
gboolean hovering = FALSE;
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (w), GTK_TEXT_WINDOW_WIDGET,
ev->x, ev->y, &x, &y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (w), &iter, x, y);
tags = gtk_text_iter_get_tags (&iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next)
{
GtkTextTag *tag = tagp->data;
gint link = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "is_link"));
if (link)
{
hovering = TRUE;
break;
}
}
if (hovering != hovering_over_link)
{
hovering_over_link = hovering;
if (hovering_over_link)
gdk_window_set_cursor (gtk_text_view_get_window (GTK_TEXT_VIEW (w), GTK_TEXT_WINDOW_TEXT), hand);
else
gdk_window_set_cursor (gtk_text_view_get_window (GTK_TEXT_VIEW (w), GTK_TEXT_WINDOW_TEXT), normal);
}
if (tags)
g_slist_free (tags);
gdk_window_get_pointer (gtk_widget_get_window (w), NULL, NULL, NULL);
return FALSE;
}
static void
set_cursor_if_appropriate (GucharmapCharmap *charmap,
gint x,
gint y)
{
GucharmapCharmapPrivate *priv = charmap->priv;
GSList *tags = NULL, *tagp = NULL;
GtkTextIter iter;
gboolean hovering_over_link = FALSE;
gtk_text_view_get_iter_at_location (priv->details_view,
&iter, x, y);
tags = gtk_text_iter_get_tags (&iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next)
{
GtkTextTag *tag = tagp->data;
gunichar uc;
/* subtract 1 because U+0000 is a character; see above where we set
* "link-character" */
uc = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (tag), "link-character")) - 1;
if (uc != (gunichar)(-1))
{
hovering_over_link = TRUE;
break;
}
}
if (hovering_over_link != priv->hovering_over_link)
{
priv->hovering_over_link = hovering_over_link;
if (hovering_over_link)
gdk_window_set_cursor (gtk_text_view_get_window (priv->details_view, GTK_TEXT_WINDOW_TEXT), priv->hand_cursor);
else
gdk_window_set_cursor (gtk_text_view_get_window (priv->details_view, GTK_TEXT_WINDOW_TEXT), priv->regular_cursor);
}
if (tags)
g_slist_free (tags);
}
static gboolean cb_button_press_event(GtkWidget *view, GdkEventButton *event)
{
GtkTextIter iter, start, end;
gint x, y;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
if ((event->button) == 3 && (event->type == GDK_BUTTON_PRESS)) {
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(view),
gtk_text_view_get_window_type(GTK_TEXT_VIEW(view), event->window),
(gint)event->x, (gint)event->y, &x, &y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(view), &iter, x, y);
gtk_text_buffer_get_selection_bounds(buffer, &start, &end);
if (!gtk_text_iter_in_range(&iter, &start, &end))
gtk_text_buffer_place_cursor(buffer, &iter);
}
return FALSE;
}
/* Looks at all tags covering the position (x, y) in the text view,
* and if one of them is a link, change the cursor to the "hands" cursor
* typically used by web browsers.
*/
static void
set_cursor_if_appropriate (GtkTextView * text_view, gint x, gint y,
GtrContextPanel *panel)
{
GSList *tags = NULL, *tagp = NULL;
GtkTextIter iter;
GtrContextPanelPrivate *priv;
gboolean hovering = FALSE;
priv = gtr_context_panel_get_instance_private(panel);
gtk_text_view_get_iter_at_location (text_view, &iter, x, y);
tags = gtk_text_iter_get_tags (&iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next)
{
GtkTextTag *tag = tagp->data;
gint *is_path = g_object_get_data (G_OBJECT (tag), "is_path");
if (is_path)
{
hovering = TRUE;
break;
}
}
if (hovering != priv->hovering_over_link)
{
priv->hovering_over_link = hovering;
if (priv->hovering_over_link)
gdk_window_set_cursor (gtk_text_view_get_window (text_view,
GTK_TEXT_WINDOW_TEXT),
priv->hand_cursor);
else
gdk_window_set_cursor (gtk_text_view_get_window (text_view,
GTK_TEXT_WINDOW_TEXT),
priv->regular_cursor);
}
if (tags)
g_slist_free (tags);
}
static gboolean _text_view_click_handler(GtkWidget *widget, GdkEvent *event)
{
GtkTextView *text_view = GTK_TEXT_VIEW(widget);
if (event->type == GDK_BUTTON_RELEASE)
{
GdkEventButton *button_event = GDK_EVENT_BUTTON(event);
if (button_event->button == 1)
{
GtkTextBuffer *text_buffer = gtk_text_view_get_buffer(text_view);
gint x;
gint y;
GtkTextIter text_iter;
gtk_text_view_window_to_buffer_coords(text_view, GTK_TEXT_WINDOW_WIDGET, button_event->x, button_event->y, &x, &y);
gtk_text_view_get_iter_at_location(text_view, &text_iter, x, y);
{
GSList *text_tag_list = gtk_text_iter_get_tags(&text_iter);
GSList *text_tag_list_item;
for (text_tag_list_item = text_tag_list; text_tag_list_item != NULL; text_tag_list_item = text_tag_list_item->next)
{
GtkTextTag *text_tag = GTK_TEXT_TAG(text_tag_list_item->data);
if (g_object_get_data(G_OBJECT(text_tag), "column_type") != NULL)
{
gtk_text_buffer_place_cursor(text_buffer);
break;
}
}
if (text_tag_list != NULL) g_slist_free(text_tag_list);
}
return TRUE;
}
}
return FALSE;
}
