static void
carrick_list_drag_begin (GtkWidget *widget,
GdkDragContext *context,
CarrickList *list)
{
CarrickListPrivate *priv = list->priv;
gint x, y;
carrick_service_item_set_active (CARRICK_SERVICE_ITEM (widget), FALSE);
/* save old place in list for drag-failures */
gtk_container_child_get (GTK_CONTAINER (priv->box),
widget,
"position", &priv->drag_position,
NULL);
priv->drop_position = priv->drag_position;
/* remove widget from list and setup dnd popup window */
priv->drag_window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_size_request (priv->drag_window,
widget->allocation.width,
widget->allocation.height);
gtk_widget_get_pointer (widget, &x, &y);
gtk_widget_reparent (widget, priv->drag_window);
gtk_drag_set_icon_widget (context,
priv->drag_window,
x, y);
}
static gboolean
lyric_show_viewport_button_press(GtkWidget *widget,GdkEventButton *event)
{
LyricShowViewport *lsv;
lsv = LYRIC_SHOW_VIEWPORT(widget);
gint x = 0;
gint y = 0;
if(!gtk_widget_get_visible(lsv->priv->lyricbox))
{
goto ext;
}
if(event->button != 1)
goto ext;
#if GTK_CHECK_VERSION(3,2,0)
gtk_widget_get_mouse_position(widget,(GdkEvent*) event,&x,&y);
#else
gtk_widget_get_pointer(widget,&x,&y);
#endif
lsv->priv->is_pressed = TRUE;
lsv->priv->pressed_y = y;
ext:
lyric_show_viewport_update_cursor(lsv);
gtk_widget_queue_resize(widget);
/// GTK_WIDGET_CLASS(lyric_show_viewport_parent_class)->button_press_event(widget,event);
return FALSE;
}
static gboolean on_mouse_leave (GtkWidget *event_box, GdkEventButton *event, gpointer data)
{
int orientation;
pqi const inst = (pqi)data;
gtk_widget_queue_draw(event_box);
inst->glowing = FALSE; /* No more glow */
/* Show the menu if it was gestured in the correct direction */
if (inst->clicked) {
GtkAllocation alloc;
int x = event->x, y = event->y;
gtk_widget_get_allocation(inst->box, &alloc); /* Get the dimensions of our widget */
gtk_widget_get_pointer(inst->box, &x, &y); /* Get the location of our mouse */
/* Check if the mouse is dragging away from the panel */
orientation = mate_panel_applet_get_orient(inst->applet);
if ((orientation == MATE_PANEL_APPLET_ORIENT_UP && x > -alloc.width /2 && x < 3*alloc.width /2 && y <= 0)
|| (orientation == MATE_PANEL_APPLET_ORIENT_RIGHT && y > -alloc.height/2 && y < 3*alloc.height/2 && x >= alloc.width)
|| (orientation == MATE_PANEL_APPLET_ORIENT_DOWN && x > -alloc.width /2 && x < 3*alloc.width /2 && y >= alloc.height)
|| (orientation == MATE_PANEL_APPLET_ORIENT_LEFT && y > -alloc.height/2 && y < 3*alloc.height/2 && x <= 0))
{
/* Dragging out menu */
show_menu(inst);
}
else return TRUE;
}
return TRUE;
}
void widget_set_sensitive(GtkWidget * widget, gboolean sensitive)
{
GtkWidget *button;
gtk_widget_set_sensitive(widget, sensitive);
/** @bug Gtk bug 56070. If the mouse is over a toolbar button that
* becomes sensitive, one can't click it without moving the mouse out
* and in again. This bug is registered in Bugzilla as a Gtk bug. The
* workaround tests if the mouse is inside the currently sensitivized
* button, and if yes call button_enter()
*/
if (!GTK_IS_BIN(widget))
return;
button = gtk_bin_get_child(GTK_BIN(widget));
if (sensitive && GTK_IS_BUTTON(button)) {
gint x, y, state;
gtk_widget_get_pointer(button, &x, &y);
state = GTK_WIDGET_STATE(button);
if ((state == GTK_STATE_NORMAL
|| state == GTK_STATE_PRELIGHT) && x >= 0 && y >= 0
&& x < button->allocation.width
&& y < button->allocation.height) {
gtk_button_enter(GTK_BUTTON(button));
GTK_BUTTON(button)->in_button = TRUE;
gtk_widget_set_state(widget, GTK_STATE_PRELIGHT);
}
}
}
static VALUE
rg_pointer(VALUE self)
{
int x, y;
gtk_widget_get_pointer(_SELF(self), &x, &y);
return rb_assoc_new(INT2FIX(x), INT2FIX(y));
}
repv
sys_get_mouse_pos(Lisp_Window *w)
{
int x, y;
/* XXX track mouse pointer position in gtk_jade.c.. */
gtk_widget_get_pointer (GTK_WIDGET (w->w_Window), &x, &y);
return make_pos((x - w->pixel_left) / w->font_width,
(y - w->pixel_top) / w->font_height);
}
Error GTKWindow::GetMousePos(Pos &oPos)
{
if (initialized) {
gdk_threads_enter();
gtk_widget_get_pointer(mainWindow, &oPos.x, &oPos.y);
gdk_threads_leave();
}
return kError_NoErr;
}
CAMLprim value ml_gtk_widget_get_pointer (value w)
{
int x,y;
value ret;
gtk_widget_get_pointer (GtkWidget_val(w), &x, &y);
ret = alloc_small (2,0);
Field(ret,0) = Val_int(x);
Field(ret,1) = Val_int(y);
return ret;
}
static gboolean
gossip_cell_renderer_expander_activate (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path_string,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GossipCellRendererExpanderPriv *priv;
GtkTreePath *path;
gboolean in_cell;
int mouse_x;
int mouse_y;
priv = GET_PRIV (cell);
if (!GTK_IS_TREE_VIEW (widget) || !priv->activatable)
return FALSE;
path = gtk_tree_path_new_from_string (path_string);
gtk_widget_get_pointer (widget, &mouse_x, &mouse_y);
gtk_tree_view_convert_widget_to_bin_window_coords (GTK_TREE_VIEW (widget),
mouse_x, mouse_y,
&mouse_x, &mouse_y);
/* check if click is within the cell */
if (mouse_x - cell_area->x >= 0
&& mouse_x - cell_area->x <= cell_area->width) {
in_cell = TRUE;
} else {
in_cell = FALSE;
}
if (! in_cell) {
gtk_tree_path_free (path);
return FALSE;
}
if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), path)) {
gtk_tree_view_collapse_row (GTK_TREE_VIEW (widget), path);
priv->style_flags &= ~(GTK_STATE_FLAG_ACTIVE);
} else {
gtk_tree_view_expand_row (GTK_TREE_VIEW (widget), path, FALSE);
priv->style_flags |= ~(GTK_STATE_FLAG_ACTIVE);
}
gtk_tree_path_free (path);
return TRUE;
}
static gint
area_event (GtkWidget *widget, GdkEvent *event, void *d)
{
switch (event->type){
case GDK_EXPOSE: {
GdkEventExpose *e = (GdkEventExpose *) event;
paint (&e->area);
return TRUE;
}
case GDK_BUTTON_PRESS: {
int x, y;
gtk_widget_get_pointer (widget, &x, &y);
kill_balls (x / STONE_SIZE, y / STONE_SIZE);
old_x = -1;
old_y = -1;
}
case GDK_ENTER_NOTIFY:
case GDK_MOTION_NOTIFY: {
int x, y;
gtk_widget_get_pointer (widget, &x, &y);
mark_balls (x / STONE_SIZE, y / STONE_SIZE);
return TRUE;
}
case GDK_LEAVE_NOTIFY:
old_x = -1;
old_y = -1;
disable_timeout ();
untag_all ();
return TRUE;
default:
return FALSE;
}
}
static gint key_press_map_cb(GtkWidget * area, GdkEventKey * event,
gpointer user_data)
{
static gint last_x, last_y;
static gchar *last_key;
GuiMap *gmap = user_data;
gint x, y;
gboolean plus10;
if (area->window == NULL || gmap->map == NULL)
return FALSE;
gtk_widget_get_pointer(area, &x, &y);
current_hex = guimap_find_hex(gmap, x, y);
if (current_hex == NULL || !terrain_has_chit(current_hex->terrain))
return TRUE;
if (last_x == x && last_y == y && strcmp(last_key, "1") == 0)
plus10 = TRUE;
else
plus10 = FALSE;
if (!plus10 && strcmp(event->string, "2") == 0)
current_hex->roll = 2;
else if (strcmp(event->string, "3") == 0)
current_hex->roll = 3;
else if (strcmp(event->string, "4") == 0)
current_hex->roll = 4;
else if (strcmp(event->string, "5") == 0)
current_hex->roll = 5;
else if (strcmp(event->string, "6") == 0)
current_hex->roll = 6;
else if (strcmp(event->string, "8") == 0)
current_hex->roll = 8;
else if (strcmp(event->string, "9") == 0)
current_hex->roll = 9;
else if (plus10 && strcmp(event->string, "0") == 0)
current_hex->roll = 10;
else if (plus10 && strcmp(event->string, "1") == 0)
current_hex->roll = 11;
else if (plus10 && strcmp(event->string, "2") == 0)
current_hex->roll = 12;
guimap_draw_hex(gmap, current_hex);
last_x = x;
last_y = y;
g_free(last_key);
last_key = g_strdup(event->string);
return TRUE;
}
static void
record_stroke_segment (GtkWidget *widget)
{
gint x, y;
struct gstroke_metrics *metrics;
g_return_if_fail( widget != NULL );
gtk_widget_get_pointer (widget, &x, &y);
if (last_mouse_position.invalid)
last_mouse_position.invalid = FALSE;
else if (gstroke_draw_strokes())
{
#if 1
XDrawLine (gstroke_disp, gstroke_window, gstroke_gc,
last_mouse_position.last_point.x,
last_mouse_position.last_point.y,
x, y);
/* XFlush (gstroke_disp); */
#else
/* FIXME: this does not work. It will only work if we create a
corresponding GDK window for stroke_window and draw on
that... */
gdk_draw_line (widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
last_mouse_position.last_point.x,
last_mouse_position.last_point.y,
x,
y);
#endif
}
if (last_mouse_position.last_point.x != x
|| last_mouse_position.last_point.y != y)
{
last_mouse_position.last_point.x = x;
last_mouse_position.last_point.y = y;
metrics = (struct gstroke_metrics *)g_object_get_data(G_OBJECT(widget),
GSTROKE_METRICS);
_gstroke_record (x, y, metrics);
}
}
/*! \brief Emits a faked motion event to update objects being drawn or placed
* \par Function Description
* This function emits an additional "motion-notify-event" to
* update objects being drawn or placed while zooming, scrolling, or
* panning.
*
* If its event parameter is not NULL, the current state of Shift
* and Control is preserved to correctly deal with special cases.
*
* \param [in] view The GschemPageView object which received the signal.
* \param [in] event The event structure of the signal or NULL.
* \returns FALSE to propagate the event further.
*/
gboolean
x_event_faked_motion (GschemPageView *view, GdkEventKey *event) {
gint x, y;
gboolean ret;
GdkEventMotion *newevent;
gtk_widget_get_pointer (GTK_WIDGET (view), &x, &y);
newevent = (GdkEventMotion*)gdk_event_new(GDK_MOTION_NOTIFY);
newevent->x = x;
newevent->y = y;
if (event != NULL ) {
switch (event->keyval) {
case GDK_Control_L:
case GDK_Control_R:
if (event->type == GDK_KEY_PRESS) {
newevent->state |= GDK_CONTROL_MASK;
} else {
newevent->state &= ~GDK_CONTROL_MASK;
}
break;
case GDK_Shift_L:
case GDK_Shift_R:
if (event->type == GDK_KEY_PRESS) {
newevent->state |= GDK_SHIFT_MASK;
} else {
newevent->state &= ~GDK_SHIFT_MASK;
}
break;
}
}
g_signal_emit_by_name (view, "motion-notify-event", newevent, &ret);
gdk_event_free((GdkEvent*)newevent);
return FALSE;
}
static gboolean
lyric_show_viewport_button_release(GtkWidget *widget,GdkEventButton *event)
{
LyricShowViewport *lsv;
lsv = LYRIC_SHOW_VIEWPORT(widget);
gint64 t=0;
gint x = 0;
gint y = 0;
gboolean is_pressed = lsv->priv->is_pressed;
#if GTK_CHECK_VERSION(3,2,0)
gtk_widget_get_mouse_position(widget,(GdkEvent*)event,&x,&y);
#else
gtk_widget_get_pointer(widget,&x,&y);
#endif
lsv->priv->is_pressed = FALSE;
if(is_pressed && lsv->priv->time_requestable)
{
t = lyric_show_viewport_get_requested_time(lsv);
/// lsv->priv->pos += lsv->priv->pressed_pos ;
lsv->priv->pressed_pos = 0;
lyric_show_viewport_update_cursor(lsv);
lyric_show_time_request(LYRIC_SHOW(lsv),t);
}else
lyric_show_viewport_update_current_widget(lsv);
if(event->button == 3)
{
GtkWidget *menu = lyric_show_menu_get_for(LYRIC_SHOW(widget));
gtk_menu_popup(GTK_MENU(menu),NULL,NULL,NULL,NULL,event->button,event->time);
}
gtk_widget_queue_resize(widget);
/// GTK_WIDGET_CLASS(lyric_show_viewport_parent_class)->button_release_event(widget,event);
return FALSE;
}
static gint
timer_cb (EyesApplet *eyes_applet)
{
gint x, y;
gint pupil_x, pupil_y;
gint i;
for (i = 0; i < eyes_applet->num_eyes; i++) {
if (gtk_widget_get_realized (eyes_applet->eyes[i])) {
gtk_widget_get_pointer (eyes_applet->eyes[i],
&x, &y);
if ((x != eyes_applet->pointer_last_x[i]) || (y != eyes_applet->pointer_last_y[i])) {
calculate_pupil_xy (eyes_applet, x, y, &pupil_x, &pupil_y, eyes_applet->eyes[i]);
draw_eye (eyes_applet, i, pupil_x, pupil_y);
eyes_applet->pointer_last_x[i] = x;
eyes_applet->pointer_last_y[i] = y;
}
}
}
return TRUE;
}
/*! \brief get the pointer position of a given GschemToplevel
* \par Function Description
* This function gets the pointer position of the drawing area of the
* current workspace <b>GschemToplevel</b>. The flag <b>snapped</b> specifies
* whether the pointer position should be snapped to the current grid.
*
* \param [in] w_current The GschemToplevel object.
* \param [in] snapped An option flag to specify the wished coords
* \param [out] wx snapped/unsnapped world x coordinate
* \param [out] wy snapped/unsnapped world y coordinate
*
* \return Returns TRUE if the pointer position is inside the drawing area.
*
*/
gboolean
x_event_get_pointer_position (GschemToplevel *w_current, gboolean snapped, gint *wx, gint *wy)
{
int width;
int height;
int sx;
int sy;
int x;
int y;
GschemPageView *page_view = gschem_toplevel_get_current_page_view (w_current);
g_return_val_if_fail (page_view != NULL, FALSE);
g_return_val_if_fail (GTK_WIDGET (page_view)->window != NULL, FALSE);
/* \todo The following line is depricated in GDK 2.24 */
gdk_drawable_get_size (GTK_WIDGET (page_view)->window, &width, &height);
gtk_widget_get_pointer(GTK_WIDGET (page_view), &sx, &sy);
/* check if we are inside the drawing area */
if ((sx < 0) || (sx >= width) || (sy < 0) || (sy >= height)) {
return FALSE;
}
gschem_page_view_SCREENtoWORLD (page_view, sx, sy, &x, &y);
if (snapped) {
x = snap_grid (w_current, x);
y = snap_grid (w_current, y);
}
*wx = x;
*wy = y;
return TRUE;
}
static gboolean
lyric_show_viewport_motion_notify(GtkWidget *widget,GdkEventMotion *event)
{
LyricShowViewport *lsv;
lsv = LYRIC_SHOW_VIEWPORT(widget);
gint x = 0;
gint y = 0;
gint tmp_pos = 0;
GtkAllocation alc = {0};
if(lsv->priv->time_requestable)
{
#if GTK_CHECK_VERSION(3,2,0)
gtk_widget_get_mouse_position(widget,(GdkEvent*)event,&x,&y);
#else
gtk_widget_get_pointer(widget,&x,&y);
#endif
tmp_pos = lsv->priv->pressed_y - y;
gtk_widget_get_allocation(lsv->priv->lyricbox,&alc);
if(tmp_pos + lsv->priv->pos > 0)
{
if(tmp_pos + lsv->priv->pos >= alc.height)
tmp_pos = alc.height-lsv->priv->pos-1;
}else{
tmp_pos = -lsv->priv->pos;
}
lsv->priv->pressed_pos = tmp_pos;
gtk_widget_queue_resize(widget);
}
if(GTK_WIDGET_CLASS(lyric_show_viewport_parent_class)->motion_notify_event)
{
GTK_WIDGET_CLASS(lyric_show_viewport_parent_class)->motion_notify_event(widget,event);
}
return FALSE;
}
gboolean onMouseMove(GtkWidget * widget, GdkEventMotion * event, gpointer user_data) {
udata *dat=(udata *)user_data;
gint x, y, x0=0, y0=0;
UNUSED(widget);
UNUSED(event);
x0 = (dat->imgWG->allocation.width - dat->nx*dat->zoom)/2;
if (x0 < 0) x0 = 0;
y0 = (dat->imgWG->allocation.height - dat->ny*dat->zoom)/2;
if (y0 < 0) y0 = 0;
gtk_widget_get_pointer(dat->imgWG, &x, &y);
dat->x = (x-x0) / dat->zoom + 1;
dat->y = (y-y0) / dat->zoom + 1;
if (dat->x<1) dat->x = 1;
if (dat->y<1) dat->y = 1;
if (dat->x>dat->nx) dat->x = dat->nx;
if (dat->y>dat->ny) dat->y = dat->ny;
updateStatusBar(user_data);
gdk_flush();
return TRUE;
}
/* GTk utility function */
void gtk_button_set_sensitive(GtkWidget *button, gboolean sensitive)
{
gtk_widget_set_sensitive(button, sensitive);
/* Simulate a mouse crossing event, to enable button */
if ( sensitive ) {
int x, y;
gboolean retval;
GdkEventCrossing crossing;
gtk_widget_get_pointer(button, &x, &y);
if ( (x >= 0) && (y >= 0) &&
(x <= button->allocation.width) &&
(y <= button->allocation.height) ) {
memset(&crossing, 0, sizeof(crossing));
crossing.type = GDK_ENTER_NOTIFY;
crossing.window = button->window;
crossing.detail = GDK_NOTIFY_VIRTUAL;
gtk_signal_emit_by_name(GTK_OBJECT(button),
"enter_notify_event",
&crossing, &retval);
}
}
}
static void
chat_text_view_populate_popup (EmpathyChatTextView *view,
GtkMenu *menu,
gpointer user_data)
{
EmpathyChatTextViewPriv *priv;
GtkTextTagTable *table;
GtkTextTag *tag;
gint x, y;
GtkTextIter iter, start, end;
GtkWidget *item;
gchar *str = NULL;
priv = GET_PRIV (view);
/* Clear menu item */
if (gtk_text_buffer_get_char_count (priv->buffer) > 0) {
item = gtk_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_CLEAR, NULL);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
g_signal_connect (item,
"activate",
G_CALLBACK (chat_text_view_clear_view_cb),
view);
}
/* Link context menu items */
table = gtk_text_buffer_get_tag_table (priv->buffer);
tag = gtk_text_tag_table_lookup (table, EMPATHY_CHAT_TEXT_VIEW_TAG_LINK);
gtk_widget_get_pointer (GTK_WIDGET (view), &x, &y);
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (view),
GTK_TEXT_WINDOW_WIDGET,
x, y,
&x, &y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (view), &iter, x, y);
start = end = iter;
if (gtk_text_iter_backward_to_tag_toggle (&start, tag) &&
gtk_text_iter_forward_to_tag_toggle (&end, tag)) {
str = gtk_text_buffer_get_text (priv->buffer,
&start, &end, FALSE);
}
if (EMP_STR_EMPTY (str)) {
g_free (str);
return;
}
/* NOTE: Set data just to get the string freed when not needed. */
g_object_set_data_full (G_OBJECT (menu),
"url", str,
(GDestroyNotify) g_free);
item = gtk_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
item = gtk_menu_item_new_with_mnemonic (_("_Copy Link Address"));
g_signal_connect (item,
"activate",
G_CALLBACK (chat_text_view_copy_address_cb),
str);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
item = gtk_menu_item_new_with_mnemonic (_("_Open Link"));
g_signal_connect (item,
"activate",
G_CALLBACK (chat_text_view_open_address_cb),
str);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
}
static void
ViewAutoDrawerUpdate(ViewAutoDrawer *that, // IN
gboolean immediate) // IN
{
ViewAutoDrawerPrivate *priv = that->priv;
GtkWidget *toplevel = gtk_widget_get_toplevel(GTK_WIDGET(that));
GtkWindow *window;
GtkAllocation allocation;
if (!toplevel || !gtk_widget_is_toplevel(toplevel)) {
// The autoDrawer cannot function properly without a toplevel.
return;
}
window = GTK_WINDOW(toplevel);
/*
* We decide to open the drawer by OR'ing several conditions. Evaluating a
* condition can have the side-effect of setting 'immediate' to TRUE, so we
* cannot stop evaluating the conditions after we have found one to be TRUE.
*/
priv->opened = FALSE;
/* Is the AutoDrawer pinned? */
if (priv->pinned) {
immediate = TRUE;
priv->opened = TRUE;
}
/* Is the mouse cursor inside the event box? */
{
int x;
int y;
gtk_widget_get_pointer(priv->evBox, &x, &y);
gtk_widget_get_allocation(priv->evBox, &allocation);
g_assert(gtk_container_get_border_width( GTK_CONTAINER(priv->evBox))
== 0);
if ( (guint)x < (guint)allocation.width
&& (guint)y < (guint)allocation.height) {
priv->opened = TRUE;
}
}
/* If there is a focused widget, is it inside the event box? */
{
GtkWidget *focus;
focus = gtk_window_get_focus(window);
if (focus && gtk_widget_is_ancestor(focus, priv->evBox)) {
/*
* Override the default 'immediate' to make sure the 'over' widget
* immediately appears along with the widget the focused widget.
*/
immediate = TRUE;
priv->opened = TRUE;
}
}
/* If input is grabbed, is it on behalf of a widget inside the event box? */
if (!priv->inputUngrabbed) {
GtkWidget *grabbed = NULL;
if (gtk_window_has_group (window)) {
GtkWindowGroup *group = gtk_window_get_group (window);
grabbed = gtk_window_group_get_current_grab (group);
}
if (!grabbed) {
grabbed = gtk_grab_get_current();
}
if (grabbed && GTK_IS_MENU(grabbed)) {
/*
* With cascading menus, the deepest menu owns the grab. Traverse the
* menu hierarchy up until we reach the attach widget for the whole
* hierarchy.
*/
for (;;) {
GtkWidget *menuAttach;
GtkWidget *menuItemParent;
menuAttach = gtk_menu_get_attach_widget(GTK_MENU(grabbed));
if (!menuAttach) {
/*
* It is unfortunately not mandatory for a menu to have a proper
* attach widget set.
*/
break;
}
grabbed = menuAttach;
if (!GTK_IS_MENU_ITEM(grabbed)) {
break;
}
menuItemParent = gtk_widget_get_parent(grabbed);
g_return_if_fail(menuItemParent);
if (!GTK_IS_MENU(menuItemParent)) {
break;
}
grabbed = menuItemParent;
}
}
if (grabbed && gtk_widget_is_ancestor(grabbed, priv->evBox)) {
/*
* Override the default 'immediate' to make sure the 'over' widget
* immediately appears along with the widget the grab happens on
* behalf of.
*/
immediate = TRUE;
priv->opened = TRUE;
}
}
if (priv->delayConnection) {
g_source_remove(priv->delayConnection);
}
if (priv->forceClosing) {
ViewAutoDrawerEnforce(that, TRUE);
} else if (immediate) {
ViewAutoDrawerEnforce(that, FALSE);
} else {
priv->delayConnection = g_timeout_add(priv->delayValue,
(GSourceFunc)ViewAutoDrawerOnEnforceDelay, that);
}
}
gboolean gtk_xournal_button_press_event(GtkWidget * widget, GdkEventButton * event) {
/**
* true: Core event, false: XInput event
*/
gboolean isCore = (event->device == gdk_device_get_core_pointer());
INPUTDBG("ButtonPress (%s) (x,y)=(%.2f,%.2f), button %d, modifier %x, isCore %i", gdk_device_get_name(event->device), event->x, event->y,
event->button, event->state, isCore);
GtkXournal * xournal = GTK_XOURNAL(widget);
Settings * settings = xournal->view->getControl()->getSettings();
if(isCore && settings->isXinputEnabled() && settings->isIgnoreCoreEvents()) {
INPUTDBG2("gtk_xournal_button_press_event return false (ignore core)");
return false;
}
XInputUtils::fixXInputCoords((GdkEvent*) event, widget);
if (event->type != GDK_BUTTON_PRESS) {
INPUTDBG2("gtk_xournal_button_press_event return false (event->type != GDK_BUTTON_PRESS)");
return false; // this event is not handled here
}
if (event->button > 3) { // scroll wheel events
XInputUtils::handleScrollEvent(event, widget);
INPUTDBG2("gtk_xournal_button_press_event return true handled scroll event");
return true;
}
gtk_widget_grab_focus(widget);
ToolHandler * h = xournal->view->getControl()->getToolHandler();
// none button release event was sent, send one now
if (xournal->currentInputPage) {
INPUTDBG2("gtk_xournal_button_press_event (xournal->currentInputPage != NULL)");
GdkEventButton ev = *event;
xournal->currentInputPage->translateEvent((GdkEvent*) &ev, xournal->x, xournal->y);
xournal->currentInputPage->onButtonReleaseEvent(widget, &ev);
}
// Change the tool depending on the key or device
ButtonConfig * cfg = NULL;
ButtonConfig * cfgTouch = settings->getTouchButtonConfig();
if (event->button == 2) { // Middle Button
cfg = settings->getMiddleButtonConfig();
} else if (event->button == 3) { // Right Button
cfg = settings->getRightButtonConfig();
} else if (event->device->source == GDK_SOURCE_ERASER) {
cfg = settings->getEraserButtonConfig();
} else if (cfgTouch->device == event->device->name) {
cfg = cfgTouch;
// If an action is defined we do it, even if it's a drawing action...
if (cfg->getDisableDrawing() && cfg->getAction() == TOOL_NONE) {
ToolType tool = h->getToolType();
if (tool == TOOL_PEN || tool == TOOL_ERASER || tool == TOOL_HILIGHTER) {
printf("ignore touchscreen for drawing!\n");
return true;
}
}
}
if (cfg && cfg->getAction() != TOOL_NONE) {
h->copyCurrentConfig();
cfg->acceptActions(h);
}
// hand tool don't change the selection, so you can scroll e.g.
// with your touchscreen without remove the selection
if (h->getToolType() == TOOL_HAND) {
Cursor * cursor = xournal->view->getCursor();
cursor->setMouseDown(true);
xournal->lastMousePositionX = 0;
xournal->lastMousePositionY = 0;
xournal->inScrolling = true;
gtk_widget_get_pointer(widget, &xournal->lastMousePositionX, &xournal->lastMousePositionY);
INPUTDBG2("gtk_xournal_button_press_event (h->getToolType() == TOOL_HAND) return true");
return true;
} else if (xournal->selection) {
EditSelection * selection = xournal->selection;
PageView * view = selection->getView();
GdkEventButton ev = *event;
view->translateEvent((GdkEvent*) &ev, xournal->x, xournal->y);
CursorSelectionType selType = selection->getSelectionTypeForPos(ev.x, ev.y, xournal->view->getZoom());
if (selType) {
xournal->view->getCursor()->setMouseDown(true);
xournal->selection->mouseDown(selType, ev.x, ev.y);
INPUTDBG2("gtk_xournal_button_press_event (selection) return true");
return true;
} else {
xournal->view->clearSelection();
}
}
PageView * pv = gtk_xournal_get_page_view_for_pos_cached(xournal, event->x, event->y);
if (pv) {
xournal->currentInputPage = pv;
pv->translateEvent((GdkEvent*) event, xournal->x, xournal->y);
INPUTDBG2("gtk_xournal_button_press_event (pv->onButtonPressEvent) return");
xournal->view->getDocument()->indexOf(pv->getPage());
return pv->onButtonPressEvent(widget, event);
}
INPUTDBG2("gtk_xournal_button_press_event (not handled) return false");
return false; // not handled
}
void
panel_applet_position_menu (GtkMenu *menu,
int *x,
int *y,
gboolean *push_in,
GtkWidget *applet)
{
GtkAllocation allocation;
GtkRequisition requisition;
GdkScreen *screen;
GtkWidget *parent;
int menu_x = 0;
int menu_y = 0;
int pointer_x;
int pointer_y;
parent = gtk_widget_get_parent (applet);
g_return_if_fail (PANEL_IS_WIDGET (parent));
screen = gtk_widget_get_screen (applet);
gtk_widget_get_preferred_size (GTK_WIDGET (menu), &requisition, NULL);
gdk_window_get_origin (gtk_widget_get_window (applet), &menu_x, &menu_y);
gtk_widget_get_pointer (applet, &pointer_x, &pointer_y);
gtk_widget_get_allocation (applet, &allocation);
if (!gtk_widget_get_has_window (applet)) {
menu_x += allocation.x;
menu_y += allocation.y;
}
if (PANEL_WIDGET (parent)->orient == GTK_ORIENTATION_HORIZONTAL) {
if (gtk_widget_get_direction (GTK_WIDGET (menu)) != GTK_TEXT_DIR_RTL) {
if (pointer_x < allocation.width &&
requisition.width < pointer_x)
menu_x += MIN (pointer_x,
allocation.width - requisition.width);
} else {
menu_x += allocation.width - requisition.width;
if (pointer_x > 0 && pointer_x < allocation.width &&
pointer_x < allocation.width - requisition.width) {
menu_x -= MIN (allocation.width - pointer_x,
allocation.width - requisition.width);
}
}
menu_x = MIN (menu_x, gdk_screen_get_width (screen) - requisition.width);
if (menu_y > gdk_screen_get_height (screen) / 2)
menu_y -= requisition.height;
else
menu_y += allocation.height;
} else {
if (pointer_y < allocation.height &&
requisition.height < pointer_y)
menu_y += MIN (pointer_y, allocation.height - requisition.height);
menu_y = MIN (menu_y, gdk_screen_get_height (screen) - requisition.height);
if (menu_x > gdk_screen_get_width (screen) / 2)
menu_x -= requisition.width;
else
menu_x += allocation.width;
}
*x = menu_x;
*y = menu_y;
*push_in = FALSE;
}
gboolean gtk_xournal_button_press_event(GtkWidget* widget,
GdkEventButton* event)
{
/**
* true: Core event, false: XInput event
*/
gboolean isCore = (event->device == gdk_device_get_core_pointer());
INPUTDBG("ButtonPress (%s) (x,y)=(%.2f,%.2f), button %d, modifier %x, isCore %i",
gdk_device_get_name(event->device), event->x, event->y,
event->button, event->state, isCore);
GtkXournal* xournal = GTK_XOURNAL(widget);
Settings* settings = xournal->view->getControl()->getSettings();
if(isCore && settings->isXinputEnabled() && settings->isIgnoreCoreEvents())
{
INPUTDBG2("gtk_xournal_button_press_event return false (ignore core)");
return false;
}
XInputUtils::fixXInputCoords((GdkEvent*) event, widget);
if (event->type != GDK_BUTTON_PRESS)
{
INPUTDBG2("gtk_xournal_button_press_event return false (event->type != GDK_BUTTON_PRESS)");
return false; // this event is not handled here
}
if (event->button > 3) // scroll wheel events
{
XInputUtils::handleScrollEvent(event, widget);
INPUTDBG2("gtk_xournal_button_press_event return true handled scroll event");
return true;
}
gtk_widget_grab_focus(widget);
// none button release event was sent, send one now
if (xournal->currentInputPage)
{
INPUTDBG2("gtk_xournal_button_press_event (xournal->currentInputPage != NULL)");
GdkEventButton ev = *event;
xournal->currentInputPage->translateEvent((GdkEvent*) &ev, xournal->x,
xournal->y);
xournal->currentInputPage->onButtonReleaseEvent(widget, &ev);
}
ToolHandler* h = xournal->view->getControl()->getToolHandler();
// Change the tool depending on the key or device
if(change_tool(settings, event, xournal))
return true;
// hand tool don't change the selection, so you can scroll e.g.
// with your touchscreen without remove the selection
if (h->getToolType() == TOOL_HAND)
{
Cursor* cursor = xournal->view->getCursor();
cursor->setMouseDown(true);
xournal->lastMousePositionX = 0;
xournal->lastMousePositionY = 0;
xournal->inScrolling = true;
gtk_widget_get_pointer(widget, &xournal->lastMousePositionX,
&xournal->lastMousePositionY);
INPUTDBG2("gtk_xournal_button_press_event (h->getToolType() == TOOL_HAND) return true");
return true;
}
else if (xournal->selection)
{
EditSelection* selection = xournal->selection;
PageView* view = selection->getView();
GdkEventButton ev = *event;
view->translateEvent((GdkEvent*) &ev, xournal->x, xournal->y);
CursorSelectionType selType = selection->getSelectionTypeForPos(ev.x, ev.y,
xournal->view->getZoom());
if (selType)
{
if(selType == CURSOR_SELECTION_MOVE && event->button == 3)
{
selection->copySelection();
}
xournal->view->getCursor()->setMouseDown(true);
xournal->selection->mouseDown(selType, ev.x, ev.y);
INPUTDBG2("gtk_xournal_button_press_event (selection) return true");
return true;
}
else
{
xournal->view->clearSelection();
if(change_tool(settings, event, xournal))
return true;
}
}
PageView* pv = gtk_xournal_get_page_view_for_pos_cached(xournal, event->x,
event->y);
current_view = pv;
if (pv)
{
xournal->currentInputPage = pv;
pv->translateEvent((GdkEvent*) event, xournal->x, xournal->y);
INPUTDBG2("gtk_xournal_button_press_event (pv->onButtonPressEvent) return");
xournal->view->getDocument()->indexOf(pv->getPage());
return pv->onButtonPressEvent(widget, event);
}
INPUTDBG2("gtk_xournal_button_press_event (not handled) return false");
return false; // not handled
}
/* List Selection Callback */
static gboolean selection_made_callback(GtkTreeSelection *selection,
gpointer data)
{
gchar *entry_name;
gchar *entry_pass;
gchar *entry_service;
gboolean autoconnect;
int x, y;
GtkTreeViewColumn *column = NULL;
GtkTreeIter sel;
GList *path_list;
gint sel_count = gtk_tree_selection_count_selected_rows(selection);
if (sel_count < 1 || sel_count > 1) {
gtk_entry_set_text(GTK_ENTRY(username), "");
gtk_entry_set_text(GTK_ENTRY(password), "");
if (sel_count > 1) {
gtk_widget_set_sensitive(GTK_WIDGET(mod_button), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(del_button), TRUE);
gtk_combo_box_set_active(GTK_COMBO_BOX(service_type),
-1);
} else {
gtk_widget_set_sensitive(GTK_WIDGET(mod_button), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(del_button), FALSE);
gtk_combo_box_set_active(GTK_COMBO_BOX(service_type),
-1);
}
return FALSE;
}
path_list = gtk_tree_selection_get_selected_rows(selection, NULL);
gtk_tree_model_get_iter(GTK_TREE_MODEL(account_list_store), &sel,
path_list->data);
g_list_foreach(path_list, (GFunc) gtk_tree_path_free, NULL);
g_list_free(path_list);
selected_row = sel;
gtk_widget_get_pointer(account_list, &x, &y);
gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(account_list),
x, y, NULL, &column, NULL, NULL);
if (column && !strcmp(gtk_tree_view_column_get_title(column), _("C"))) {
gboolean autoconnect;
gtk_tree_model_get(GTK_TREE_MODEL(account_list_store),
&selected_row, CONNECT, &autoconnect, -1);
gtk_list_store_set(account_list_store, &selected_row,
CONNECT, !autoconnect, -1);
}
gtk_tree_model_get(GTK_TREE_MODEL(account_list_store), &sel,
CONNECT, &autoconnect,
USER_NAME, &entry_name,
PASSWORD, &entry_pass, SERVICE_TYPE, &entry_service, -1);
gtk_entry_set_text(GTK_ENTRY(username), entry_name);
gtk_entry_set_text(GTK_ENTRY(password), entry_pass);
{
int i;
LList *l, *list = get_service_list();
for (l = list, i = 0; l; l = l_list_next(l), i++) {
char *name = l->data;
if (!strcmp(name, entry_service)) {
gtk_combo_box_set_active(GTK_COMBO_BOX
(service_type), i);
break;
}
}
l_list_free(list);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(connect_at_startup),
autoconnect);
gtk_widget_set_sensitive(GTK_WIDGET(mod_button), TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(del_button), TRUE);
return FALSE;
}
static gboolean
gossip_cell_renderer_expander_activate (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path_string,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GossipCellRendererExpander *expander;
GossipCellRendererExpanderPriv *priv;
GtkTreePath *path;
GtkSettings *settings;
gboolean animate = FALSE;
gboolean expanding;
gboolean in_cell;
int mouse_x;
int mouse_y;
expander = GOSSIP_CELL_RENDERER_EXPANDER (cell);
priv = GET_PRIV (cell);
if (!GTK_IS_TREE_VIEW (widget) || !priv->activatable)
return FALSE;
path = gtk_tree_path_new_from_string (path_string);
gtk_widget_get_pointer (widget, &mouse_x, &mouse_y);
gtk_tree_view_convert_widget_to_bin_window_coords (GTK_TREE_VIEW (widget),
mouse_x, mouse_y,
&mouse_x, &mouse_y);
/* check if click is within the cell */
if (mouse_x - cell_area->x >= 0
&& mouse_x - cell_area->x <= cell_area->width) {
in_cell = TRUE;
} else {
in_cell = FALSE;
}
if (! in_cell) {
return FALSE;
}
#if 0
if (gtk_tree_path_get_depth (path) > 1) {
gtk_tree_path_free (path);
return TRUE;
}
#endif
settings = gtk_widget_get_settings (GTK_WIDGET (widget));
if (g_object_class_find_property (G_OBJECT_GET_CLASS (settings), "gtk-enable-animations")) {
g_object_get (settings,
"gtk-enable-animations", &animate,
NULL);
}
if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), path)) {
gtk_tree_view_collapse_row (GTK_TREE_VIEW (widget), path);
expanding = FALSE;
} else {
gtk_tree_view_expand_row (GTK_TREE_VIEW (widget), path, FALSE);
expanding = TRUE;
}
if (animate) {
gossip_cell_renderer_expander_start_animation (expander,
GTK_TREE_VIEW (widget),
path,
expanding,
background_area);
}
gtk_tree_path_free (path);
return TRUE;
}
void *dt_control_expose(void *voidptr)
{
int width, height, pointerx, pointery;
if(!darktable.gui->surface) return NULL;
width = cairo_image_surface_get_width(darktable.gui->surface);
height = cairo_image_surface_get_height(darktable.gui->surface);
GtkWidget *widget = dt_ui_center(darktable.gui->ui);
gtk_widget_get_pointer(widget, &pointerx, &pointery);
//create a gtk-independent surface to draw on
cairo_surface_t *cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
cairo_t *cr = cairo_create(cst);
// TODO: control_expose: only redraw the part not overlapped by temporary control panel show!
//
float tb = 8;//fmaxf(10, width/100.0);
darktable.control->tabborder = tb;
darktable.control->width = width;
darktable.control->height = height;
GtkStyle *style = gtk_widget_get_style(widget);
cairo_set_source_rgb (cr,
style->bg[GTK_STATE_NORMAL].red/65535.0,
style->bg[GTK_STATE_NORMAL].green/65535.0,
style->bg[GTK_STATE_NORMAL].blue/65535.0
);
cairo_set_line_width(cr, tb);
cairo_rectangle(cr, tb/2., tb/2., width-tb, height-tb);
cairo_stroke(cr);
cairo_set_line_width(cr, 1.5);
cairo_set_source_rgb (cr, .1, .1, .1);
cairo_rectangle(cr, tb, tb, width-2*tb, height-2*tb);
cairo_stroke(cr);
cairo_save(cr);
cairo_translate(cr, tb, tb);
cairo_rectangle(cr, 0, 0, width - 2*tb, height - 2*tb);
cairo_clip(cr);
cairo_new_path(cr);
// draw view
dt_view_manager_expose(darktable.view_manager, cr, width-2*tb, height-2*tb,
pointerx-tb, pointery-tb);
cairo_restore(cr);
// draw status bar, if any
if(darktable.control->progress < 100.0)
{
tb = fmaxf(20, width/40.0);
char num[10];
cairo_rectangle(cr, width*0.4, height*0.85,
width*0.2*darktable.control->progress/100.0f, tb);
cairo_fill(cr);
cairo_set_source_rgb(cr, 0., 0., 0.);
cairo_rectangle(cr, width*0.4, height*0.85, width*0.2, tb);
cairo_stroke(cr);
cairo_set_source_rgb(cr, 0.9, 0.9, 0.9);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, tb/3);
cairo_move_to (cr, width/2.0-10, height*0.85+2.*tb/3.);
snprintf(num, sizeof(num), "%d%%", (int)darktable.control->progress);
cairo_show_text (cr, num);
}
// draw log message, if any
dt_pthread_mutex_lock(&darktable.control->log_mutex);
if(darktable.control->log_ack != darktable.control->log_pos)
{
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_BOLD);
const float fontsize = 14;
cairo_set_font_size (cr, fontsize);
cairo_text_extents_t ext;
cairo_text_extents (cr,
darktable.control->log_message[darktable.control->log_ack], &ext);
const float pad = 20.0f, xc = width/2.0;
const float yc = height*0.85+10, wd = pad + ext.width*.5f;
float rad = 14;
cairo_set_line_width(cr, 1.);
cairo_move_to( cr, xc-wd,yc+rad);
for(int k=0; k<5; k++)
{
cairo_arc (cr, xc-wd, yc, rad, M_PI/2.0, 3.0/2.0*M_PI);
cairo_line_to (cr, xc+wd, yc-rad);
cairo_arc (cr, xc+wd, yc, rad, 3.0*M_PI/2.0, M_PI/2.0);
cairo_line_to (cr, xc-wd, yc+rad);
if(k == 0)
{
cairo_set_source_rgb(cr, 0.3, 0.3, 0.3);
cairo_fill_preserve (cr);
}
cairo_set_source_rgba(cr, 0., 0., 0., 1.0/(1+k));
cairo_stroke (cr);
rad += .5f;
}
cairo_set_source_rgb(cr, 0.7, 0.7, 0.7);
cairo_move_to (cr, xc-wd+.5f*pad, yc + 1./3.*fontsize);
cairo_show_text (cr,
darktable.control->log_message[darktable.control->log_ack]);
}
// draw busy indicator
if(darktable.control->log_busy > 0)
{
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_BOLD);
const float fontsize = 14;
cairo_set_font_size (cr, fontsize);
cairo_text_extents_t ext;
cairo_text_extents (cr, _("working.."), &ext);
const float xc = width/2.0, yc = height*0.85-30, wd = ext.width*.5f;
cairo_move_to (cr, xc-wd, yc + 1./3.*fontsize);
cairo_text_path (cr, _("working.."));
cairo_set_source_rgb(cr, 0.7, 0.7, 0.7);
cairo_fill_preserve(cr);
cairo_set_line_width(cr, 0.7);
cairo_set_source_rgb(cr, 0.3, 0.3, 0.3);
cairo_stroke(cr);
}
dt_pthread_mutex_unlock(&darktable.control->log_mutex);
cairo_destroy(cr);
cairo_t *cr_pixmap = cairo_create(darktable.gui->surface);
cairo_set_source_surface (cr_pixmap, cst, 0, 0);
cairo_paint(cr_pixmap);
cairo_destroy(cr_pixmap);
cairo_surface_destroy(cst);
return NULL;
}
/**
* gimp_display_shell_scale_get_zoom_focus:
* @shell:
* @new_scale:
* @x:
* @y:
*
* Calculates the viewport coordinate to focus on when zooming
* independently for each axis.
**/
static void
gimp_display_shell_scale_get_zoom_focus (GimpDisplayShell *shell,
gdouble new_scale,
gdouble current_scale,
gdouble *x,
gdouble *y,
GimpZoomFocus zoom_focus)
{
GtkWidget *window = GTK_WIDGET (gimp_display_shell_get_window (shell));
GdkEvent *event;
gint image_center_x;
gint image_center_y;
gint other_x;
gint other_y;
/* Calculate stops-to-fit focus point */
gimp_display_shell_scale_get_image_center_viewport (shell,
&image_center_x,
&image_center_y);
/* Calculate other focus point, default is the canvas center */
other_x = shell->disp_width / 2;
other_y = shell->disp_height / 2;
/* Center on the mouse position instead of the display center if
* one of the following conditions are fulfilled and pointer is
* within the canvas:
*
* (1) there's no current event (the action was triggered by an
* input controller)
* (2) the event originates from the canvas (a scroll event)
* (3) the event originates from the window (a key press event)
*
* Basically the only situation where we don't want to center on
* mouse position is if the action is being called from a menu.
*/
event = gtk_get_current_event ();
if (! event ||
gtk_get_event_widget (event) == shell->canvas ||
gtk_get_event_widget (event) == window)
{
GdkPoint *point = g_queue_pop_head (shell->zoom_focus_pointer_queue);
gint canvas_pointer_x;
gint canvas_pointer_y;
if (point)
{
canvas_pointer_x = point->x;
canvas_pointer_y = point->y;
g_slice_free (GdkPoint, point);
}
else
{
gtk_widget_get_pointer (shell->canvas,
&canvas_pointer_x,
&canvas_pointer_y);
}
if (canvas_pointer_x >= 0 &&
canvas_pointer_y >= 0 &&
canvas_pointer_x < shell->disp_width &&
canvas_pointer_y < shell->disp_height)
{
other_x = canvas_pointer_x;
other_y = canvas_pointer_y;
}
}
/* Decide which one to use for each axis */
if (zoom_focus == GIMP_ZOOM_FOCUS_RETAIN_CENTERING_ELSE_BEST_GUESS)
{
if (gimp_display_shell_scale_viewport_coord_almost_centered (shell,
image_center_x,
image_center_y,
NULL,
NULL))
{
zoom_focus = GIMP_ZOOM_FOCUS_IMAGE_CENTER;
}
else
{
zoom_focus = GIMP_ZOOM_FOCUS_BEST_GUESS;
}
}
switch (zoom_focus)
{
case GIMP_ZOOM_FOCUS_POINTER:
*x = other_x;
*y = other_y;
break;
case GIMP_ZOOM_FOCUS_IMAGE_CENTER:
*x = image_center_x;
*y = image_center_y;
break;
case GIMP_ZOOM_FOCUS_BEST_GUESS:
default:
{
gboolean within_horizontally, within_vertically;
gboolean stops_horizontally, stops_vertically;
gimp_display_shell_scale_image_is_within_viewport (shell,
&within_horizontally,
&within_vertically);
gimp_display_shell_scale_image_stops_to_fit (shell,
new_scale,
current_scale,
&stops_horizontally,
&stops_vertically);
*x = within_horizontally && ! stops_horizontally ? image_center_x : other_x;
*y = within_vertically && ! stops_vertically ? image_center_y : other_y;
}
break;
}
}
gboolean ly_3lrc_widget_on_seek_cb(GtkWidget * widget, GdkEventButton *event, gpointer data)
{
LyMdhMetadata *md=ly_pqm_get_current_md();
if(!md)
return FALSE;
int length=ly_lrc_get_length();
if(length<=0)
return FALSE;
//GdkCursor *cursor;
int index=0;
if (event->button == 1)
{
switch(event->type)
{
case GDK_BUTTON_PRESS:
flag_seek=TRUE;
ly_3lrc_widget_pos_old[X] = event->x;
ly_3lrc_widget_pos_old[Y] = event->y;
index_mark=ly_lrc_get_index();
break;
case GDK_BUTTON_RELEASE:
if(flag_seek==TRUE&&flag_seeked==TRUE)
{
LyLrcLyric **array=ly_lrc_get_array();
index=ly_lrc_get_index();
ly_aud_set_position(array[index]->time/(double)ly_mdh_time_str2int(md->duration));
}
flag_seek = FALSE;
flag_seeked=FALSE;
ly_lrc_set_update_state(TRUE);
break;
default:
break;
}
}
if(flag_seek)
{
int pos[2]={0,0};
gtk_widget_get_pointer(widget, &pos[X], &pos[Y]);
ly_3lrc_widget_pos_delta[Y]=pos[Y]-ly_3lrc_widget_pos_old[Y];
if(pos[Y]-ly_3lrc_widget_pos_old[Y])
flag_seeked=TRUE;
ly_lrc_set_update_state(FALSE);
}
if(flag_seek&&flag_seeked)
{
gint lrc_gap=20;
if(!ly_reg_get("lrc_gap","%d",&lrc_gap))
{
ly_reg_set("lrc_gap","%d",lrc_gap);
}
index=index_mark;
if(ly_3lrc_widget_pos_delta[Y]>=0)
{
index-=(int)(abs(ly_3lrc_widget_pos_delta[Y])/lrc_gap);
if(index<0)
{
index=0;
}
}
else
{
index+=(int)(abs(ly_3lrc_widget_pos_delta[Y])/lrc_gap);
if(index>=length)
{
index=length-1;
}
}
ly_lrc_set_index(index);
}
return FALSE;
}
gboolean
pointer_update (GtkWidget* window)
{
gint pointer_rel_x;
gint pointer_rel_y;
gint pointer_abs_x;
gint pointer_abs_y;
gint win_x;
gint win_y;
gint width;
gint height;
gboolean old_mouse_over;
gfloat old_distance = 0;
if (!GTK_IS_WINDOW (window))
return FALSE;
old_mouse_over = g_mouse_over;
if (gtk_widget_get_realized (window))
{
gint distance_x = 0;
gint distance_y = 0;
gtk_widget_get_pointer (window, &pointer_rel_x, &pointer_rel_y);
gtk_window_get_position (GTK_WINDOW (window), &win_x, &win_y);
pointer_abs_x = win_x + pointer_rel_x;
pointer_abs_y = win_y + pointer_rel_y;
gtk_window_get_size (GTK_WINDOW (window), &width, &height);
if (pointer_abs_x >= win_x &&
pointer_abs_x <= win_x + width &&
pointer_abs_y >= win_y &&
pointer_abs_y <= win_y + height)
g_mouse_over = TRUE;
else
g_mouse_over = FALSE;
if (pointer_abs_x >= win_x &&
pointer_abs_x <= win_x + width)
distance_x = 0;
else
{
if (pointer_abs_x < win_x)
distance_x = abs (pointer_rel_x);
if (pointer_abs_x > win_x + width)
distance_x = abs (pointer_rel_x - width);
}
if (pointer_abs_y >= win_y &&
pointer_abs_y <= win_y + height)
distance_y = 0;
else
{
if (pointer_abs_y < win_y)
distance_y = abs (pointer_rel_y);
if (pointer_abs_y > win_y + height)
distance_y = abs (pointer_rel_y - height);
}
old_distance = g_distance;
g_distance = sqrt (distance_x * distance_x +
distance_y * distance_y) /
(double) 40;
}
if (old_mouse_over != g_mouse_over)
set_bg_blur (window, !g_mouse_over);
if (old_distance != g_distance)
gtk_widget_queue_draw (window);
return TRUE;
}
