PasteClip Ctrl::GtkDnd(GtkWidget *widget, GdkDragContext *context, gint x, gint y,
guint time, gpointer user_data, bool paste)
{
DndTargets(context);
g_object_ref(context); // make sure these always survive the action...
g_object_ref(widget);
dnd_context = context;
dnd_widget = widget;
dnd_time = time;
PasteClip clip;
clip.type = 1;
clip.paste = paste;
clip.accepted = false;
clip.allowed = DND_MOVE|DND_COPY;
gint dummy;
GdkModifierType mod;
gdk_window_get_pointer(gdk_get_default_root_window(), &dummy, &dummy, &mod);
clip.action = mod & GDK_CONTROL_MASK ? DND_COPY : DND_MOVE;
Ctrl *w = DragWnd(user_data);
if(w) {
gint mx, my;
GdkModifierType mod;
gdk_window_get_pointer(gdk_get_default_root_window(), &mx, &my, &mod);
CurrentState = mod;
CurrentMousePos = Point(x, y) + w->GetScreenRect().TopLeft();
w->DnD(CurrentMousePos, clip);
}
gdk_drag_status(context, clip.IsAccepted() ? clip.GetAction() == DND_MOVE ? GDK_ACTION_MOVE
: GDK_ACTION_COPY
: GdkDragAction(0), time);
return clip;
}
static gboolean
scribble_motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
gpointer data)
{
int x, y;
GdkModifierType state;
if (pixmap == NULL)
return FALSE; /* paranoia check, in case we haven't gotten a configure event */
/* This call is very important; it requests the next motion event.
* If you don't call gdk_window_get_pointer() you'll only get
* a single motion event. The reason is that we specified
* GDK_POINTER_MOTION_HINT_MASK to gtk_widget_set_events().
* If we hadn't specified that, we could just use event->x, event->y
* as the pointer location. But we'd also get deluged in events.
* By requesting the next event as we handle the current one,
* we avoid getting a huge number of events faster than we
* can cope.
*/
gdk_window_get_pointer (event->window, &x, &y, &state);
if (state & GDK_BUTTON1_MASK)
draw_brush (widget, x, y);
/* We've handled it, stop processing */
return TRUE;
}
static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxMiniFrame *win )
{
if (g_isIdle) wxapp_install_idle_handler();
if (!win->m_hasVMT) return FALSE;
if (g_blockEventsOnDrag) return TRUE;
if (g_blockEventsOnScroll) return TRUE;
if (!win->m_isDragging) return TRUE;
if (gdk_event->is_hint)
{
int x = 0;
int y = 0;
GdkModifierType state;
gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
gdk_event->x = x;
gdk_event->y = y;
gdk_event->state = state;
}
DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
win->m_oldX = (int)gdk_event->x - win->m_diffX;
win->m_oldY = (int)gdk_event->y - win->m_diffY;
DrawFrame( widget, win->m_oldX, win->m_oldY, win->m_width, win->m_height );
return TRUE;
}
static gboolean Stylus_Move(GtkWidget *w, GdkEventMotion *e, gpointer data)
{
GdkModifierType state;
gint x,y;
s32 EmuX, EmuY;
if(click)
{
if(e->is_hint)
gdk_window_get_pointer(w->window, &x, &y, &state);
else
{
x= (gint)e->x;
y= (gint)e->y;
state=(GdkModifierType)e->state;
}
// fprintf(stderr,"X=%d, Y=%d, S&1=%d\n", x,y,state&GDK_BUTTON1_MASK);
if(y >= 192 && (state & GDK_BUTTON1_MASK))
{
EmuX = x;
EmuY = y - 192;
if(EmuX<0) EmuX = 0; else if(EmuX>255) EmuX = 255;
if(EmuY<0) EmuY = 0; else if(EmuY>192) EmuY = 192;
NDS_setTouchPos(EmuX, EmuY);
}
}
return TRUE;
}
gboolean DrawFunc(gpointer user) {
ENGD *engd = user;
GdkGLDrawable *pGLD = 0;
GdkRectangle rect = {};
GdkModifierType gmod;
gint xptr, yptr;
GdkRegion *creg;
GdkWindow *hwnd;
intptr_t *data;
uint32_t attr;
cEngineCallback(engd, ECB_GUSR, (intptr_t)&data);
if (!(hwnd = gtk_widget_get_window(GTK_WIDGET(data[0]))))
return TRUE;
gdk_window_get_pointer(hwnd, &xptr, &yptr, &gmod);
attr = ((gmod & GDK_BUTTON1_MASK)? UFR_LBTN : 0)
| ((gmod & GDK_BUTTON2_MASK)? UFR_MBTN : 0)
| ((gmod & GDK_BUTTON3_MASK)? UFR_RBTN : 0)
| ((gtk_window_is_active(GTK_WINDOW(data[0])))? UFR_MOUS : 0);
attr = cPrepareFrame(engd, xptr, yptr, attr);
if (attr & PFR_SKIP)
usleep(1000);
if (attr & PFR_HALT)
return TRUE;
if (attr & PFR_PICK) {
rect.width = (int16_t)(data[2]);
rect.height = (int16_t)(data[2] >> 16);
}
static void
gamine_on_key (GtkWidget *pWidget,
GdkEventKey* pKey,
gamine_t *cb)
{
gint mx, my;
if (pKey->type == GDK_KEY_PRESS)
{
switch (pKey->keyval)
{
case GDK_Escape :
gtk_main_quit ();
break;
case GDK_space :
gtk_widget_queue_draw(pWidget);
break;
case GDK_Print:
save_picture(cb);
break;
default:
gdk_window_get_pointer(pWidget->window, &mx, &my, NULL);
draw_string(cb, mx, my, pKey->string);
break;
}
};
}
void
menu_calc_popup_position (GtkMenu *menu, gint *x_ret, gint *y_ret,
gboolean *push_in,
gpointer data)
{
GdkWindow *window = data;
gint x = 0, y = 0, w = 0, h = 0, cursor_x = 0, cursor_y = 0;
GdkModifierType mask;
g_return_if_fail (x_ret && y_ret);
g_return_if_fail (window);
gdk_window_get_pointer (window, &cursor_x, &cursor_y, &mask);
gdk_window_get_origin (window, &x, &y);
gdk_window_get_size (window, &w, &h);
if (cursor_x < 0 || cursor_x > w || cursor_y < 0 || cursor_y > h)
{
*x_ret = x + w / 2;
*y_ret = y + h / 2;
} else {
*x_ret = x + cursor_x;
*y_ret = y + cursor_y;
}
}
static void
timeline_frame_cb (GsdTimeline *timeline,
gdouble progress,
gpointer user_data)
{
GsdLocatePointerData *data = (GsdLocatePointerData *) user_data;
GdkScreen *screen;
gint cursor_x, cursor_y;
if (gtk_widget_is_composited (data->widget))
{
gdk_window_invalidate_rect (data->window, NULL, FALSE);
data->progress = progress;
}
else if (progress >= data->progress + CIRCLES_PROGRESS_INTERVAL)
{
/* only invalidate window each circle interval */
update_shape (data);
gdk_window_invalidate_rect (data->window, NULL, FALSE);
data->progress += CIRCLES_PROGRESS_INTERVAL;
}
screen = gdk_drawable_get_screen (data->window);
gdk_window_get_pointer (gdk_screen_get_root_window (screen),
&cursor_x, &cursor_y, NULL);
gdk_window_move (data->window,
cursor_x - WINDOW_SIZE / 2,
cursor_y - WINDOW_SIZE / 2);
}
static void
move_locate_pointer_window (GsdLocatePointerData *data,
GdkScreen *screen)
{
gint cursor_x, cursor_y;
GdkBitmap *mask;
GdkColor col;
GdkGC *gc;
gdk_window_get_pointer (gdk_screen_get_root_window (screen), &cursor_x, &cursor_y, NULL);
gdk_window_move_resize (data->window,
cursor_x - WINDOW_SIZE / 2,
cursor_y - WINDOW_SIZE / 2,
WINDOW_SIZE, WINDOW_SIZE);
col.pixel = 0;
mask = gdk_pixmap_new (data->window, WINDOW_SIZE, WINDOW_SIZE, 1);
gc = gdk_gc_new (mask);
gdk_gc_set_foreground (gc, &col);
gdk_draw_rectangle (mask, gc, TRUE, 0, 0, WINDOW_SIZE, WINDOW_SIZE);
/* allow events to happen through the window */
gdk_window_input_shape_combine_mask (data->window, mask, 0, 0);
g_object_unref (mask);
g_object_unref (gc);
}
/* Zpracování událostí - tato funkce pøidává popis události do seznamu
* zachycených událostí, ale vrací FALSE, proto¾e chceme, aby se události dál
* normálnì zpracovávaly. */
static gint gtk_ev_event(GtkWidget *widget, GdkEvent *event)
{
GtkEv *ev;
g_return_val_if_fail(widget, FALSE);
g_return_val_if_fail(GTK_IS_EV(widget), FALSE);
g_return_val_if_fail(event, FALSE);
ev = GTK_EV(widget);
if(event->any.window == widget->window) {
if(GTK_WIDGET_CLASS(parent_class)->event)
return GTK_WIDGET_CLASS(parent_class)->event(widget, event);
} else {
/* Událost je buï urèena pro ev->ev_win, nebo je to klávesnicová
* událost poslaná z toplevel GtkWindow */
gchar *text;
text = event_to_text(event);
gtk_ev_push_text(ev, text);
g_free(text);
/* Zajistit pøeètení dal¹í motion event */
if(event->type == GDK_MOTION_NOTIFY)
gdk_window_get_pointer(ev->ev_win, NULL, NULL, NULL);
}
gtk_signal_emit(GTK_OBJECT(widget), ev_signals[EVENT_RECEIVED],
event->type);
return FALSE;
}
static void
setupConnections(GtkWidget *widget, GtkWidget *parent)
{
GtkWidgetProps props(widget);
if (widget && !props->scrolledWindowHacked) {
props->scrolledWindowHacked = true;
gtk_widget_add_events(widget, GDK_LEAVE_NOTIFY_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK);
props->scrolledWindowDestroy.conn("destroy-event", destroy, parent);
props->scrolledWindowUnrealize.conn("unrealize", destroy, parent);
props->scrolledWindowStyleSet.conn("style-set", styleSet, parent);
if (opts.unifyCombo && opts.unifySpin) {
props->scrolledWindowEnter.conn("enter-notify-event",
enter, parent);
props->scrolledWindowLeave.conn("leave-notify-event",
leave, parent);
}
props->scrolledWindowFocusIn.conn("focus-in-event", focusIn, parent);
props->scrolledWindowFocusOut.conn("focus-out-event", focusOut, parent);
if (parent && opts.unifyCombo && opts.unifySpin) {
QtcRect alloc = Widget::getAllocation(parent);
int x;
int y;
gdk_window_get_pointer(gtk_widget_get_window(parent),
&x, &y, nullptr);
if (x >= 0 && x <alloc.width && y >= 0 && y < alloc.height) {
hoverWidget = parent;
}
}
}
}
static void qtcScrolledWindowSetupConnections(GtkWidget *widget, GtkWidget *parent)
{
if (widget && !g_object_get_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET"))
{
gtk_widget_add_events(widget, GDK_LEAVE_NOTIFY_MASK|GDK_ENTER_NOTIFY_MASK|GDK_FOCUS_CHANGE_MASK);
g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET", (gpointer)1);
g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_DESTROY_ID",
(gpointer)g_signal_connect(G_OBJECT(widget), "destroy-event", G_CALLBACK(qtcScrolledWindowDestroy), parent));
g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_UNREALIZE_ID",
(gpointer)g_signal_connect(G_OBJECT(widget), "unrealize", G_CALLBACK(qtcScrolledWindowDestroy), parent));
g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_STYLE_SET_ID",
(gpointer)g_signal_connect(G_OBJECT(widget), "style-set", G_CALLBACK(qtcScrolledWindowStyleSet), parent));
if(ENTRY_MO)
{
g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_ENTER_ID",
(gpointer)g_signal_connect(G_OBJECT(widget), "enter-notify-event", G_CALLBACK(qtcScrolledWindowEnter), parent));
g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_LEAVE_ID",
(gpointer)g_signal_connect(G_OBJECT(widget), "leave-notify-event", G_CALLBACK(qtcScrolledWindowLeave), parent));
}
g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_FOCUS_IN_ID",
(gpointer)g_signal_connect(G_OBJECT(widget), "focus-in-event", G_CALLBACK(qtcScrolledWindowFocusIn), parent));
g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_FOCUS_OUT_ID",
(gpointer)g_signal_connect(G_OBJECT(widget), "focus-out-event", G_CALLBACK(qtcScrolledWindowFocusOut), parent));
if(parent && ENTRY_MO)
{
gint x, y;
GtkAllocation alloc=qtcWidgetGetAllocation(parent);
gdk_window_get_pointer(qtcWidgetGetWindow(parent), &x, &y, 0L);
if(x>=0 && x<alloc.width && y>=0 && y<alloc.height)
qtcScrolledWindowHover=parent;
}
}
}
static void
move_locate_pointer_window (MsdLocatePointerData *data,
GdkScreen *screen)
{
gint cursor_x, cursor_y;
GdkBitmap *mask;
cairo_t *cr;
gdk_window_get_pointer (gdk_screen_get_root_window (screen), &cursor_x, &cursor_y, NULL);
gdk_window_move_resize (data->window,
cursor_x - WINDOW_SIZE / 2,
cursor_y - WINDOW_SIZE / 2,
WINDOW_SIZE, WINDOW_SIZE);
mask = gdk_pixmap_new (data->window, WINDOW_SIZE, WINDOW_SIZE, 1);
cr = gdk_cairo_create (mask);
cairo_set_source_rgb (cr, 0., 0., 0.);
cairo_rectangle (cr, 0., 0., WINDOW_SIZE, WINDOW_SIZE);
cairo_fill (cr);
cairo_destroy (cr);
/* allow events to happen through the window */
gdk_window_input_shape_combine_mask (data->window, mask, 0, 0);
g_object_unref (mask);
}
gboolean
ghid_note_event_location (GdkEventButton * ev)
{
gint x, y;
gboolean moved;
if (!ev)
{
gdk_window_get_pointer (ghid_port.drawing_area->window, &x, &y, NULL);
event_x = x;
event_y = y;
}
else
{
event_x = ev->x;
event_y = ev->y;
}
gport->view_x = event_x * gport->zoom + gport->view_x0;
gport->view_y = event_y * gport->zoom + gport->view_y0;
moved = MoveCrosshairAbsolute (SIDE_X (gport->view_x),
SIDE_Y (gport->view_y));
if (moved)
{
AdjustAttachedObjects ();
RestoreCrosshair (false);
}
ghid_set_cursor_position_labels ();
return moved;
}
static gboolean
motion_notify_event_cb (GtkWidget *widget, GdkEventMotion *event, gpointer data) {
gui_world *world = (gui_world *)data;
int x, y;
GdkModifierType state;
gdk_window_get_pointer (event->window, &x, &y, &state);
int space_height = 50, space_width = 50;
/* convert into cp values */
int window_height = gtk_widget_get_allocated_height(world -> graphics -> drawing_screen);
int window_width = gtk_widget_get_allocated_width(world -> graphics -> drawing_screen);
float screen_height_ratio = (float) window_height / space_height;
float screen_width_ratio = (float) window_width / space_width;
cpFloat x1 = (x - window_width / 2) / screen_width_ratio;
cpFloat y1 = (-y + window_height / 2) / screen_height_ratio;
if (state & GDK_BUTTON1_MASK) {
add_user_point (x1, y1, world);
}
return TRUE;
}
void Gcwkeyaction(GtkWidget * w, GdkEventKey * event, gpointer data)
{
Gwidget_t *widget;
Gevent_t gev;
int xtype, bn, wi, state;
PIXpoint_t pp;
unsigned int mask;
char c;
widget = findwidget((unsigned long) canvas->w, G_CANVASWIDGET);
switch ((xtype = event->type)) {
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
gdk_window_get_pointer(event->window, &pp.x, &pp.y, &state);
gev.type = G_KEYBD;
gev.code = (xtype == GDK_KEY_PRESS) ? G_DOWN : G_UP;
gev.data = event->keyval;
gev.p = Gppixtodraw(widget, pp);
break;
default:
return;
}
gev.wi = widget - &Gwidgets[0];
Gpopdownflag = FALSE;
if (WCU->func)
(*WCU->func) (&gev);
if (Gpopdownflag)
Gpopdownflag = FALSE;
}
static gint
gtk_vruler_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
GtkRuler *ruler;
gint y;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_VRULER (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
ruler = GTK_RULER (widget);
if (event->is_hint)
gdk_window_get_pointer (widget->window, NULL, &y, NULL);
else
y = event->y;
ruler->position = ruler->lower + ((ruler->upper - ruler->lower) * y) / widget->allocation.height;
/* Make sure the ruler has been allocated already */
if (ruler->backing_store != NULL)
gtk_ruler_draw_pos (ruler);
return FALSE;
}
gint handle_map_button_release(
GtkWidget *widget, GdkEventMotion *event
)
{
gint x = 0;
gint y = 0;
GdkModifierType state = (GdkModifierType)0;
if( event->is_hint ){
gdk_window_get_pointer( event->window, &x, &y, &state );
} else {
x = (gint)(event->x);
y = (gint)(event->y);
state = (GdkModifierType)(event->state);
}
if( !(state & GDK_BUTTON1_MASK) )
gMouseMotion.end( MouseMotion::nMouseButton0, x, y );
if( !(state & GDK_BUTTON2_MASK) )
gMouseMotion.end( MouseMotion::nMouseButton1, x, y );
if( !(state & GDK_BUTTON3_MASK) )
gMouseMotion.end( MouseMotion::nMouseButton2, x, y );
if( !(state & GDK_BUTTON4_MASK) )
gMouseMotion.end( MouseMotion::nMouseButton3, x, y );
if( !(state & GDK_BUTTON5_MASK) )
gMouseMotion.end( MouseMotion::nMouseButton4, x, y );
gMapDragBgnX = -1;
gMapDragBgnY = -1;
return TRUE;
}
void
populate_popup_cb(WebKitWebView *v, GtkMenu *m, void *c) {
(void) c;
gint context;
if(!uzbl.gui.menu_items)
return;
/* check context */
if((context = get_click_context()) == -1)
return;
WebKitHitTestResult *hit_test_result;
GdkEventButton ev;
gint x, y;
#if GTK_CHECK_VERSION (3, 0, 0)
gdk_window_get_device_position (gtk_widget_get_window(GTK_WIDGET(v)),
gdk_device_manager_get_client_pointer (
gdk_display_get_device_manager (
gtk_widget_get_display (GTK_WIDGET (v)))),
&x, &y, NULL);
#else
gdk_window_get_pointer(gtk_widget_get_window(GTK_WIDGET(v)), &x, &y, NULL);
#endif
ev.x = x;
ev.y = y;
hit_test_result = webkit_web_view_get_hit_test_result(v, &ev);
populate_context_menu(m, hit_test_result, context);
g_object_unref(hit_test_result);
}
static void
expose_event_cb (GtkDrawingArea *drawing_area,
GdkEventExpose *eev,
gpointer user_data)
{
GtkWidget *widget;
EomPrintPreviewPrivate *priv;
cairo_t *cr;
widget = GTK_WIDGET (drawing_area);
priv = EOM_PRINT_PREVIEW (user_data)->priv;
update_relative_sizes (EOM_PRINT_PREVIEW (user_data));
cr = gdk_cairo_create (gtk_widget_get_window (widget));
eom_print_preview_draw (EOM_PRINT_PREVIEW (user_data), cr);
if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) {
fprintf (stderr, "Cairo is unhappy: %s\n",
cairo_status_to_string (cairo_status (cr)));
}
cairo_destroy (cr);
gdk_window_get_pointer (gtk_widget_get_window (widget), NULL, NULL, NULL);
}
static void wxFillOtherKeyEventFields(wxKeyEvent& event,
wxWindowGTK *win,
GdkEventKey *gdk_event)
{
int x = 0;
int y = 0;
GdkModifierType state;
if (gdk_event->window)
gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
event.SetTimestamp( gdk_event->time );
event.SetId(win->GetId());
event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
event.m_scanCode = gdk_event->keyval;
event.m_rawCode = (wxUint32) gdk_event->keyval;
event.m_rawFlags = 0;
#if wxUSE_UNICODE
event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval);
#endif
wxGetMousePosition( &x, &y );
win->ScreenToClient( &x, &y );
event.m_x = x;
event.m_y = y;
event.SetEventObject( win );
}
static int
uni_nav_motion_notify (GtkWidget * widget, GdkEventMotion * ev)
{
UniNav *nav = UNI_NAV (widget);
int mx, my;
gdk_window_get_pointer (gtk_widget_get_window (widget), &mx, &my, NULL);
/* Make coordinates relative to window. */
mx -= 4;
my -= 4;
/* Convert Nav space to Zoom space coordinates. */
gdouble zoom2nav_factor = uni_nav_get_zoom2nav_factor (nav);
GdkRectangle rect;
uni_image_view_get_viewport (nav->view, &rect);
/* Convert Zoom space to Nav space coordinates. */
rect.width = (gdouble) rect.width / zoom2nav_factor;
rect.height = (gdouble) rect.height / zoom2nav_factor;
/* Subtract half of the XOR rectangles size from the coordinates. */
mx -= (rect.width / 2);
my -= (rect.height / 2);
/* Do the adjusted coordinate conversion. */
int zoom_x_ofs = mx * zoom2nav_factor;
int zoom_y_ofs = my * zoom2nav_factor;
uni_image_view_set_offset (nav->view, zoom_x_ofs, zoom_y_ofs, TRUE);
uni_nav_draw_rectangle (nav, TRUE);
return TRUE;
}
void tree_tips_show(TreeTips *tips)
{
GtkWidget *label;
gint x,y;
gchar *pstr;
if (!tips) return;
if (!tips->enabled) return;
if (tips->window) return;
pstr = ((* tips->func)(tips->bfwin,tips->tree, tips->posx,tips->posy));
if (pstr)
{
tips->window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_app_paintable (tips->window, TRUE);
gtk_window_set_resizable (GTK_WINDOW(tips->window), FALSE);
gtk_widget_set_name (tips->window, "tree-tooltips");
gtk_container_set_border_width (GTK_CONTAINER (tips->window), 4);
g_signal_connect_swapped(GTK_WINDOW(tips->window),"expose-event",G_CALLBACK(tree_tips_paint),tips);
label = gtk_label_new (NULL);
gtk_label_set_markup(GTK_LABEL(label),pstr);
gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
gtk_container_add (GTK_CONTAINER (tips->window), GTK_WIDGET (label));
gtk_window_set_position (GTK_WINDOW(tips->window), GTK_WIN_POS_MOUSE);
gdk_window_get_pointer (NULL, &x, &y, NULL);
gtk_window_move (GTK_WINDOW(tips->window), x + 8, y + 16);
gtk_widget_show_all(tips->window);
g_free(pstr);
tips->hide_tout = g_timeout_add (tips->hide_interval, (GSourceFunc) tree_tips_hide, tips);
}
}
static gboolean
hand_display_motion (GtkWidget *hand, GdkEventMotion *event)
{
HandDisplay *handdisp = HAND_DISPLAY(hand);
int card = which_card(handdisp, event->x, event->y);
if (handdisp->drag && handdisp->cur_click >= 0 && handdisp->cur_click < 52 &&
gtk_drag_check_threshold (hand, handdisp->drag_x, handdisp->drag_y, event->x, event->y))
{
if (! target_list)
target_list = gtk_target_list_new (target_entry, 1);
handdisp->cur_drag = handdisp->cur_click;
gtk_drag_begin (hand, target_list, GDK_ACTION_COPY, 1, (GdkEvent *) event);
}
if (handdisp->cur_focus != card) {
if (handdisp->cur_focus != -1) {
redraw_card (hand, handdisp->cur_focus);
g_signal_emit_by_name (handdisp, "card-leave", handdisp->cur_focus);
}
handdisp->cur_focus = card;
if (card != -1) {
redraw_card (hand, card);
g_signal_emit_by_name (handdisp, "card-enter", card);
}
}
gdk_window_get_pointer(gtk_widget_get_window (hand), NULL, NULL, NULL); /* request more pointer hints */
return FALSE;
}
/* *****************************************************************************
* create a new POI of type "waypoint.route"
* and append it to the current route
*/
void add_quickpoint_to_route ()
{
gchar t_name[100], t_cmt[100];
gdouble t_lat, t_lon;
glong t_id;
gint t_x, t_y;
GdkModifierType state;
g_snprintf (t_name, sizeof (t_name), "%s %d", _("Routepoint"), route.items+1);
g_snprintf (t_cmt, sizeof (t_cmt), _("Quicksaved Routepoint"));
gdk_window_get_pointer (GTK_LAYOUT (map_drawingarea)->bin_window, &t_x, &t_y, &state);
calcxytopos (t_x, t_y, &t_lat, &t_lon, current.zoom);
if ( mydebug > 0 )
printf ("Add Routepoint: %s lat:%f,lon:%f (x:%d,y:%d)\n",
t_name, t_lat, t_lon, t_x, t_y);
t_id = addwaypoint (t_name,
"waypoint.route", t_cmt, t_lat, t_lon, TRUE);
add_routepoint
(t_id, t_name, t_cmt, "waypoint.route", t_lon, t_lat);
gtk_statusbar_push (GTK_STATUSBAR (frame_statusbar),
current.statusbar_id,
_("Routepoint added."));
gtk_widget_set_sensitive (menuitem_saveroute, TRUE);
}
void mainWindow_press( GtkWidget* widget,
GdkEventButton* event, gpointer callback_data )
{
if ( event->button == 1 )
{
gdk_window_raise(widget->window );
gdk_pointer_grab(widget->window, FALSE, (GdkEventMask)
( GDK_BUTTON_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK ), GDK_NONE, GDK_NONE, GDK_CURRENT_TIME);
offset_x = (int)event->x;
offset_y = (int)event->y;
indrag=1;
}
else if ( event->button == 3 )
{
int x,y;
gdk_window_get_pointer( NULL, &x, &y, NULL );
gtk_item_factory_popup( GTK_ITEM_FACTORY( mainMenu ),
x,
y,
3,
GDK_CURRENT_TIME );
}
}
static gboolean Stylus_Press(GtkWidget *w, GdkEventButton *e, gpointer data)
{
GdkModifierType state;
gint x,y;
s32 EmuX, EmuY;
if(desmume_running())
{
if(e->button == 1)
{
click = TRUE;
gdk_window_get_pointer(w->window, &x, &y, &state);
if(y >= 192 && (state & GDK_BUTTON1_MASK))
{
EmuX = x;
EmuY = y - 192;
if(EmuX<0) EmuX = 0; else if(EmuX>255) EmuX = 255;
if(EmuY<0) EmuY = 0; else if(EmuY>192) EmuY = 192;
NDS_setTouchPos(EmuX, EmuY);
}
}
}
return TRUE;
}
static void reload_clicked_cb (GtkButton *button, WebBrowserObject *browser)
{
gint x, y;
GdkModifierType state = (GdkModifierType)0;
gdk_window_get_pointer(NULL, &x, &y, &state);
gtk_moz_embed_reload(GTK_MOZ_EMBED(browser->mozilla), (state & GDK_SHIFT_MASK) ? GTK_MOZ_EMBED_FLAG_RELOADBYPASSCACHE : GTK_MOZ_EMBED_FLAG_RELOADNORMAL);
}
gboolean
ghid_note_event_location (GdkEventButton * ev)
{
gint event_x, event_y;
gboolean moved;
if (!ev)
{
gdk_window_get_pointer (gtk_widget_get_window (ghid_port.drawing_area),
&event_x, &event_y, NULL);
}
else
{
event_x = ev->x;
event_y = ev->y;
}
ghid_event_to_pcb_coords (event_x, event_y, &gport->pcb_x, &gport->pcb_y);
moved = MoveCrosshairAbsolute (gport->pcb_x, gport->pcb_y);
if (moved)
{
AdjustAttachedObjects ();
notify_crosshair_change (true);
}
ghid_set_cursor_position_labels ();
return moved;
}
void structGraphicsScreen :: v_getMouseLocation (double *xWC, double *yWC) {
#if cairo
GdkEvent *gevent = gdk_display_get_event (d_display);
if (gevent != NULL) {
if (gevent -> type == GDK_BUTTON_RELEASE) {
theMouseDown = false;
}
gdk_event_free (gevent);
}
gint xDC, yDC;
gdk_window_get_pointer (d_window, & xDC, & yDC, NULL);
Graphics_DCtoWC (this, xDC, yDC, xWC, yWC);
#elif cocoa
#elif win
POINT pos;
if (! GetCursorPos (& pos)) { Melder_warning (L"Cannot get cursor position."); return; }
ScreenToClient (d_winWindow, & pos);
Graphics_DCtoWC (this, pos. x, pos. y, xWC, yWC);
#elif mac
if (HIGetMousePosition != NULL && false) { // AVAILABLE_MAC_OS_X_VERSION_10_5_AND_LATER
//Melder_casual ("HIGetMousePosition exists");
HIPoint mouseLoc;
HIGetMousePosition (kHICoordSpaceWindow, GetWindowFromPort (d_macPort), & mouseLoc);
Graphics_DCtoWC (this, mouseLoc. x, mouseLoc. y, xWC, yWC);
} else {
Point mouseLoc;
GetMouse (& mouseLoc); // AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5
Graphics_DCtoWC (this, mouseLoc. h, mouseLoc. v, xWC, yWC);
}
#endif
}