static void button_press( GtkWidget *widget, GdkEventButton *event, gpointer data ){
GLWindow *wnd = (GLWindow*)data;
guint32 flags = 0;
gdk_pointer_grab( gtk_widget_get_window( widget ), FALSE,
(GdkEventMask)( GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK ),
NULL, NULL, GDK_CURRENT_TIME );
gtk_window_set_focus( GTK_WINDOW( g_pParentWnd->m_pWidget ), widget );
switch ( event->button )
{
case 1: flags |= MK_LBUTTON; break;
case 2: flags |= MK_MBUTTON; break;
case 3: flags |= MK_RBUTTON; break;
#if !GTK_CHECK_VERSION( 1,3,0 )
case 4: wnd->OnMouseWheel( true, (int)event->x, (int)event->y ); break;
case 5: wnd->OnMouseWheel( false, (int)event->x, (int)event->y ); break;
#endif
}
if ( ( event->state & GDK_CONTROL_MASK ) != 0 ) {
flags |= MK_CONTROL;
}
if ( ( event->state & GDK_SHIFT_MASK ) != 0 ) {
flags |= MK_SHIFT;
}
if ( event->type == GDK_BUTTON_PRESS ) {
switch ( event->button )
{
case 1:
wnd->OnLButtonDown( flags, (int)event->x, (int)event->y ); break;
case 2:
wnd->OnMButtonDown( flags, (int)event->x, (int)event->y ); break;
case 3:
wnd->OnRButtonDown( flags, (int)event->x, (int)event->y ); break;
}
}
else if ( event->type == GDK_2BUTTON_PRESS ) {
// do nothing
}
}
void eplay_load_image()
{
if (im) {
gdk_imlib_kill_image(im);
im = NULL;
}
if(!p[image_idx]) {
im = gdk_imlib_load_image(image_names[image_idx]);
}
if (first) {
w = org_w = im->rgb_width;
h = org_h = im->rgb_height;
win_x = (screen_x - w) / 2;
win_y = (screen_y - h) / 2;
attr.window_type = GDK_WINDOW_TEMP;
attr.wclass = GDK_INPUT_OUTPUT;
attr.event_mask = GDK_ALL_EVENTS_MASK;
attr.x = attr.y = 0;
attr.width = screen_x;
attr.height = screen_y;
parent = NULL;
win = gdk_window_new(parent, &attr, ATTRIBUTES_MASK);
gdk_window_show(win);
gc = gdk_gc_new(win);
first = 0;
gdk_window_set_background(win, &color_bg);
gdk_keyboard_grab(win, FALSE, CurrentTime);
gdk_pointer_grab(win, FALSE, event_mask, NULL, cursor, CurrentTime);
gdk_window_set_hints(win, win_x, win_y, w, h, w, h, GDK_HINT_MIN_SIZE |
GDK_HINT_MAX_SIZE | GDK_HINT_POS);
}
/* gdk_imlib_free_pixmap(p[image_idx]); */ /* killing old pixmap */
if(!p[image_idx]) {
gdk_imlib_render(im, w, h); /* Imlib render ... */
p[image_idx] = gdk_imlib_move_image(im); /* creating new */
}
gdk_draw_pixmap(win, gc, p[image_idx], 0, 0, win_x, win_y, w, h);
gdk_window_show(win); /* display image */
}
static int
gs_grab_get_mouse (GSGrab *grab,
GdkWindow *window,
GdkScreen *screen,
gboolean hide_cursor)
{
GdkGrabStatus status;
GdkCursor *cursor;
g_return_val_if_fail (window != NULL, FALSE);
g_return_val_if_fail (screen != NULL, FALSE);
#if GTK_CHECK_VERSION (3, 0, 0)
cursor = gdk_cursor_new (GDK_BLANK_CURSOR);
#else
cursor = get_cursor ();
#endif
gs_debug ("Grabbing mouse widget=%X", (guint32) GDK_WINDOW_XID (window));
status = gdk_pointer_grab (window, TRUE, 0, NULL,
(hide_cursor ? cursor : NULL),
GDK_CURRENT_TIME);
if (status == GDK_GRAB_SUCCESS)
{
if (grab->priv->mouse_grab_window != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window),
(gpointer *) &grab->priv->mouse_grab_window);
}
grab->priv->mouse_grab_window = window;
g_object_add_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window),
(gpointer *) &grab->priv->mouse_grab_window);
grab->priv->mouse_grab_screen = screen;
grab->priv->mouse_hide_cursor = hide_cursor;
}
gdk_cursor_unref (cursor);
return status;
}
static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *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;
GtkPizza *pizza = GTK_PIZZA(widget);
if (gdk_event->window != pizza->bin_window) return TRUE;
wxClientDC dc(win);
dc.SetFont( *wxSMALL_FONT );
int height = dc.GetCharHeight() + 1;
if (gdk_event->y > height) return TRUE;
gdk_window_raise( win->m_widget->window );
gdk_pointer_grab( widget->window, FALSE,
(GdkEventMask)
(GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON1_MOTION_MASK),
NULL,
NULL,
(unsigned int) GDK_CURRENT_TIME );
win->m_diffX = (int)gdk_event->x;
win->m_diffY = (int)gdk_event->y;
DrawFrame( widget, 0, 0, win->m_width, win->m_height );
win->m_oldX = 0;
win->m_oldY = 0;
win->m_isDragging = true;
return TRUE;
}
static gboolean
gcrd_grab_on_window (GdkWindow *window,
guint32 activate_time)
{
if ((gdk_pointer_grab (window, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
NULL, NULL, activate_time) == 0)) {
if (gdk_keyboard_grab (window, TRUE,
activate_time) == 0)
return TRUE;
else {
gdk_pointer_ungrab (activate_time);
return FALSE;
}
}
return FALSE;
}
static void
gtk_combo_button_popup_display (GtkComboButton * combo_button)
{
gint height, width, x, y;
gtk_combo_button_get_pos (combo_button, &x, &y, &height, &width);
gtk_window_move(GTK_WINDOW(combo_button->popwin), x, y);
gtk_widget_set_usize (combo_button->popwin, width, height);
gtk_widget_show (combo_button->popwin);
gtk_grab_add (combo_button->popwin);
gdk_pointer_grab (combo_button->popwin->window, TRUE,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
NULL, NULL, GDK_CURRENT_TIME);
}
gint switch_fullscreen(GtkWidget *gl_area)
{
static GtkWidget *fullscreenwidget = NULL;
if (!fullscreenwidget)
{
/* Grab keyboard and pointer so that user does not wander off the game
window while in fullscreen mode.
*/
if (gdk_keyboard_grab(gl_area->window, FALSE, GDK_CURRENT_TIME) == 0)
{
if (gdk_pointer_grab(gl_area->window, FALSE, 0, NULL, NULL, GDK_CURRENT_TIME) == 0)
{
gtk_widget_grab_focus(gl_area);
if (gtk_gl_area_make_current(GTK_GL_AREA(gl_area)))
{
if (XMesaSetFXmode((XMESA_FX_FULLSCREEN)))
{
fullscreenwidget = gl_area;
return TRUE;
}
}
gdk_pointer_ungrab(GDK_CURRENT_TIME);
}
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
}
return FALSE;
}
if (fullscreenwidget == gl_area)
{
if (gtk_gl_area_make_current(GTK_GL_AREA(gl_area)))
XMesaSetFXmode(XMESA_FX_WINDOW);
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
gdk_pointer_ungrab(GDK_CURRENT_TIME);
fullscreenwidget = NULL;
return TRUE;
}
return FALSE;
}
/**
* Handles the 'activate' signal on the tray_icon,
* usually opening the popup_window and grabbing pointer and keyboard.
*
* @param status_icon the object which received the signal
* @param user_data user data set when the signal handler was connected
*/
void
tray_icon_on_click(G_GNUC_UNUSED GtkStatusIcon *status_icon,
G_GNUC_UNUSED gpointer user_data)
{
get_current_levels();
if (!gtk_widget_get_visible(GTK_WIDGET(popup_window))) {
gtk_widget_show_now(popup_window);
gtk_widget_grab_focus(vol_scale);
#ifdef WITH_GTK3
GdkDevice *pointer_dev = gtk_get_current_event_device();
if (pointer_dev != NULL) {
GdkDevice *keyboard_dev =
gdk_device_get_associated_device(pointer_dev);
if (gdk_device_grab(pointer_dev,
gtk_widget_get_window(GTK_WIDGET(popup_window)),
GDK_OWNERSHIP_NONE,
TRUE,
GDK_BUTTON_PRESS_MASK,
NULL, GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
g_warning("Could not grab %s\n",
gdk_device_get_name(pointer_dev));
if (keyboard_dev != NULL) {
if (gdk_device_grab(keyboard_dev,
gtk_widget_get_window(GTK_WIDGET(popup_window)),
GDK_OWNERSHIP_NONE,
TRUE,
GDK_KEY_PRESS_MASK,
NULL, GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
g_warning("Could not grab %s\n",
gdk_device_get_name(keyboard_dev));
}
}
#else
gdk_keyboard_grab(gtk_widget_get_window(popup_window),
TRUE, GDK_CURRENT_TIME);
gdk_pointer_grab(gtk_widget_get_window(popup_window), TRUE,
GDK_BUTTON_PRESS_MASK, NULL, NULL, GDK_CURRENT_TIME);
#endif
} else {
gtk_widget_hide(popup_window);
}
}
static void
gtk_combo_popup_button_press (GtkWidget *button,
GdkEventButton *event,
GtkCombo *combo)
{
if (!GTK_WIDGET_HAS_FOCUS (combo->entry))
gtk_widget_grab_focus (combo->entry);
if (!combo->current_button && (event->button == 1))
gtk_combo_popup_list (combo);
combo->current_button = event->button;
GTK_LIST (combo->list)->drag_selection = TRUE;
gdk_pointer_grab (combo->list->window, TRUE,
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK,
NULL, NULL, event->time);
gtk_grab_add (combo->list);
}
void
uni_nav_grab (UniNav * nav)
{
GtkWidget *preview = nav->preview;
GdkWindow *window;
gtk_grab_add (preview);
GdkCursor *cursor = gdk_cursor_new (GDK_FLEUR);
int mask = (GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_BUTTON_RELEASE_MASK | GDK_EXTENSION_EVENTS_ALL);
window = gtk_widget_get_window (preview);
gdk_pointer_grab (window, TRUE, mask, window, cursor, 0);
gdk_cursor_unref (cursor);
/* Capture keyboard events. */
gdk_keyboard_grab (window, TRUE, GDK_CURRENT_TIME);
gtk_widget_grab_focus (preview);
}
/* protected */ void
go_combo_box_popup_display (GOComboBox *combo_box)
{
int x, y;
g_return_if_fail (GO_COMBO_BOX (combo_box) != NULL);
g_return_if_fail (combo_box->priv->popdown_container != NULL);
if (combo_box->priv->torn_off) {
/* To give the illusion that tearoff still displays the
* popup, we copy the image in the popup window to the
* background. Thus, it won't be blank after reparenting */
go_combo_tearoff_bg_copy (combo_box);
/* We force an unrealize here so that we don't trigger
* redrawing/ clearing code - we just want to reveal our
* backing pixmap.
*/
go_combo_popup_reparent (combo_box->priv->popup,
combo_box->priv->toplevel, TRUE);
}
go_combo_box_get_pos (combo_box, &x, &y);
gtk_window_move (GTK_WINDOW (combo_box->priv->toplevel), x, y);
gtk_widget_realize (combo_box->priv->popup);
gtk_widget_show (combo_box->priv->popup);
gtk_widget_realize (combo_box->priv->toplevel);
gtk_widget_show (combo_box->priv->toplevel);
gtk_widget_grab_focus (combo_box->priv->toplevel);
do_focus_change (combo_box->priv->toplevel, TRUE);
gtk_grab_add (combo_box->priv->toplevel);
gdk_pointer_grab (combo_box->priv->toplevel->window, TRUE,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
NULL, NULL, GDK_CURRENT_TIME);
set_arrow_state (combo_box, TRUE);
}
static void
gimp_popup_map (GtkWidget *widget)
{
GTK_WIDGET_CLASS (parent_class)->map (widget);
/* grab with owner_events == TRUE so the popup's widgets can
* receive events. we filter away events outside this toplevel
* away in button_press()
*/
if (gdk_pointer_grab (gtk_widget_get_window (widget), TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
NULL, NULL, GDK_CURRENT_TIME) == 0)
{
if (gdk_keyboard_grab (gtk_widget_get_window (widget), TRUE,
GDK_CURRENT_TIME) == 0)
{
gtk_grab_add (widget);
g_signal_connect (widget, "grab-notify",
G_CALLBACK (gimp_popup_grab_notify),
widget);
g_signal_connect (widget, "grab-broken-event",
G_CALLBACK (gimp_popup_grab_broken_event),
widget);
return;
}
else
{
gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
GDK_CURRENT_TIME);
}
}
/* if we could not grab, destroy the popup instead of leaving it
* around uncloseable.
*/
g_signal_emit (widget, popup_signals[CANCEL], 0);
}
static void
begin_area_grab (void)
{
if (grab_widget == NULL)
{
grab_widget = gtk_invisible_new ();
gtk_widget_add_events (grab_widget,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
gtk_widget_show (grab_widget);
}
if (gdk_keyboard_grab (gtk_widget_get_window (grab_widget),
FALSE,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
g_warning ("Failed to grab keyboard to do eyedropper");
return;
}
if (gdk_pointer_grab (gtk_widget_get_window (grab_widget),
FALSE,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
NULL,
NULL,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
g_warning ("Failed to grab pointer to do eyedropper");
return;
}
gtk_grab_add (grab_widget);
g_signal_connect (grab_widget, "button_press_event",
G_CALLBACK (mouse_press), NULL);
g_signal_connect (grab_widget, "key_press_event",
G_CALLBACK (key_press), NULL);
}
/* Grabs the pointer (usually a mouse) so that all events are passed to this
* application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
* the grab window becomes unviewable. This overrides any previous pointer
* grab by this client.
* Pointer grabs are used for operations which need complete control over mouse
* events, even if the mouse leaves the application. For example in GTK+ it is
* used for Drag and Drop, for dragging the handle in the GtkHPaned and GtkVPaned
* widgets, and for resizing columns in GtkCList widgets.
* Note that if the event mask of an X window has selected both button press and
* button release events, then a button press event will cause an automatic pointer
* grab until the button is released. X does this automatically since most
* applications expect to receive button press and release events in pairs.
* It is equivalent to a pointer grab on the window with owner_events set to TRUE. */
int
clip_GDK_POINTERGRAB(ClipMachine * ClipMachineMemory)
{
C_widget *cwin = _fetch_cw_arg(ClipMachineMemory);
GdkWindow *win = NULL;
gboolean owner_events = _clip_parl(ClipMachineMemory, 2);
GdkEventMask event_mask = _clip_parnl(ClipMachineMemory, 3);
C_widget *cconfine_to = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 4));
GdkWindow *confine_to = NULL;
C_object *ccursor = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 5));
GdkCursor *cursor = NULL;
CHECKCWID(cwin, GTK_IS_WIDGET);
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
CHECKOPT2(4, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cwin, GTK_IS_WIDGET);
CHECKOPT2(5, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJOPT(ccursor, GDK_IS_CURSOR(ccursor));
if (cwin && cwin->widget)
win = cwin->widget->window;
if (cconfine_to && cconfine_to->widget)
confine_to = cconfine_to->widget->window;
if (ccursor)
cursor = GDK_CURSOR(ccursor->object);
_clip_retni(ClipMachineMemory, gdk_pointer_grab(win, owner_events, event_mask, confine_to, cursor, GDK_CURRENT_TIME));
return 0;
err:
return 1;
}
static void
dwell_start_gesture (MTClosure *mt)
{
GdkCursor *cursor;
GdkWindow *root;
if (mt->override_cursor) {
cursor = gdk_cursor_new (GDK_CROSS);
root = gdk_screen_get_root_window (mt_main_current_screen (mt));
gdk_pointer_grab (root, FALSE,
GDK_POINTER_MOTION_MASK,
NULL, cursor,
gtk_get_current_event_time ());
gdk_cursor_unref (cursor);
}
else {
mt_main_set_cursor (mt, GDK_CROSS);
}
mt->dwell_gesture_started = TRUE;
mt_timer_start (mt->dwell_timer);
}
static gboolean
popup_grab_on_window (GdkWindow *window,
guint32 activate_time)
{
GdkEventMask emask = static_cast<GdkEventMask>(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_ENTER_NOTIFY_MASK) ;
if ((gdk_pointer_grab (window, FALSE,emask,
NULL, NULL, activate_time) == 0))
{
if (gdk_keyboard_grab (window, FALSE,
activate_time) == 0)
return TRUE;
else
{
gdk_pointer_ungrab (activate_time);
return FALSE;
}
}
return FALSE;
}
/*
grab pointer, set mouse pointer shape
called by: ui_check_mouse_cursor, ui_restore_mouse, x11ui_fullscreen
TODO: also route lightpen stuff through this function
*/
static void mouse_cursor_grab(int grab, GdkCursor *cursor)
{
#ifdef DEBUGNOMOUSEGRAB
DBG(("mouse_cursor_grab disabled (%d)", grab));
#else
GtkWidget *widget;
GdkWindow *window;
DBG(("mouse_cursor_grab (%d, was %d)", grab, mouse_grabbed));
if (mouse_grabbed) {
gdk_pointer_ungrab(GDK_CURRENT_TIME);
mouse_grabbed = 0;
}
if (grab) {
/*ui_dispatch_events();
gdk_flush();*/
widget = get_active_toplevel();
window = widget ? gtk_widget_get_window(widget) : NULL;
if ((widget == NULL) || (window == NULL)) {
log_error(ui_log, "mouse_cursor_grab: bad params");
return;
}
#ifdef DEBUGMOUSECURSOR
if (cursor == blankCursor) {
DBG(("mouse_cursor_grab blankCursor disabled"));
cursor = NULL;
}
#endif
gdk_pointer_grab(window, 1, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK, window, cursor, GDK_CURRENT_TIME);
mouse_grabbed = 1;
}
#endif
}
static int do_if_clicked_handle(DDisplay *ddisp, ModifyTool *tool,
Point *clickedpoint, GdkEventButton *event)
{
DiaObject *obj;
Handle *handle;
handle = NULL;
diagram_find_closest_handle(ddisp->diagram, &handle, &obj, clickedpoint);
if (handle_is_clicked(ddisp, handle, clickedpoint)) {
tool->state = STATE_MOVE_HANDLE;
tool->break_connections = TRUE;
tool->last_to = handle->pos;
tool->handle = handle;
tool->object = obj;
gdk_pointer_grab (gtk_widget_get_window(ddisp->canvas), FALSE,
GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
NULL, NULL, event->time);
tool->start_at = handle->pos;
tool->start_time = time_micro();
ddisplay_set_all_cursor_name (NULL, "move");
return TRUE;
}
return FALSE;
}
static gint button_press_event(GtkWidget *widget, GdkEventButton *event)
{
int num_traces_displayable;
int which;
int trwhich, trtarget;
GtkAdjustment *wadj;
Trptr t;
if((traces.total)&&(signalpixmap))
{
gdk_pointer_grab(widget->window, FALSE,
GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON1_MOTION_MASK | GDK_BUTTON3_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK, NULL, NULL, event->time);
num_traces_displayable=widget->allocation.height/(fontheight);
num_traces_displayable--; /* for the time trace that is always there */
which=(int)(event->y);
which=(which/fontheight)-1;
if((which>=traces.total)||(which>=num_traces_displayable)||(which<0))
{
if(dnd_state==0)cachedwhich=-1;
goto check_button_3; /* off in no man's land, but check 3rd anyways.. */
}
cachedwhich=which; /* cache for later fill in */
wadj=GTK_ADJUSTMENT(wave_vslider);
trtarget=((int)wadj->value)+which;
t=traces.first;
trwhich=0;
while(t)
{
if((trwhich<trtarget)&&(t->next))
{
trwhich++;
t=t->next;
}
else
{
break;
}
}
cachedtrace=t;
if((dnd_state==0)&&(event->button==1))
if(t)
{
int yval;
GtkAdjustment *hadj;
gint xsrc;
if((shift_click_trace)&&(event->state&GDK_SHIFT_MASK))
{
Trptr t2;
unsigned int f;
t2=shift_click_trace;
while(t2)
{
if(t2==t)
{
t2=shift_click_trace;
f=t2->flags&TR_HIGHLIGHT;
while(t2)
{
t2->flags = (t2->flags & (~TR_HIGHLIGHT)) | f;
if(t2==t) break;
t2=t2->prev;
}
goto resync_signalarea;
}
t2=t2->prev;
}
t2=shift_click_trace;
while(t2)
{
if(t2==t)
{
t2=shift_click_trace;
f=t2->flags&TR_HIGHLIGHT;
while(t2)
{
t2->flags = (t2->flags & (~TR_HIGHLIGHT)) | f;
if(t2==t) break;
t2=t2->next;
}
goto resync_signalarea;
}
t2=t2->next;
}
goto normal_button1_press; /* couldn't find original so make this original... */
resync_signalarea:
MaxSignalLength();
signalarea_configure_event(signalarea, NULL);
DEBUG(printf("Shift-Click in signalarea!\n"));
return(TRUE);
}
else
{
normal_button1_press:
hadj=GTK_ADJUSTMENT(signal_hslider);
xsrc=(gint)hadj->value;
shift_click_trace=t;
t->flags ^= TR_HIGHLIGHT;
cachedhiflag = t->flags & TR_HIGHLIGHT;
DEBUG(printf("Button pressed in signalarea at x: %d, y: %d row: %d\n",
(int)event->x, (int)event->y, which));
yval=RenderSig(t, which, 1);
gdk_draw_pixmap(signalarea->window, signalarea->style->fg_gc[GTK_WIDGET_STATE(signalarea)],
signalpixmap,
xsrc, yval,
0, yval,
signalarea->allocation.width, fontheight-1);
}
}
check_button_3:
if(event->button==3)
{
if(dnd_state==0)
{
if(CutBuffer())
{
char buf[32];
sprintf(buf,"Dragging %d trace%s.\n",traces.buffercount,traces.buffercount!=1?"s":"");
status_text(buf);
MaxSignalLength();
signalarea_configure_event(signalarea, NULL);
wavearea_configure_event(wavearea, NULL);
dnd_state=1;
}
}
}
}
return(TRUE);
}
/* This is a _horrible_ hack to have this here. This needs to be added to the
* GTK+ menuing code in some manner.
*/
static void
drag_end_menu_cb (GtkWidget *widget, GdkDragContext *context)
{
GtkWidget *xgrab_shell;
GtkWidget *parent;
/* Find the last viewable ancestor, and make an X grab on it
*/
parent = gtk_widget_get_parent (widget);
xgrab_shell = NULL;
/* FIXME: workaround for a possible gtk+ bug
* See bugs #92085(gtk+) and #91184(panel) for details.
*/
g_object_set (widget, "has-tooltip", TRUE, NULL);
while (parent)
{
gboolean viewable = TRUE;
GtkWidget *tmp = parent;
while (tmp)
{
if (!gtk_widget_get_mapped (tmp))
{
viewable = FALSE;
break;
}
tmp = gtk_widget_get_parent (tmp);
}
if (viewable)
xgrab_shell = parent;
#if GTK_CHECK_VERSION (3, 0, 0)
parent = gtk_menu_shell_get_parent_shell (GTK_MENU_SHELL (parent));
#else
parent = GTK_MENU_SHELL (parent)->parent_menu_shell;
#endif
}
if (xgrab_shell && !gtk_menu_get_tearoff_state (GTK_MENU(xgrab_shell)))
{
GdkWindow *window = gtk_widget_get_window (xgrab_shell);
GdkCursor *cursor = gdk_cursor_new (GDK_ARROW);
if ((gdk_pointer_grab (window, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_POINTER_MOTION_MASK,
NULL, cursor, GDK_CURRENT_TIME) == 0))
{
if (gdk_keyboard_grab (window, TRUE,
GDK_CURRENT_TIME) == 0)
{
/* FIXME fix for GTK3 */
#if !GTK_CHECK_VERSION (3, 0, 0)
GTK_MENU_SHELL (xgrab_shell)->have_xgrab = TRUE;
#endif
}
else
{
gdk_pointer_ungrab (GDK_CURRENT_TIME);
}
}
gdk_cursor_unref (cursor);
}
}
static GtkCellEditable *
gtk_cell_renderer_accel_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GtkCellRendererText *celltext;
GtkCellRendererAccel *accel;
GtkWidget *label;
GtkWidget *eventbox;
celltext = GTK_CELL_RENDERER_TEXT (cell);
accel = GTK_CELL_RENDERER_ACCEL (cell);
/* If the cell isn't editable we return NULL. */
if (celltext->editable == FALSE)
return NULL;
g_return_val_if_fail (widget->window != NULL, NULL);
if (gdk_keyboard_grab (widget->window, FALSE,
gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
return NULL;
if (gdk_pointer_grab (widget->window, FALSE,
GDK_BUTTON_PRESS_MASK,
NULL, NULL,
gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
{
gdk_display_keyboard_ungrab (gtk_widget_get_display (widget),
gdk_event_get_time (event));
return NULL;
}
accel->grab_widget = widget;
g_signal_connect (G_OBJECT (widget), "key-press-event",
G_CALLBACK (grab_key_callback),
accel);
eventbox = g_object_new (_gtk_cell_editable_event_box_get_type (), NULL);
accel->edit_widget = eventbox;
g_object_add_weak_pointer (G_OBJECT (accel->edit_widget),
(gpointer) &accel->edit_widget);
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL,
&widget->style->bg[GTK_STATE_SELECTED]);
gtk_widget_modify_fg (label, GTK_STATE_NORMAL,
&widget->style->fg[GTK_STATE_SELECTED]);
/* This label is displayed in a treeview cell displaying
* an accelerator when the cell is clicked to change the
* acelerator.
*/
gtk_label_set_text (GTK_LABEL (label), _("New accelerator..."));
gtk_container_add (GTK_CONTAINER (eventbox), label);
g_object_set_data_full (G_OBJECT (accel->edit_widget), "gtk-cell-renderer-text",
g_strdup (path), g_free);
gtk_widget_show_all (accel->edit_widget);
g_signal_connect (G_OBJECT (accel->edit_widget), "unrealize",
G_CALLBACK (ungrab_stuff), accel);
return GTK_CELL_EDITABLE (accel->edit_widget);
}
static gboolean
gtk_scale_popup (GtkWidget *widget,
GdkEvent *event,
guint32 time)
{
GtkScaleButton *button;
GtkScaleButtonPrivate *priv;
GtkAdjustment *adj;
gint x, y, m, dx, dy, sx, sy, startoff;
gdouble v;
GdkDisplay *display;
GdkScreen *screen;
button = GTK_SCALE_BUTTON (widget);
priv = button->priv;
adj = priv->adjustment;
display = gtk_widget_get_display (widget);
screen = gtk_widget_get_screen (widget);
/* position roughly */
gtk_window_set_screen (GTK_WINDOW (priv->dock), screen);
gdk_window_get_origin (widget->window, &x, &y);
x += widget->allocation.x;
y += widget->allocation.y;
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
gtk_window_move (GTK_WINDOW (priv->dock), x, y - (SCALE_SIZE / 2));
else
gtk_window_move (GTK_WINDOW (priv->dock), x - (SCALE_SIZE / 2), y);
gtk_widget_show_all (priv->dock);
gdk_window_get_origin (priv->dock->window, &dx, &dy);
dx += priv->dock->allocation.x;
dy += priv->dock->allocation.y;
gdk_window_get_origin (priv->scale->window, &sx, &sy);
sx += priv->scale->allocation.x;
sy += priv->scale->allocation.y;
priv->timeout = TRUE;
/* position (needs widget to be shown already) */
v = gtk_scale_button_get_value (button) / (adj->upper - adj->lower);
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
{
startoff = sy - dy;
x += (widget->allocation.width - priv->dock->allocation.width) / 2;
y -= startoff;
y -= GTK_RANGE (priv->scale)->min_slider_size / 2;
m = priv->scale->allocation.height -
GTK_RANGE (priv->scale)->min_slider_size;
y -= m * (1.0 - v);
}
else
{
startoff = sx - dx;
x -= startoff;
y += (widget->allocation.height - priv->dock->allocation.height) / 2;
x -= GTK_RANGE (priv->scale)->min_slider_size / 2;
m = priv->scale->allocation.width -
GTK_RANGE (priv->scale)->min_slider_size;
x -= m * v;
}
/* Make sure the dock stays inside the monitor */
if (event->type == GDK_BUTTON_PRESS)
{
int monitor;
GdkEventButton *button_event = (GdkEventButton *) event;
GdkRectangle rect;
GtkWidget *d;
d = GTK_WIDGET (priv->dock);
monitor = gdk_screen_get_monitor_at_point (screen,
button_event->x_root,
button_event->y_root);
gdk_screen_get_monitor_geometry (screen, monitor, &rect);
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
y += button_event->y;
else
x += button_event->x;
if (y < rect.y)
y = rect.y;
else if (y + d->allocation.height > rect.height + rect.y)
y = rect.y + rect.height - d->allocation.height;
if (x < rect.x)
x = rect.x;
else if (x + d->allocation.width > rect.width + rect.x)
x = rect.x + rect.width - d->allocation.width;
}
gtk_window_move (GTK_WINDOW (priv->dock), x, y);
if (event->type == GDK_BUTTON_PRESS)
GTK_WIDGET_CLASS (gtk_scale_button_parent_class)->button_press_event (widget, (GdkEventButton *) event);
/* grab focus */
gtk_grab_add (priv->dock);
if (gdk_pointer_grab (priv->dock->window, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK, NULL, NULL, time)
!= GDK_GRAB_SUCCESS)
{
gtk_grab_remove (priv->dock);
gtk_widget_hide (priv->dock);
return FALSE;
}
if (gdk_keyboard_grab (priv->dock->window, TRUE, time) != GDK_GRAB_SUCCESS)
{
gdk_display_pointer_ungrab (display, time);
gtk_grab_remove (priv->dock);
gtk_widget_hide (priv->dock);
return FALSE;
}
gtk_widget_grab_focus (priv->dock);
if (event->type == GDK_BUTTON_PRESS)
{
GdkEventButton *e;
GdkEventButton *button_event = (GdkEventButton *) event;
/* forward event to the slider */
e = (GdkEventButton *) gdk_event_copy ((GdkEvent *) event);
e->window = priv->scale->window;
/* position: the X position isn't relevant, halfway will work just fine.
* The vertical position should be *exactly* in the middle of the slider
* of the scale; if we don't do that correctly, it'll move from its current
* position, which means a position change on-click, which is bad.
*/
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
{
e->x = priv->scale->allocation.width / 2;
m = priv->scale->allocation.height -
GTK_RANGE (priv->scale)->min_slider_size;
e->y = ((1.0 - v) * m) + GTK_RANGE (priv->scale)->min_slider_size / 2;
}
else
{
e->y = priv->scale->allocation.height / 2;
m = priv->scale->allocation.width -
GTK_RANGE (priv->scale)->min_slider_size;
e->x = (v * m) + GTK_RANGE (priv->scale)->min_slider_size / 2;
}
gtk_widget_event (priv->scale, (GdkEvent *) e);
e->window = button_event->window;
gdk_event_free ((GdkEvent *) e);
}
gtk_widget_grab_focus (priv->scale);
priv->pop_time = time;
return TRUE;
}
void
panel_force_quit (GdkScreen *screen,
guint time)
{
GdkGrabStatus status;
GdkCursor *cross;
GtkWidget *popup;
GdkWindow *root;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkDisplay *display;
GdkDevice *pointer;
GdkDevice *keyboard;
GdkDeviceManager *device_manager;
#endif
popup = display_popup_window (screen);
root = gdk_screen_get_root_window (screen);
gdk_window_add_filter (root, (GdkFilterFunc) popup_filter, popup);
cross = gdk_cursor_new (GDK_CROSS);
#if GTK_CHECK_VERSION (3, 0, 0)
display = gdk_window_get_display (root);
device_manager = gdk_display_get_device_manager (display);
pointer = gdk_device_manager_get_client_pointer (device_manager);
keyboard = gdk_device_get_associated_device (pointer);
status = gdk_device_grab (pointer, root,
GDK_OWNERSHIP_NONE, FALSE,
GDK_BUTTON_PRESS_MASK,
cross, time);
g_object_unref (cross);
status = gdk_device_grab (keyboard, root,
GDK_OWNERSHIP_NONE, FALSE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL, time);
if (status != GDK_GRAB_SUCCESS) {
g_warning ("Pointer grab failed\n");
remove_popup (popup);
return;
}
#else
status = gdk_pointer_grab (root, FALSE, GDK_BUTTON_PRESS_MASK,
NULL, cross, time);
gdk_cursor_unref (cross);
if (status != GDK_GRAB_SUCCESS) {
g_warning ("Pointer grab failed\n");
remove_popup (popup);
return;
}
status = gdk_keyboard_grab (root, FALSE, time);
if (status != GDK_GRAB_SUCCESS) {
g_warning ("Keyboard grab failed\n");
remove_popup (popup);
return;
}
#endif
gdk_flush ();
}
static void
begin_area_grab (void)
{
#if GTK_CHECK_VERSION (3, 0, 0)
GdkWindow *window;
GdkDeviceManager *manager;
GdkDevice *device;
#endif
if (grab_widget == NULL)
{
grab_widget = gtk_invisible_new ();
gtk_widget_add_events (grab_widget,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
gtk_widget_show (grab_widget);
}
#if GTK_CHECK_VERSION (3, 0, 0)
window = gtk_widget_get_window (grab_widget);
manager = gdk_display_get_device_manager (gdk_display_get_default ());
device = gdk_device_manager_get_client_pointer (manager);
if (gdk_device_grab (device,
window,
GDK_OWNERSHIP_NONE,
FALSE,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
NULL,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
g_warning ("Failed to grab pointer to do eyedropper");
return;
}
if (gdk_device_grab (gdk_device_get_associated_device (device),
window,
GDK_OWNERSHIP_NONE,
FALSE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
gdk_device_ungrab (device, gtk_get_current_event_time ());
g_warning ("Failed to grab keyboard to do eyedropper");
return;
}
#else
if (gdk_keyboard_grab (gtk_widget_get_window (grab_widget),
FALSE,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
g_warning ("Failed to grab keyboard to do eyedropper");
return;
}
if (gdk_pointer_grab (gtk_widget_get_window (grab_widget),
FALSE,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
NULL,
NULL,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
g_warning ("Failed to grab pointer to do eyedropper");
return;
}
#endif
gtk_grab_add (grab_widget);
g_signal_connect (grab_widget, "button_press_event",
G_CALLBACK (mouse_press), NULL);
g_signal_connect (grab_widget, "key_press_event",
G_CALLBACK (key_press), NULL);
}
static gboolean
gtk_window_button_press_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win)
{
if (gdk_event->window != gtk_widget_get_window(widget))
return false;
if (g_blockEventsOnDrag) return TRUE;
if (g_blockEventsOnScroll) return TRUE;
if (win->m_isDragging) return TRUE;
int style = win->GetWindowStyle();
int y = (int)gdk_event->y;
int x = (int)gdk_event->x;
if ((style & wxRESIZE_BORDER) &&
(x > win->m_width-14) && (y > win->m_height-14))
{
GtkWidget *ancestor = gtk_widget_get_toplevel( widget );
GdkWindow *source = gtk_widget_get_window(widget);
int org_x = 0;
int org_y = 0;
gdk_window_get_origin( source, &org_x, &org_y );
gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
GDK_WINDOW_EDGE_SOUTH_EAST,
1,
org_x + x,
org_y + y,
0);
return TRUE;
}
if (win->m_miniTitle && (style & wxCLOSE_BOX))
{
if ((y > 3) && (y < 19) && (x > win->m_width-19) && (x < win->m_width-3))
{
win->Close();
return TRUE;
}
}
if (y >= win->m_miniEdge + win->m_miniTitle)
return true;
gdk_window_raise(gtk_widget_get_window(win->m_widget));
const GdkEventMask mask = GdkEventMask(
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON1_MOTION_MASK);
#ifdef __WXGTK3__
gdk_device_grab(
gdk_event->device, gdk_event->window, GDK_OWNERSHIP_NONE,
false, mask, NULL, gdk_event->time);
#else
gdk_pointer_grab(gdk_event->window, false, mask, NULL, NULL, gdk_event->time);
#endif
win->m_diffX = x;
win->m_diffY = y;
win->m_oldX = 0;
win->m_oldY = 0;
win->m_isDragging = true;
return TRUE;
}
static GtkCellEditable *
cell_renderer_key_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GtkCellRendererText *celltext;
CellRendererKey *key;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *clear_button;
GtkWidget *eventbox;
celltext = GTK_CELL_RENDERER_TEXT (cell);
key = CELL_RENDERER_KEY (cell);
/* If the cell isn't editable we return NULL. */
if (celltext->editable == FALSE)
return NULL;
g_return_val_if_fail (widget->window != NULL, NULL);
if (gdk_keyboard_grab (widget->window, FALSE,
gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
return NULL;
if (gdk_pointer_grab (widget->window, TRUE,
GDK_BUTTON_PRESS_MASK,
NULL, NULL,
gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
{
gdk_keyboard_ungrab (gdk_event_get_time (event));
return NULL;
}
key->grab_widget = widget;
g_signal_connect(G_OBJECT (widget), "key_press_event",
G_CALLBACK (grab_key_callback), key);
eventbox = g_object_new(pointless_eventbox_subclass_get_type(), NULL);
key->edit_widget = eventbox;
g_object_add_weak_pointer (G_OBJECT (key->edit_widget),
(void**) &key->edit_widget);
hbox = gtk_hbox_new(FALSE, 2);
label = gtk_label_new(TOOLTIP_TEXT);
gtk_label_set_single_line_mode(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
clear_button = gtk_button_new_from_stock(GTK_STOCK_DELETE);
g_signal_connect(G_OBJECT(clear_button), "clicked",
G_CALLBACK(clear_key_callback), key);
gtk_widget_modify_bg(eventbox, GTK_STATE_NORMAL,
&widget->style->bg[GTK_STATE_SELECTED]);
gtk_widget_modify_fg(label, GTK_STATE_NORMAL,
&widget->style->fg[GTK_STATE_SELECTED]);
gtk_box_pack_start_defaults(GTK_BOX(hbox), label);
gtk_box_pack_start(GTK_BOX(hbox), clear_button, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(eventbox), hbox);
gtk_container_set_border_width(GTK_CONTAINER(eventbox), 0);
gtk_widget_set_size_request(GTK_WIDGET(eventbox),
cell_area->width, cell_area->height);
g_object_set_data_full(G_OBJECT(eventbox), CELL_RENDERER_TEXT_PATH,
g_strdup (path), g_free);
gtk_widget_show_all(eventbox);
g_signal_connect (G_OBJECT(eventbox), "unrealize",
G_CALLBACK (ungrab_stuff), key);
return GTK_CELL_EDITABLE(eventbox);
}
static int
passphrase_dialog(char *message)
{
const char *failed;
char *passphrase, *local;
int result, grab_tries, grab_server, grab_pointer;
GtkWidget *dialog, *entry;
GdkGrabStatus status;
grab_server = (getenv("GNOME_SSH_ASKPASS_GRAB_SERVER") != NULL);
grab_pointer = (getenv("GNOME_SSH_ASKPASS_GRAB_POINTER") != NULL);
grab_tries = 0;
dialog = gtk_message_dialog_new(NULL, 0,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_OK_CANCEL,
"%s",
message);
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), entry, FALSE,
FALSE, 0);
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
gtk_widget_grab_focus(entry);
gtk_widget_show(entry);
gtk_window_set_title(GTK_WINDOW(dialog), "OpenSSH");
gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE);
gtk_label_set_line_wrap(GTK_LABEL((GTK_MESSAGE_DIALOG(dialog))->label),
TRUE);
/* Make <enter> close dialog */
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(ok_dialog), dialog);
/* Grab focus */
gtk_widget_show_now(dialog);
if (grab_pointer) {
for(;;) {
status = gdk_pointer_grab(
(GTK_WIDGET(dialog))->window, TRUE, 0, NULL,
NULL, GDK_CURRENT_TIME);
if (status == GDK_GRAB_SUCCESS)
break;
usleep(GRAB_WAIT * 1000);
if (++grab_tries > GRAB_TRIES) {
failed = "mouse";
goto nograb;
}
}
}
for(;;) {
status = gdk_keyboard_grab((GTK_WIDGET(dialog))->window,
FALSE, GDK_CURRENT_TIME);
if (status == GDK_GRAB_SUCCESS)
break;
usleep(GRAB_WAIT * 1000);
if (++grab_tries > GRAB_TRIES) {
failed = "keyboard";
goto nograbkb;
}
}
if (grab_server) {
gdk_x11_grab_server();
}
result = gtk_dialog_run(GTK_DIALOG(dialog));
/* Ungrab */
if (grab_server)
XUngrabServer(GDK_DISPLAY());
if (grab_pointer)
gdk_pointer_ungrab(GDK_CURRENT_TIME);
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
gdk_flush();
/* Report passphrase if user selected OK */
passphrase = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
if (result == GTK_RESPONSE_OK) {
local = g_locale_from_utf8(passphrase, strlen(passphrase),
NULL, NULL, NULL);
if (local != NULL) {
puts(local);
memset(local, '\0', strlen(local));
g_free(local);
} else {
puts(passphrase);
}
}
/* Zero passphrase in memory */
memset(passphrase, '\b', strlen(passphrase));
gtk_entry_set_text(GTK_ENTRY(entry), passphrase);
memset(passphrase, '\0', strlen(passphrase));
g_free(passphrase);
gtk_widget_destroy(dialog);
return (result == GTK_RESPONSE_OK ? 0 : -1);
/* At least one grab failed - ungrab what we got, and report
the failure to the user. Note that XGrabServer() cannot
fail. */
nograbkb:
gdk_pointer_ungrab(GDK_CURRENT_TIME);
nograb:
if (grab_server)
XUngrabServer(GDK_DISPLAY());
gtk_widget_destroy(dialog);
report_failed_grab(failed);
return (-1);
}
gboolean xmms_fullscreen_enter(GtkWidget * win, gint * w, gint * h)
{
gint i, close, how_close = -1, t, dummy;
gboolean retval = FALSE;
fullscreen_window_t *fwin;
FULL_LOCK();
fwin = getwindow(win);
if (!fwin->display->is_full && !fwin->is_full
&& fwin->display->can_full)
{
for (close = 0; close < fwin->display->num_modes; close++)
{
if ((fwin->display->modes[close]->hdisplay >= *w) &&
(fwin->display->modes[close]->vdisplay >= *h))
{
how_close = fwin->display->modes[close]->hdisplay - *w;
break;
}
}
for (i = close + 1; i < fwin->display->num_modes; i++)
{
if (fwin->display->modes[i]->vdisplay < *h)
continue;
t = fwin->display->modes[i]->hdisplay - *w;
if (t >= 0 && t < how_close)
{
close = i;
how_close = t;
}
}
if (close < fwin->display->num_modes)
{
*w = fwin->display->modes[close]->hdisplay;
*h = fwin->display->modes[close]->vdisplay;
/* Save the old position/size */
gdk_window_get_root_origin(fwin->window->window, &fwin->ox, &fwin->oy);
gdk_window_get_size(fwin->window->window, &fwin->owidth, &fwin->oheight);
/* Move it. */
gdk_window_move_resize(fwin->window->window, 0, 0,
fwin->display->modes[close]->hdisplay,
fwin->display->modes[close]->vdisplay);
/* Tell the WM not to mess with this window (no more decor) */
gdk_window_hide(fwin->window->window);
gdk_window_set_override_redirect(fwin->window->window, TRUE);
gdk_window_show(fwin->window->window);
/*
* XXX: HACK
* Something is ungrabbing the pointer shortly
* after the above unmap/override_redirect=TRUE/map
* is done. I don't know what at this time, only
* that it's not XMMS, and that it's very very evil.
*/
gdk_flush();
xmms_usleep(50000);
/* Steal the keyboard/mouse */
/* XXX: FIXME, use timeouts.. */
for (t = 0; t < 10; t++)
{
dummy = gdk_pointer_grab(fwin->window->window,
TRUE, 0,
fwin->window->window,
NULL,
GDK_CURRENT_TIME);
if (dummy == GrabSuccess)
break;
gtk_main_iteration_do(FALSE);
xmms_usleep(10000);
}
gdk_keyboard_grab(fwin->window->window, TRUE,
GDK_CURRENT_TIME);
/* Do the video mode switch.. */
XF86VidModeSwitchToMode(fwin->display->display,
DefaultScreen(fwin->display->display),
fwin->display->modes[close]);
XF86VidModeSetViewPort(fwin->display->display,
DefaultScreen(fwin->display->display),
0, 0);
retval = TRUE;
fwin->is_full = TRUE;
fwin->display->is_full = TRUE;
}
}
FULL_UNLOCK();
return retval;
}
static void
create_object_button_press(CreateObjectTool *tool, GdkEventButton *event,
DDisplay *ddisp)
{
Point clickedpoint, origpoint;
Handle *handle1;
Handle *handle2;
DiaObject *obj;
real click_distance;
ddisplay_untransform_coords(ddisp,
(int)event->x, (int)event->y,
&clickedpoint.x, &clickedpoint.y);
origpoint = clickedpoint;
snap_to_grid(ddisp, &clickedpoint.x, &clickedpoint.y);
click_distance = ddisplay_untransform_length(ddisp, 3.0);
obj = dia_object_default_create (tool->objtype, &clickedpoint,
tool->user_data,
&handle1, &handle2);
tool->obj = obj; /* ensure that tool->obj is initialised in case we
return early. */
if (!obj) {
tool->moving = FALSE;
tool->handle = NULL;
message_error(_("'%s' creation failed"), tool->objtype ? tool->objtype->name : "NULL");
return;
}
diagram_add_object(ddisp->diagram, obj);
/* Try a connect */
if (handle1 != NULL &&
handle1->connect_type != HANDLE_NONCONNECTABLE) {
ConnectionPoint *connectionpoint;
connectionpoint =
object_find_connectpoint_display(ddisp, &origpoint, obj, TRUE);
if (connectionpoint != NULL) {
(obj->ops->move)(obj, &origpoint);
}
}
if (!(event->state & GDK_SHIFT_MASK)) {
/* Not Multi-select => remove current selection */
diagram_remove_all_selected(ddisp->diagram, TRUE);
}
diagram_select(ddisp->diagram, obj);
/* Connect first handle if possible: */
if ((handle1!= NULL) &&
(handle1->connect_type != HANDLE_NONCONNECTABLE)) {
object_connect_display(ddisp, obj, handle1, TRUE);
}
object_add_updates(obj, ddisp->diagram);
ddisplay_do_update_menu_sensitivity(ddisp);
diagram_flush(ddisp->diagram);
if (handle2 != NULL) {
tool->handle = handle2;
tool->moving = TRUE;
tool->last_to = handle2->pos;
gdk_pointer_grab (gtk_widget_get_window(ddisp->canvas), FALSE,
GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
NULL, NULL, event->time);
ddisplay_set_all_cursor(get_cursor(CURSOR_SCROLL));
} else {
diagram_update_extents(ddisp->diagram);
tool->moving = FALSE;
}
}
gboolean
mc_show_history (GtkWidget *event_box,
GdkEventButton *event,
MCData *mc)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkListStore *store;
GtkTreeIter iter;
GtkTreeModel *model;
GtkWidget *treeview;
GtkCellRenderer *cell_renderer;
GtkTreeViewColumn *column;
GtkRequisition req;
gchar *command_list[1];
int i, j;
gint win_x, win_y, width, height;
gint entry_h, entry_x, entry_y, applet_x, applet_y;
/* count commands stored in history list */
for(i = 0, j = 0; i < MC_HISTORY_LIST_LENGTH; i++)
if(exists_history_entry(i))
j++;
window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (GTK_WIDGET (mc->applet)));
gtk_window_set_policy(GTK_WINDOW(window), 0, 0, 1);
gtk_widget_set_app_paintable (window, TRUE);
gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_COMBO);
/* cb */
g_signal_connect_after(GTK_OBJECT(window),
"button_press_event",
GTK_SIGNAL_FUNC(history_popup_clicked_cb),
NULL);
g_signal_connect_after (G_OBJECT (window), "key_press_event",
G_CALLBACK (history_key_press_cb), NULL);
gdk_window_get_geometry (GTK_WIDGET (mc->applet_box)->window, NULL, NULL,
&width, &height, NULL);
gdk_window_get_origin (mc->applet_box->window, &applet_x, &applet_y);
gdk_window_get_position (mc->entry->window, &entry_x, &entry_y);
gdk_drawable_get_size (mc->entry->window, NULL, &entry_h);
win_x=applet_x + entry_x-1;
win_y=applet_y + entry_y;
/* size */
gtk_widget_set_usize(GTK_WIDGET(window), width-2*(entry_x-1), 350);
/* scrollbars */
/* create scrolled window to put the Gtk_list widget inside */
scrolled_window=gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
g_signal_connect(GTK_OBJECT(scrolled_window),
"button_release_event",
GTK_SIGNAL_FUNC(history_popup_clicked_inside_cb),
NULL);
gtk_container_add(GTK_CONTAINER(window), scrolled_window);
gtk_container_set_border_width (GTK_CONTAINER(scrolled_window), 1);
gtk_widget_show(scrolled_window);
store = gtk_list_store_new (1, G_TYPE_STRING);
/* add history entries to list */
if (j == 0) {
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,0, _("No items in history"), -1);
}
else {
for(i = 0; i < MC_HISTORY_LIST_LENGTH; i++)
{
if(exists_history_entry(i))
{
command_list[0] = get_history_entry(i);
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,0,command_list[0],-1);
}
}
}
model = GTK_TREE_MODEL(store);
treeview = gtk_tree_view_new_with_model (model);
g_object_set_data (G_OBJECT (mc->applet), "tree", treeview);
cell_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (NULL, cell_renderer,
"text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
if (j == 0) {
gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection
(GTK_TREE_VIEW (treeview)),
GTK_SELECTION_NONE);
}
else {
gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection
(GTK_TREE_VIEW (treeview)),
GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (treeview), "button_press_event",
G_CALLBACK (history_list_button_press_cb), mc);
g_signal_connect (G_OBJECT (treeview), "key_press_event",
G_CALLBACK (history_list_key_press_cb), mc);
}
g_object_unref (G_OBJECT (model));
gtk_container_add(GTK_CONTAINER(scrolled_window),treeview);
gtk_widget_show (treeview);
gtk_widget_size_request (window, &req);
switch (panel_applet_get_orient (mc->applet)) {
case PANEL_APPLET_ORIENT_RIGHT:
case PANEL_APPLET_ORIENT_LEFT:
case PANEL_APPLET_ORIENT_DOWN:
win_y += (entry_h+BORDER-1);
break;
case PANEL_APPLET_ORIENT_UP:
win_y -= (req.height+BORDER-1);
break;
}
gtk_window_move (GTK_WINDOW (window), win_x, win_y);
g_signal_connect ((gpointer) window, "expose_event",
G_CALLBACK (history_window_expose_event),
NULL);
gtk_widget_show(window);
/* grab focus */
gdk_pointer_grab (window->window,
TRUE,
GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_POINTER_MOTION_MASK,
NULL,
NULL,
GDK_CURRENT_TIME);
gdk_keyboard_grab (window->window, TRUE, GDK_CURRENT_TIME);
gtk_grab_add(window);
gtk_widget_grab_focus (treeview);
return FALSE;
}
