void
set_pointer_confinement (void)
{
if (confine_flag) {
XGrabPointer (display.dpy, display.win, 0,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync,
display.win, None, CurrentTime);
} else {
XUngrabPointer (display.dpy, CurrentTime);
}
}
static void
unlockscreen(Display *dpy, Lock *lock) {
if(dpy == NULL || lock == NULL)
return;
XUngrabPointer(dpy, CurrentTime);
XFreeColors(dpy, DefaultColormap(dpy, lock->screen), lock->colors, 2, 0);
XFreePixmap(dpy, lock->pmap);
XDestroyWindow(dpy, lock->win);
free(lock);
}
void Alleg4Display::releaseMouse()
{
#ifdef _WIN32
capture_mouse = false;
#elif defined(ALLEGRO_UNIX)
XUngrabPointer(_xwin.display, CurrentTime);
#endif
}
void OS_X11::set_mouse_mode(MouseMode p_mode) {
if (p_mode==mouse_mode)
return;
if (mouse_mode==MOUSE_MODE_CAPTURED)
XUngrabPointer(x11_display, CurrentTime);
if (mouse_mode!=MOUSE_MODE_VISIBLE && p_mode==MOUSE_MODE_VISIBLE)
XUndefineCursor(x11_display,x11_window);
if (p_mode!=MOUSE_MODE_VISIBLE && mouse_mode==MOUSE_MODE_VISIBLE) {
XDefineCursor(x11_display,x11_window,null_cursor);
}
mouse_mode=p_mode;
if (mouse_mode==MOUSE_MODE_CAPTURED) {
while(true) {
//flush pending motion events
if (XPending(x11_display) > 0) {
XEvent event;
XPeekEvent(x11_display, &event);
if (event.type==MotionNotify) {
XNextEvent(x11_display,&event);
} else {
break;
}
} else {
break;
}
}
if (XGrabPointer(x11_display, x11_window, True,
ButtonPressMask | ButtonReleaseMask |
PointerMotionMask, GrabModeAsync, GrabModeAsync,
x11_window, None, CurrentTime) !=
GrabSuccess) {
ERR_PRINT("NO GRAB");
}
center.x = current_videomode.width/2;
center.y = current_videomode.height/2;
XWarpPointer(x11_display, None, x11_window,
0,0,0,0, (int)center.x, (int)center.y);
input->set_mouse_pos(center);
} else {
do_mouse_warp=false;
}
XFlush(x11_display);
}
int vidmode_enable(struct video_canvas_s *canvas, int enable)
{
#ifdef HAVE_FULLSCREEN
Display *vm_display;
Window shellwin;
if (vm_available == 0) {
return 0;
}
vm_display = x11ui_get_display_ptr();
if (enable) {
vm_is_enabled = 0;
log_message(vidmode_log, "Enabling Vidmode with%s", vm_bestmodes[vidmode_selected_mode].name);
vm = vm_modes[vm_bestmodes[vidmode_selected_mode].modeindex];
saved_w = canvas->draw_buffer->canvas_width;
saved_h = canvas->draw_buffer->canvas_height;
vidmode_resize_canvas(canvas, canvas->fullscreenconfig->ui_border_top > 0);
XF86VidModeSwitchToMode(vm_display, screen, vm);
vidmode_center_canvas(canvas);
XWarpPointer(vm_display, None, DefaultRootWindow(vm_display), 0, 0, vm->hdisplay, vm->vdisplay, x + vm->hdisplay / 2, y + vm->vdisplay / 2);
/* grab the pointer */
shellwin = x11ui_get_X11_window();
XGrabPointer(vm_display, shellwin, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, shellwin, None, CurrentTime);
active_canvas = canvas;
vm_is_enabled = 1;
vm_is_suspended = 0;
} else {
if (!vm_is_enabled) {
return 0;
}
log_message(vidmode_log, "Disabling Vidmode");
/* FIXME: don't ungrab if either mouse or lightpen emulation is enabled */
XUngrabPointer(vm_display, CurrentTime);
XUngrabKeyboard(vm_display, CurrentTime);
XF86VidModeSwitchToMode(vm_display, screen, vm_modes[0]);
/* restore canvas size for windowed mode */
canvas->draw_buffer->canvas_width = saved_w;
canvas->draw_buffer->canvas_height = saved_h;
video_viewport_resize(canvas);
vm_is_enabled = 0;
}
#endif
return 0;
}
void
unlockscreen(Display *dpy, Lock *lock)
{
if (dpy == NULL || lock == NULL)
return;
XUngrabPointer(dpy, CurrentTime);
XFreePixmap(dpy, lock->pmap);
XDestroyWindow(dpy, lock->win);
free(lock);
}
void forward_click(XEvent* e) {
// forward the click to the desktop window (thanks conky)
XUngrabPointer(server.dsp, e->xbutton.time);
e->xbutton.window = server.root_win;
// icewm doesn't open under the mouse.
// and xfce doesn't open at all.
e->xbutton.x = e->xbutton.x_root;
e->xbutton.y = e->xbutton.y_root;
// XSetInputFocus(server.dsp, e->xbutton.window, RevertToParent,
// e->xbutton.time);
XSendEvent(server.dsp, e->xbutton.window, False, ButtonPressMask, e);
}
void Gesture::stroke_timeout()
{
kDebug() << "GESTURE: timeout";
XAllowEvents( QX11Info::display(), AsyncPointer, CurrentTime );
XUngrabPointer( QX11Info::display(), CurrentTime );
mouse_replay( false );
// for xorg-server 1.7 to 1.9 RC4: disable drag'n'drop support to evade bug #173606
if( VendorRelease( QX11Info::display() ) < 10899905 && VendorRelease( QX11Info::display() ) >= 10700000 )
mouse_replay( true );
recording = false;
}
static void ExitDlg(t_dlg *dlg)
{
if (dlg->bGrab)
{
XUngrabPointer(dlg->x11->disp, CurrentTime);
dlg->bGrab = false;
}
HideDlg(dlg);
if (dlg->flags & DLG_FREEONBUTTON)
{
FreeDlg(dlg);
}
}
int
pushScreenGrab (CompScreen *s,
Cursor cursor)
{
if (s->maxGrab == 0)
{
int status;
status = XGrabPointer (s->display->display, s->grabWindow, TRUE,
POINTER_GRAB_MASK,
GrabModeAsync, GrabModeAsync,
s->root, cursor,
CurrentTime);
if (status == GrabSuccess)
{
status = XGrabKeyboard (s->display->display,
s->grabWindow, TRUE,
GrabModeAsync, GrabModeAsync,
CurrentTime);
if (status != GrabSuccess)
{
XUngrabPointer (s->display->display, CurrentTime);
return 0;
}
}
else
return 0;
}
else
{
XChangeActivePointerGrab (s->display->display, POINTER_GRAB_MASK,
cursor, CurrentTime);
}
if (s->grabSize <= s->maxGrab)
{
s->grabs = realloc (s->grabs, sizeof (CompGrab) * (s->maxGrab + 1));
if (!s->grabs)
return 0;
s->grabSize = s->maxGrab + 1;
}
s->grabs[s->maxGrab].cursor = cursor;
s->grabs[s->maxGrab].active = TRUE;
s->maxGrab++;
return s->maxGrab;
}
static bool
bdown_event(Window *w, void *aux, XButtonEvent *e) {
Frame *f;
Client *c;
c = aux;
f = c->sel;
if((e->state & def.mod) == def.mod) {
switch(e->button) {
case Button1:
focus(c, false);
mouse_resize(c, Center, true);
break;
case Button2:
frame_restack(f, nil);
view_restack(f->view);
focus(c, false);
grabpointer(c->framewin, nil, cursor[CurNone], ButtonReleaseMask);
break;
case Button3:
focus(c, false);
mouse_resize(c, quadrant(f->r, Pt(e->x_root, e->y_root)), true);
break;
default:
XAllowEvents(display, ReplayPointer, e->time);
break;
}
}else {
if(e->button == Button1) {
if(!e->subwindow) {
frame_restack(f, nil);
view_restack(f->view);
mouse_checkresize(f, Pt(e->x, e->y), true);
}
if(f->client != selclient())
focus(c, false);
}
if(e->subwindow)
XAllowEvents(display, ReplayPointer, e->time);
else {
/* Ungrab so a menu can receive events before the button is released */
XUngrabPointer(display, e->time);
sync();
event("ClientMouseDown %#C %d\n", f->client, e->button);
}
}
return false;
}
void
tilemovemouse(const Arg *arg) {
/* Could EnterNotify events be used instead? */
Client *c, *d;
Monitor *m;
XEvent ev;
int x, y;
Bool after;
if(!(c = selmon->sel))
return;
if((m = recttomon(c->x, c->y, c->w, c->h)) != selmon) {
sendmon(c, m);
selmon = m;
focus(NULL);
}
if(c->isfloating || !selmon->lt[selmon->sellt]->arrange){
movemouse(NULL);
return;
}
if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
None, cursor[CurMove], CurrentTime) != GrabSuccess)
return;
do {
XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev);
switch (ev.type) {
case ConfigureRequest:
case Expose:
case MapRequest:
handler[ev.type](&ev);
break;
case MotionNotify:
x = ev.xmotion.x;
y = ev.xmotion.y;
after = False;
for(d = nexttiled(m->clients); d; d = nexttiled(d->next)){
if(d == c)
after = True;
else if(INRECT(x, y, d->x, d->y, d->w+2*borderpx, d->h+2*borderpx)){
detach(c);
after ? insertafter(c, d) : insertbefore(c,d);
arrange(c->mon);
break;
}
}
}
} while(ev.type != ButtonRelease);
XUngrabPointer(dpy, CurrentTime);
}
/* from xwininfo , thanks*/
Window Select_Window(){
// Display *dpy;
int status;
Cursor cursor;
XEvent event;
Window target_win = None, root = RootWindow(dpy, default_src);
int buttons = 0;
/* Make the target cursor */
cursor = XCreateFontCursor(dpy, XC_crosshair);
/* Grab the pointer using target cursor, letting it room all over */
status = XGrabPointer( dpy, root, False,
ButtonPressMask|ButtonReleaseMask, GrabModeSync,
GrabModeAsync, root, cursor, CurrentTime);
if (status != GrabSuccess)
printf("Can't grab the mouse.");
/* Let the user select a window... */
while ((target_win == None) || (buttons != 0)) {
/* allow one more event */
XAllowEvents(dpy, SyncPointer, CurrentTime);
XWindowEvent(dpy, root, ButtonPressMask|ButtonReleaseMask, &event);
switch (event.type) {
case ButtonPress:
if (target_win == None) {
target_win = event.xbutton.subwindow; /* window selected */
if (target_win == None) target_win = root;
}
buttons++;
break;
case ButtonRelease:
if (buttons > 0) /* there may have been some down before we started */
buttons--;
break;
}
}
XUngrabPointer(dpy, CurrentTime); /* Done with pointer */
if (target_win) {
Window root;
int dummyi;
uint32_t dummy;
if ( XGetGeometry (dpy, target_win, &root, &dummyi, &dummyi,
&dummy, &dummy, &dummy, &dummy) && target_win != root)
target_win = XmuClientWindow (dpy, target_win);
}
return(target_win);
}
void
Tk_Ungrab(
Tk_Window tkwin) /* Window whose grab should be released. */
{
TkDisplay *dispPtr;
TkWindow *grabWinPtr, *winPtr;
unsigned int serial;
grabWinPtr = (TkWindow *) tkwin;
dispPtr = grabWinPtr->dispPtr;
if (grabWinPtr != dispPtr->eventualGrabWinPtr) {
return;
}
ReleaseButtonGrab(dispPtr);
QueueGrabWindowChange(dispPtr, NULL);
if (dispPtr->grabFlags & (GRAB_GLOBAL|GRAB_TEMP_GLOBAL)) {
dispPtr->grabFlags &= ~(GRAB_GLOBAL|GRAB_TEMP_GLOBAL);
serial = NextRequest(dispPtr->display);
XUngrabPointer(dispPtr->display, CurrentTime);
XUngrabKeyboard(dispPtr->display, CurrentTime);
EatGrabEvents(dispPtr, serial);
}
/*
* Generate events to move the pointer back to the window where it really
* is. Some notes:
* 1. As with grabs, only do this if the "real" window is not a descendant
* of the grab window, since in this case the pointer is already where
* it's supposed to be.
* 2. If the "real" window is in some other application then don't
* generate any events at all, since everything's already been reported
* correctly.
* 3. Only generate enter events. Don't generate leave events, because we
* never told the lower-level windows that they had the pointer in the
* first place.
*/
for (winPtr = dispPtr->serverWinPtr; ; winPtr = winPtr->parentPtr) {
if (winPtr == grabWinPtr) {
break;
}
if (winPtr == NULL) {
if ((dispPtr->serverWinPtr == NULL) ||
(dispPtr->serverWinPtr->mainPtr == grabWinPtr->mainPtr)) {
MovePointer2(grabWinPtr, dispPtr->serverWinPtr,
NotifyUngrab, 0, 1);
}
break;
}
}
}
void
JXAssert::UnlockDisplays()
{
const JSize count = itsDisplayList->GetElementCount();
for (JIndex i=1; i<=count; i++)
{
JXDisplay* display = itsDisplayList->NthElement(i);
Display* xDisplay = display->GetXDisplay();
XUngrabServer(xDisplay);
XUngrabPointer(xDisplay, CurrentTime);
XUngrabKeyboard(xDisplay, CurrentTime);
display->Flush();
}
}
bool Window::processEvent( const WindowEvent& event )
{
switch( event.type )
{
case Event::WINDOW_POINTER_BUTTON_PRESS:
if( getIAttribute( IATTR_HINT_GRAB_POINTER ) == ON &&
getIAttribute( IATTR_HINT_DRAWABLE ) == WINDOW &&
// If no other button was pressed already, capture the mouse
event.pointerButtonPress.buttons == event.pointerButtonPress.button)
{
const unsigned int eventMask = ButtonPressMask | ButtonReleaseMask |
ButtonMotionMask;
const int result = XGrabPointer( getXDisplay(), getXDrawable(),
False, eventMask, GrabModeAsync,
GrabModeAsync, None, None,
CurrentTime );
if( result == GrabSuccess )
{
WindowEvent grabEvent = event;
grabEvent.type = Event::WINDOW_POINTER_GRAB;
processEvent( grabEvent );
}
else
{
LBWARN << "Failed to grab mouse: XGrabPointer returned "
<< result << std::endl;
}
}
break;
case Event::WINDOW_POINTER_BUTTON_RELEASE:
if( getIAttribute( IATTR_HINT_GRAB_POINTER ) == ON &&
getIAttribute( IATTR_HINT_DRAWABLE ) == WINDOW &&
// If no button is pressed anymore, release the mouse
event.pointerButtonRelease.buttons == PTR_BUTTON_NONE )
{
// Call early for consistent ordering
const bool result = SystemWindow::processEvent( event );
WindowEvent ungrabEvent = event;
ungrabEvent.type = Event::WINDOW_POINTER_UNGRAB;
processEvent( ungrabEvent );
XUngrabPointer( getXDisplay(), CurrentTime );
return result;
}
break;
}
return SystemWindow::processEvent( event );
}
bool Gesture::x11Event( XEvent* ev_P )
{
/* kdDebug(1217) << k_funcinfo << " ( type = " << ev_P->type << " )" << KeyRelease << " " << KeyPress <<endl;
if( ev_P->type == XKeyPress || ev_P->type == XKeyRelease )
{
return voice_handler->x11Event( ev_P );
}*/
if( ev_P->type == ButtonPress && ev_P->xbutton.button == button )
{
kdDebug( 1217 ) << "GESTURE: mouse press" << endl;
stroke.reset();
stroke.record( ev_P->xbutton.x, ev_P->xbutton.y );
nostroke_timer.start( timeout, true );
recording = true;
start_x = ev_P->xbutton.x_root;
start_y = ev_P->xbutton.y_root;
return true;
}
else if( ev_P->type == ButtonRelease && ev_P->xbutton.button == button
&& recording )
{
recording = false;
nostroke_timer.stop();
stroke.record( ev_P->xbutton.x, ev_P->xbutton.y );
QString gesture( stroke.translate());
if( gesture.isEmpty())
{
kdDebug( 1217 ) << "GESTURE: replay" << endl;
XAllowEvents( qt_xdisplay(), AsyncPointer, CurrentTime );
XUngrabPointer( qt_xdisplay(), CurrentTime );
mouse_replay( true );
return true;
}
kdDebug( 1217 ) << "GESTURE: got: " << gesture << endl;
emit handle_gesture( gesture, windows_handler->window_at_position( start_x, start_y ));
return true;
}
else if( ev_P->type == MotionNotify && recording )
{ // ignore small initial movement
if( nostroke_timer.isActive()
&& abs( start_x - ev_P->xmotion.x_root ) < 10
&& abs( start_y - ev_P->xmotion.y_root ) < 10 )
return true;
nostroke_timer.stop();
stroke.record( ev_P->xmotion.x, ev_P->xmotion.y );
}
return false;
}
void
IN_UngrabMouse(void)
{
if (mouse_grab_active) {
XUngrabPointer(x_disp, CurrentTime);
XUndefineCursor(x_disp, x_win);
mouse_grab_active = false;
}
#ifdef USE_XF86DGA
if (dga_mouse_active) {
IN_DeactivateDGAMouse();
}
#endif
}
static void
window_shutdown(glw_x11_t *gx11)
{
glw_video_reset(&gx11->gr);
glFlush();
XSync(gx11->display, False);
if(gx11->is_fullscreen) {
XUngrabPointer(gx11->display, CurrentTime);
XUngrabKeyboard(gx11->display, CurrentTime);
}
glw_flush(&gx11->gr);
window_close(gx11);
}
void
GrabPointerRelease(void)
{
#if USE_XI2
XIUngrabDevice(disp, DEV_PTR, CurrentTime);
#else
XUngrabPointer(disp, CurrentTime);
#endif
if (EDebug(EDBUG_TYPE_GRABS))
Eprintf("%s: %#x\n", __func__, Mode.grabs.pointer_grab_window);
Mode.grabs.pointer_grab_active = 0;
Mode.grabs.pointer_grab_window = NoXID;
}
void mouse_stop_drag() {
if (g_win_drag_client) {
client_set_dragged(g_win_drag_client, false);
// resend last size
monitor_apply_layout(g_drag_monitor);
}
g_win_drag_client = NULL;
g_drag_function = NULL;
XUngrabPointer(g_display, CurrentTime);
// remove all enternotify-events from the event queue that were
// generated by the XUngrabPointer
XEvent ev;
XSync(g_display, False);
while(XCheckMaskEvent(g_display, EnterWindowMask, &ev));
}
void GLWindow::UpdateGrabKey()
{
// Do not stole the key in debug mode. It is not breakpoint friendly...
#ifndef _DEBUG
XLockDisplay(glDisplay);
if (fullScreen) {
XGrabPointer(glDisplay, glWindow, True, ButtonPressMask, GrabModeAsync, GrabModeAsync, glWindow, None, CurrentTime);
XGrabKeyboard(glDisplay, glWindow, True, GrabModeAsync, GrabModeAsync, CurrentTime);
} else {
XUngrabPointer(glDisplay, CurrentTime);
XUngrabKeyboard(glDisplay, CurrentTime);
}
XUnlockDisplay(glDisplay);
#endif
}
// Wait for keyboard/mouse input and select window
static XID wait_click_window(int screen, int button)
{
Window root = RootWindow(dpy, screen);
Cursor cursor = XCreateFontCursor(dpy, XC_question_arrow);
if (cursor == None)
error_exit("unable to create selection cursor");
XSync(dpy, 0);
unsigned int mask = (ButtonPressMask | ButtonReleaseMask);
if (XGrabPointer(dpy, root, False, mask, GrabModeSync, GrabModeAsync,
None, cursor, CurrentTime) != GrabSuccess)
error_exit("unable to grab pointer");
Window win = None; // the window that got selected
int buttonPressed = -1; // button used to select window
int pressed = 0; // count of number of buttons pressed
// from dsimple.c in xwininfo
while (win == None || pressed != 0)
{
XEvent event;
XAllowEvents(dpy, SyncPointer, CurrentTime);
XWindowEvent(dpy, root, mask, &event);
switch (event.type)
{
case ButtonPress:
if (win == None)
{
buttonPressed = event.xbutton.button;
win = (event.xbutton.subwindow != None ? event.xbutton.subwindow : root);
}
pressed++;
break;
case ButtonRelease:
if (pressed > 0)
pressed--;
break;
}
}
XUngrabPointer(dpy, CurrentTime);
XFreeCursor(dpy, cursor);
XSync(dpy, 0);
return ((button == -1 || buttonPressed == button) ? win : None);
}
static void uninstall_grabs(void)
{
input_grabbed = false;
#ifdef USE_DGA
XF86DGADirectVideo(x_disp, DefaultScreen(x_disp), 0);
dgamouse = false;
#endif
XUngrabPointer(x_disp, CurrentTime);
XUngrabKeyboard(x_disp, CurrentTime);
// show cursor again
XUndefineCursor(x_disp, x_win);
}
void
input_capture_cursor(bool capture)
{
if (capture) {
XSetInputFocus(x_display, x11_active_window, RevertToPointerRoot,
CurrentTime);
XGrabPointer(x_display, x11_active_window, False,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync, x11_active_window,
None, CurrentTime);
cursor_state |= (uint8_t)1 << CURSOR_CAPTURED;
} else {
XUngrabPointer(x_display, CurrentTime);
cursor_state &= ~((uint8_t)1 << CURSOR_CAPTURED);
}
}
void
move_resize_window (WnckWindow *win,
int direction,
decor_event *gtkwd_event)
{
Display *xdisplay;
GdkDisplay *gdkdisplay;
GdkScreen *screen;
Window xroot;
XEvent ev;
gdkdisplay = gdk_display_get_default ();
xdisplay = GDK_DISPLAY_XDISPLAY (gdkdisplay);
screen = gdk_display_get_default_screen (gdkdisplay);
xroot = RootWindowOfScreen (gdk_x11_screen_get_xscreen (screen));
if (action_menu_mapped)
{
gtk_object_destroy (GTK_OBJECT (action_menu));
return;
}
ev.xclient.type = ClientMessage;
ev.xclient.display = xdisplay;
ev.xclient.serial = 0;
ev.xclient.send_event = TRUE;
ev.xclient.window = wnck_window_get_xid (win);
ev.xclient.message_type = wm_move_resize_atom;
ev.xclient.format = 32;
ev.xclient.data.l[0] = gtkwd_event->x_root;
ev.xclient.data.l[1] = gtkwd_event->y_root;
ev.xclient.data.l[2] = direction;
ev.xclient.data.l[3] = gtkwd_event->button;
ev.xclient.data.l[4] = 1;
XUngrabPointer (xdisplay, gtkwd_event->time);
XUngrabKeyboard (xdisplay, gtkwd_event->time);
XSendEvent (xdisplay, xroot, FALSE,
SubstructureRedirectMask | SubstructureNotifyMask,
&ev);
XSync (xdisplay, FALSE);
}
KEYS
#define CLEANMASK(mask) (mask & ~(numlockmask | LockMask))
#define MOUSEMASK (BUTTONMASK | PointerMotionMask)
static void
movemouse(Client *c) {
int x1, y1, ocx, ocy, di;
unsigned int dui;
Window dummy;
XEvent ev;
ocx = c->x;
ocy = c->y;
if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
None, cursor[CurMove], CurrentTime) != GrabSuccess)
return;
c->ismax = False;
XQueryPointer(dpy, root, &dummy, &dummy, &x1, &y1, &di, &di, &dui);
for(;;) {
XMaskEvent(dpy, MOUSEMASK | SubstructureRedirectMask, &ev);
switch (ev.type) {
case ButtonRelease:
resize(c, True);
XUngrabPointer(dpy, CurrentTime);
return;
case ConfigureRequest:
case MapRequest:
handler[ev.type](&ev);
break;
case MotionNotify:
XSync(dpy, False);
c->x = ocx + (ev.xmotion.x - x1);
c->y = ocy + (ev.xmotion.y - y1);
if(abs(sx + c->x) < SNAP)
c->x = sx;
else if(abs((sx + sw) - (c->x + c->w + 2 * c->border)) < SNAP)
c->x = sx + sw - c->w - 2 * c->border;
if(abs(sy - c->y) < SNAP)
c->y = sy;
else if(abs((sy + sh) - (c->y + c->h + 2 * c->border)) < SNAP)
c->y = sy + sh - c->h - 2 * c->border;
resize(c, False);
break;
}
}
}
static void uninit(void)
{
#ifdef HAVE_DGA2
XDGADevice *dgadevice;
#endif
if (!vo_config_count)
return;
if (vo_dga_is_running)
{
vo_dga_is_running = 0;
mp_msg(MSGT_VO, MSGL_V, "vo_dga: in uninit\n");
if (vo_grabpointer)
XUngrabPointer(mDisplay, CurrentTime);
XUngrabKeyboard(mDisplay, CurrentTime);
#ifdef HAVE_DGA2
XDGACloseFramebuffer(mDisplay, mScreen);
dgadevice = XDGASetMode(mDisplay, mScreen, 0);
if (dgadevice != NULL)
{
XFree(dgadevice);
}
#else
XF86DGADirectVideo(mDisplay, mScreen, 0);
// first disable DirectVideo and then switch mode back!
#ifdef HAVE_XF86VM
if (vo_dga_vidmodes != NULL)
{
int screen;
screen = XDefaultScreen(mDisplay);
mp_msg(MSGT_VO, MSGL_V,
"vo_dga: VidModeExt: Switching back..\n");
// seems some graphics adaptors need this more than once ...
XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
XF86VidModeSwitchToMode(mDisplay, screen, vo_dga_vidmodes[0]);
XFree(vo_dga_vidmodes);
}
#endif
#endif
}
vo_x11_uninit();
}
void sweep(Client *c) {
XEvent ev;
int old_cx = c->x;
int old_cy = c->y;
if (!grab_pointer(c->screen->root, MouseMask, resize_curs)) return;
client_raise(c);
#ifdef INFOBANNER_MOVERESIZE
create_info_window(c);
#endif
XGrabServer(dpy);
draw_outline(c);
setmouse(c->window, c->width, c->height);
for (;;) {
XMaskEvent(dpy, MouseMask, &ev);
switch (ev.type) {
case MotionNotify:
if (ev.xmotion.root != c->screen->root)
break;
draw_outline(c); /* clear */
XUngrabServer(dpy);
recalculate_sweep(c, old_cx, old_cy, ev.xmotion.x, ev.xmotion.y, ev.xmotion.state & altmask);
#ifdef INFOBANNER_MOVERESIZE
update_info_window(c);
#endif
XSync(dpy, False);
XGrabServer(dpy);
draw_outline(c);
break;
case ButtonRelease:
draw_outline(c); /* clear */
XUngrabServer(dpy);
#ifdef INFOBANNER_MOVERESIZE
remove_info_window();
#endif
XUngrabPointer(dpy, CurrentTime);
moveresize(c);
/* In case maximise state has changed: */
ewmh_set_net_wm_state(c);
return;
default:
break;
}
}
}
// Hide cursor
//
static void hideCursor(_GLFWwindow* window)
{
// Un-grab cursor (in windowed mode only; in fullscreen mode we still
// want the cursor grabbed in order to confine the cursor to the window
// area)
if (window->x11.cursorGrabbed && window->monitor == NULL)
{
XUngrabPointer(_glfw.x11.display, CurrentTime);
window->x11.cursorGrabbed = GL_FALSE;
}
if (!window->x11.cursorHidden)
{
XDefineCursor(_glfw.x11.display, window->x11.handle, _glfw.x11.cursor);
window->x11.cursorHidden = GL_TRUE;
}
}
