gboolean
rcm_gray_motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
RcmGray *circle)
{
gint x, y;
GdkGCValues values;
values.function = GDK_INVERT;
xor_gc = gdk_gc_new_with_values (Current.From->preview->window,
&values,
GDK_GC_FUNCTION);
if (circle->action_flag == DRAG_START)
{
GtkStyle *style = gtk_widget_get_style (circle->preview);
gtk_widget_queue_draw (circle->preview);
color_rotate_draw_large_circle (circle->preview->window,
style->black_gc,
circle->gray_sat);
circle->action_flag = DRAGING;
}
else
{
color_rotate_draw_little_circle (widget->window, xor_gc,
circle->hue, circle->satur); /* erase */
}
x = event->x - GRAY_CENTER - LITTLE_RADIUS;
y = GRAY_CENTER - event->y + LITTLE_RADIUS;
circle->hue = angle_mod_2PI (arctg (y, x));
circle->satur = sqrt (SQR (x) + SQR (y)) / GRAY_RADIUS;
if (circle->satur > 1.0)
circle->satur = 1;
color_rotate_draw_little_circle (widget->window, xor_gc,
circle->hue, circle->satur);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->hue_entry),
circle->hue * rcm_units_factor(Current.Units));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->satur_entry),
circle->satur);
if (Current.RealTime)
rcm_render_preview (Current.Bna->after);
gdk_event_request_motions (event);
return TRUE;
}
static gboolean
motion_notify_cb (GtkWidget *widget, GdkEventMotion *ev, gpointer userdata)
{
GhidTrackball *ball = GHID_TRACKBALL (userdata);
double x1, y1;
double x2, y2;
float q[4];
if (!ball->dragging) {
gdk_event_request_motions (ev);
return TRUE;
}
x1 = ball->x1;
y1 = ball->y1;
x2 = 2. * ev->x / widget->allocation.width - 1.;
y2 = 2. * ev->y / widget->allocation.height - 1.;
/* Trackball computation */
trackball (q, x1, y1, x2, y2);
add_quats (q, ball->quart1, ball->quart2);
g_signal_emit (ball, ghid_trackball_signals[ROTATION_CHANGED], 0,
ball->quart2);
gdk_event_request_motions (ev);
return TRUE;
}
gboolean SludgeGLApplication::on_drawingarea1_motion_notify_event
(GtkWidget *theWidget, GdkEventMotion *theEvent)
{
refreshStatusbarCursor(theEvent->x, theEvent->y);
if ( (awaitButton1Release && theEvent->state & GDK_BUTTON1_MASK) || awaitButton2Release )
{
int local_pointx, local_pointy;
local_pointx = theEvent->x;
local_pointy = theEvent->y;
if (theEvent->state & GDK_BUTTON1_MASK)
{
button1Motion (local_pointx, local_pointy);
}
else if (awaitButton2Release)
{
int x1 = x;
int y1 = y;
x = x1 + (mouseLoc2x - local_pointx);
y = y1 + (local_pointy - mouseLoc2y);
setCoords();
mouseLoc2x = theEvent->x;
mouseLoc2y = theEvent->y;
}
render_timer_event(theDrawingarea);
}
gdk_event_request_motions (theEvent);
return FALSE;
}
gboolean
rcm_gray_motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
RcmGray *circle)
{
gint x, y;
gtk_widget_queue_draw (circle->preview);
x = event->x - GRAY_CENTER - LITTLE_RADIUS;
y = GRAY_CENTER - event->y + LITTLE_RADIUS;
circle->hue = angle_mod_2PI (arctg (y, x));
circle->satur = sqrt (SQR (x) + SQR (y)) / GRAY_RADIUS;
if (circle->satur > 1.0)
circle->satur = 1;
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->hue_entry),
circle->hue * rcm_units_factor(Current.Units));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->satur_entry),
circle->satur);
if (Current.RealTime)
rcm_render_preview (Current.Bna->after);
gdk_event_request_motions (event);
return TRUE;
}
gint
ghid_port_window_motion_cb (GtkWidget * widget,
GdkEventMotion * ev, GHidPort * out)
{
gdouble dx, dy;
static gint x_prev = -1, y_prev = -1;
gdk_event_request_motions (ev);
if (out->panning)
{
dx = gport->view.coord_per_px * (x_prev - ev->x);
dy = gport->view.coord_per_px * (y_prev - ev->y);
if (x_prev > 0)
ghid_pan_view_rel (dx, dy);
x_prev = ev->x;
y_prev = ev->y;
return FALSE;
}
x_prev = y_prev = -1;
ghid_note_event_location ((GdkEventButton *)ev);
queue_tooltip_update (out);
return FALSE;
}
static gboolean gx_knob_pointer_motion(GtkWidget *widget, GdkEventMotion *event)
{
g_assert(GX_IS_KNOB(widget));
if (!gtk_widget_has_grab(widget)) {
return FALSE;
}
gdk_event_request_motions (event);
_gx_knob_pointer_event(widget, event->x, event->y, get_stock_id(widget), TRUE, event->state, 0, NULL);
return FALSE;
}
static gboolean
gtk_shruler_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
GtkSHRuler *ruler = GTK_SHRULER (widget);
gdk_event_request_motions (event);
gtk_shruler_update_position (ruler, event->x, event->y);
return FALSE;
}
static gboolean
cb_treeview_motion (GtkWidget *widget,
GdkEventMotion *event,
StfDialogData *pagedata)
{
int x = (int)event->x;
int col, dx;
RenderData_t *renderdata = pagedata->fixed.renderdata;
int old_ruler_x = pagedata->fixed.ruler_x;
int colstart, colend, colwidth;
gpointer user;
pagedata->fixed.ruler_x = -1;
/* We get events from the buttons too. Translate x. */
gdk_window_get_user_data (event->window, &user);
if (GTK_IS_BUTTON (user)) {
int ewx;
gdk_window_get_position (event->window, &ewx, NULL);
x += ewx;
}
stf_preview_find_column (renderdata, x, &col, &dx);
colstart = (col == 0)
? 0
: stf_parse_options_fixed_splitpositions_nth (pagedata->parseoptions, col - 1);
colend = stf_parse_options_fixed_splitpositions_nth (pagedata->parseoptions, col);
colwidth = (colend == -1) ? G_MAXINT : colend - colstart;
if (col >= 0 && col < renderdata->colcount) {
int ci = calc_char_index (renderdata, col, &dx);
if (ci <= colwidth) {
int padx;
GtkCellRenderer *cell =
stf_preview_get_cell_renderer (renderdata, col);
gtk_cell_renderer_get_padding (cell, &padx, NULL);
pagedata->fixed.ruler_x = x - dx + padx;
}
}
gdk_event_request_motions (event);
if (pagedata->fixed.ruler_x == old_ruler_x)
return FALSE;
queue_redraw (widget, old_ruler_x);
queue_redraw (widget, pagedata->fixed.ruler_x);
return FALSE;
}
bool Liveplay::pointer_motion(GdkEventMotion* event) {
if (event) {
gdk_event_request_motions(event);
}
if (mouse_hide_conn.connected()) {
mouse_hide_conn.disconnect();
} else {
window->get_window()->set_cursor();
}
mouse_hide_conn = Glib::signal_timeout().connect_seconds(
sigc::bind_return(
sigc::bind(
sigc::mem_fun1(window->get_window().operator->(), &Gdk::Window::set_cursor),
Gdk::Cursor(Gdk::BLANK_CURSOR)),
false),
5);
return false;
}
gboolean
rcm_motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
RcmCircle *circle)
{
gfloat clicked_angle, delta;
clicked_angle = angle_mod_2PI (arctg (CENTER - event->y, event->x - CENTER));
delta = clicked_angle - circle->prev_clicked;
circle->prev_clicked = clicked_angle;
if (delta)
{
if (circle->mode == EACH)
{
*(circle->target) = clicked_angle;
}
else
{
circle->angle->alpha = angle_mod_2PI (circle->angle->alpha + delta);
circle->angle->beta = angle_mod_2PI (circle->angle->beta + delta);
}
gtk_widget_queue_draw (widget);
gdk_window_process_updates (gtk_widget_get_window (widget), FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->alpha_entry),
circle->angle->alpha *
rcm_units_factor(Current.Units));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->beta_entry),
circle->angle->beta *
rcm_units_factor(Current.Units));
if (Current.RealTime)
rcm_render_preview (Current.Bna->after);
}
gdk_event_request_motions (event);
return TRUE;
}
static gboolean
nova_center_preview_events (GtkWidget *widget,
GdkEvent *event,
NovaCenter *center)
{
switch (event->type)
{
case GDK_MOTION_NOTIFY:
{
GdkEventMotion *mevent = (GdkEventMotion *) event;
if (mevent->state & GDK_BUTTON1_MASK)
{
nova_center_update (widget, center, mevent->x, mevent->y);
gdk_event_request_motions (mevent);
return TRUE;
}
}
break;
case GDK_BUTTON_PRESS:
{
GdkEventButton *bevent = (GdkEventButton *) event;
if (bevent->button == 1)
{
nova_center_update (widget, center, bevent->x, bevent->y);
return TRUE;
}
}
break;
default:
break;
}
return FALSE;
}
static gint
gd_tagged_entry_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
GdTaggedEntry *self = GD_TAGGED_ENTRY (widget);
GdTaggedEntryTag *tag;
tag = gd_tagged_entry_find_tag_by_window (self, event->window);
if (tag != NULL)
{
gdk_event_request_motions (event);
self->in_child = tag;
self->in_child_button = gd_tagged_entry_tag_event_is_button (tag, self, event->x, event->y);
gtk_widget_queue_draw (widget);
return FALSE;
}
return GTK_WIDGET_CLASS (gd_tagged_entry_parent_class)->motion_notify_event (widget, event);
}
static gboolean
gimp_scrolled_preview_area_event (GtkWidget *area,
GdkEvent *event,
GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview);
GdkEventButton *button_event = (GdkEventButton *) event;
GdkCursor *cursor;
switch (event->type)
{
case GDK_BUTTON_PRESS:
switch (button_event->button)
{
case 1:
case 2:
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (area),
GDK_FLEUR);
if (gdk_pointer_grab (gtk_widget_get_window (area), TRUE,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK,
NULL, cursor,
gdk_event_get_time (event)) == GDK_GRAB_SUCCESS)
{
gtk_widget_get_pointer (area, &priv->drag_x, &priv->drag_y);
priv->drag_xoff = GIMP_PREVIEW (preview)->xoff;
priv->drag_yoff = GIMP_PREVIEW (preview)->yoff;
priv->in_drag = TRUE;
gtk_grab_add (area);
}
gdk_cursor_unref (cursor);
break;
case 3:
return TRUE;
}
break;
case GDK_BUTTON_RELEASE:
if (priv->in_drag &&
(button_event->button == 1 || button_event->button == 2))
{
gdk_display_pointer_ungrab (gtk_widget_get_display (area),
gdk_event_get_time (event));
gtk_grab_remove (area);
priv->in_drag = FALSE;
}
break;
case GDK_MOTION_NOTIFY:
if (priv->in_drag)
{
GdkEventMotion *mevent = (GdkEventMotion *) event;
GtkAdjustment *hadj;
GtkAdjustment *vadj;
gint x, y;
hadj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
vadj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
gtk_widget_get_pointer (area, &x, &y);
x = priv->drag_xoff - (x - priv->drag_x);
y = priv->drag_yoff - (y - priv->drag_y);
x = CLAMP (x,
gtk_adjustment_get_lower (hadj),
gtk_adjustment_get_upper (hadj) -
gtk_adjustment_get_page_size (hadj));
y = CLAMP (y,
gtk_adjustment_get_lower (vadj),
gtk_adjustment_get_upper (vadj) -
gtk_adjustment_get_page_size (vadj));
if (GIMP_PREVIEW (preview)->xoff != x ||
GIMP_PREVIEW (preview)->yoff != y)
{
gtk_adjustment_set_value (hadj, x);
gtk_adjustment_set_value (vadj, y);
gimp_preview_draw (GIMP_PREVIEW (preview));
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
gdk_event_request_motions (mevent);
}
break;
case GDK_SCROLL:
{
GdkEventScroll *sevent = (GdkEventScroll *) event;
GdkScrollDirection direction = sevent->direction;
GtkAdjustment *adj;
gfloat value;
/* Ctrl-Scroll is reserved for zooming */
if (sevent->state & GDK_CONTROL_MASK)
return FALSE;
if (sevent->state & GDK_SHIFT_MASK)
switch (direction)
{
case GDK_SCROLL_UP: direction = GDK_SCROLL_LEFT; break;
case GDK_SCROLL_DOWN: direction = GDK_SCROLL_RIGHT; break;
case GDK_SCROLL_LEFT: direction = GDK_SCROLL_UP; break;
case GDK_SCROLL_RIGHT: direction = GDK_SCROLL_DOWN; break;
}
switch (direction)
{
case GDK_SCROLL_UP:
case GDK_SCROLL_DOWN:
default:
adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
break;
case GDK_SCROLL_RIGHT:
case GDK_SCROLL_LEFT:
adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
break;
}
value = gtk_adjustment_get_value (adj);
switch (direction)
{
case GDK_SCROLL_UP:
case GDK_SCROLL_LEFT:
value -= gtk_adjustment_get_page_increment (adj) / 2;
break;
case GDK_SCROLL_DOWN:
case GDK_SCROLL_RIGHT:
value += gtk_adjustment_get_page_increment (adj) / 2;
break;
}
gtk_adjustment_set_value (adj,
CLAMP (value,
gtk_adjustment_get_lower (adj),
gtk_adjustment_get_upper (adj) -
gtk_adjustment_get_page_size (adj)));
}
break;
default:
break;
}
return FALSE;
}
static VALUE
gdkeventmotion_request_motions(VALUE self)
{
gdk_event_request_motions(&(RVAL2GDKEVENT(self)->motion));
return self;
}
gboolean
rcm_motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
RcmCircle *circle)
{
gfloat clicked_angle, delta;
gfloat *alpha, *beta;
gint cw_ccw;
GdkGCValues values;
alpha = &(circle->angle->alpha);
beta = &(circle->angle->beta);
cw_ccw = circle->angle->cw_ccw;
delta = angle_mod_2PI (cw_ccw * (*beta - *alpha));
values.function = GDK_INVERT;
xor_gc = gdk_gc_new_with_values (Current.From->preview->window,
&values,
GDK_GC_FUNCTION);
clicked_angle = angle_mod_2PI (arctg (CENTER - event->y, event->x - CENTER));
delta = clicked_angle - circle->prev_clicked;
circle->prev_clicked = clicked_angle;
if (delta)
{
if (circle->action_flag == DRAG_START)
{
gtk_widget_queue_draw (circle->preview);
circle->action_flag = DRAGING;
}
else
{
/* this should be erasing entire angle */
color_rotate_draw_arrows (widget->window, xor_gc, circle->angle);
}
if (circle->mode == EACH)
{
*(circle->target)=clicked_angle;
}
else
{
circle->angle->alpha=angle_mod_2PI(circle->angle->alpha + delta);
circle->angle->beta =angle_mod_2PI(circle->angle->beta + delta);
}
gdk_window_process_updates (widget->window, FALSE);
color_rotate_draw_arrows (widget->window, xor_gc, circle->angle);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->alpha_entry),
circle->angle->alpha *
rcm_units_factor(Current.Units));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->beta_entry),
circle->angle->beta *
rcm_units_factor(Current.Units));
if (Current.RealTime)
rcm_render_preview (Current.Bna->after);
}
gdk_event_request_motions (event);
return TRUE;
}
static gboolean
gimp_scrolled_preview_nav_popup_event (GtkWidget *widget,
GdkEvent *event,
GimpScrolledPreview *preview)
{
switch (event->type)
{
case GDK_BUTTON_RELEASE:
{
GdkEventButton *button_event = (GdkEventButton *) event;
if (button_event->button == 1)
{
gtk_grab_remove (widget);
gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
button_event->time);
gtk_widget_destroy (preview->nav_popup);
preview->nav_popup = NULL;
}
}
break;
case GDK_MOTION_NOTIFY:
{
GdkEventMotion *mevent = (GdkEventMotion *) event;
GtkAdjustment *hadj;
GtkAdjustment *vadj;
GtkAllocation allocation;
gint cx, cy;
gdouble x, y;
hadj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
vadj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
gtk_widget_get_allocation (widget, &allocation);
gtk_widget_get_pointer (widget, &cx, &cy);
x = cx * (gtk_adjustment_get_upper (hadj) -
gtk_adjustment_get_lower (hadj)) / allocation.width;
y = cy * (gtk_adjustment_get_upper (vadj) -
gtk_adjustment_get_lower (vadj)) / allocation.height;
x += (gtk_adjustment_get_lower (hadj) -
gtk_adjustment_get_page_size (hadj) / 2);
y += (gtk_adjustment_get_lower (vadj) -
gtk_adjustment_get_page_size (vadj) / 2);
gtk_adjustment_set_value (hadj,
CLAMP (x,
gtk_adjustment_get_lower (hadj),
gtk_adjustment_get_upper (hadj) -
gtk_adjustment_get_page_size (hadj)));
gtk_adjustment_set_value (vadj,
CLAMP (y,
gtk_adjustment_get_lower (vadj),
gtk_adjustment_get_upper (vadj) -
gtk_adjustment_get_page_size (vadj)));
gtk_widget_queue_draw (widget);
gdk_window_process_updates (gtk_widget_get_window (widget), FALSE);
gdk_event_request_motions (mevent);
}
break;
default:
break;
}
return FALSE;
}
static VALUE
gdkeventmotion_request_motions(VALUE self)
{
gdk_event_request_motions(&(get_gdkevent(self)->motion));
return self;
}
static gboolean
motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
ColorselWater *water)
{
GtkAllocation allocation;
GdkTimeCoord **coords;
gint nevents;
gint i;
gboolean erase;
gtk_widget_get_allocation (widget, &allocation);
if (event->state & (GDK_BUTTON1_MASK |
GDK_BUTTON2_MASK |
GDK_BUTTON3_MASK |
GDK_BUTTON4_MASK))
{
guint32 last_motion_time = event->time;
erase = ((event->state &
(GDK_BUTTON2_MASK | GDK_BUTTON3_MASK | GDK_BUTTON4_MASK)) ||
FALSE);
/* FIXME: (event->source == GDK_SOURCE_ERASER) */
if (event->state & GDK_SHIFT_MASK)
erase = !erase;
water->motion_time = event->time;
if (gdk_device_get_history (event->device,
event->window,
last_motion_time,
event->time,
&coords,
&nevents))
{
for (i = 0; i < nevents; i++)
{
gdouble x = 0.0;
gdouble y = 0.0;
gdouble pressure = 0.5;
gdk_device_get_axis (event->device, coords[i]->axes,
GDK_AXIS_X, &x);
gdk_device_get_axis (event->device, coords[i]->axes,
GDK_AXIS_Y, &y);
gdk_device_get_axis (event->device, coords[i]->axes,
GDK_AXIS_PRESSURE, &pressure);
draw_brush (water, widget, erase,
x / allocation.width,
y / allocation.height, pressure);
}
g_free (coords);
}
else
{
gdouble pressure = 0.5;
gdk_event_get_axis ((GdkEvent *) event, GDK_AXIS_PRESSURE, &pressure);
draw_brush (water, widget, erase,
event->x / allocation.width,
event->y / allocation.height, pressure);
}
}
/* Ask for more motion events in case the event was a hint */
gdk_event_request_motions (event);
return TRUE;
}
void
_gtk_tooltip_handle_event (GdkEvent *event)
{
gint x, y;
gboolean return_value = FALSE;
GtkWidget *has_tooltip_widget = NULL;
GdkDisplay *display;
GtkTooltip *current_tooltip;
if (!tooltips_enabled (event))
return;
/* Returns coordinates relative to has_tooltip_widget's allocation. */
has_tooltip_widget = find_topmost_widget_coords_from_event (event, &x, &y);
display = gdk_window_get_display (event->any.window);
current_tooltip = g_object_get_data (G_OBJECT (display),
"gdk-display-current-tooltip");
if (current_tooltip)
{
gtk_tooltip_set_last_window (current_tooltip, event->any.window);
}
if (current_tooltip && current_tooltip->keyboard_mode_enabled)
{
has_tooltip_widget = current_tooltip->keyboard_widget;
if (!has_tooltip_widget)
return;
return_value = gtk_tooltip_run_requery (&has_tooltip_widget,
current_tooltip,
&x, &y);
if (!return_value)
gtk_tooltip_hide_tooltip (current_tooltip);
else
gtk_tooltip_start_delay (display);
return;
}
#ifdef DEBUG_TOOLTIP
if (has_tooltip_widget)
g_print ("%p (%s) at (%d, %d) %dx%d pointer: (%d, %d)\n",
has_tooltip_widget, gtk_widget_get_name (has_tooltip_widget),
has_tooltip_widget->allocation.x,
has_tooltip_widget->allocation.y,
has_tooltip_widget->allocation.width,
has_tooltip_widget->allocation.height,
x, y);
#endif /* DEBUG_TOOLTIP */
/* Always poll for a next motion event */
gdk_event_request_motions (&event->motion);
/* Hide the tooltip when there's no new tooltip widget */
if (!has_tooltip_widget)
{
if (current_tooltip)
gtk_tooltip_hide_tooltip (current_tooltip);
return;
}
switch (event->type)
{
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
case GDK_KEY_PRESS:
case GDK_DRAG_ENTER:
case GDK_GRAB_BROKEN:
case GDK_SCROLL:
gtk_tooltip_hide_tooltip (current_tooltip);
break;
case GDK_MOTION_NOTIFY:
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY:
if (current_tooltip)
{
gboolean tip_area_set;
GdkRectangle tip_area;
gboolean hide_tooltip;
tip_area_set = current_tooltip->tip_area_set;
tip_area = current_tooltip->tip_area;
return_value = gtk_tooltip_run_requery (&has_tooltip_widget,
current_tooltip,
&x, &y);
/* Requested to be hidden? */
hide_tooltip = !return_value;
/* Leave notify should override the query function */
hide_tooltip = (event->type == GDK_LEAVE_NOTIFY);
/* Is the pointer above another widget now? */
if (GTK_TOOLTIP_VISIBLE (current_tooltip))
hide_tooltip |= has_tooltip_widget != current_tooltip->tooltip_widget;
/* Did the pointer move out of the previous "context area"? */
if (tip_area_set)
hide_tooltip |= (x <= tip_area.x
|| x >= tip_area.x + tip_area.width
|| y <= tip_area.y
|| y >= tip_area.y + tip_area.height);
if (hide_tooltip)
gtk_tooltip_hide_tooltip (current_tooltip);
else
gtk_tooltip_start_delay (display);
}
else
{
/* Need a new tooltip for this display */
current_tooltip = g_object_new (GTK_TYPE_TOOLTIP, NULL);
g_object_set_data_full (G_OBJECT (display),
"gdk-display-current-tooltip",
current_tooltip, g_object_unref);
g_signal_connect (display, "closed",
G_CALLBACK (gtk_tooltip_display_closed),
current_tooltip);
gtk_tooltip_set_last_window (current_tooltip, event->any.window);
gtk_tooltip_start_delay (display);
}
break;
default:
break;
}
}
