/***********************************************************************
* process_events
*/
static int process_events( Display *display, ULONG_PTR mask )
{
XEvent event;
HWND hwnd;
int count = 0;
x11drv_event_handler handler;
wine_tsx11_lock();
while (XCheckIfEvent( display, &event, filter_event, (char *)mask ))
{
count++;
if (XFilterEvent( &event, None )) continue; /* filtered, ignore it */
if (!(handler = find_handler( event.type )))
{
TRACE( "%s, ignoring\n", dbgstr_event( event.type ));
continue; /* no handler, ignore it */
}
if (XFindContext( display, event.xany.window, winContext, (char **)&hwnd ) != 0)
hwnd = 0; /* not for a registered window */
if (!hwnd && event.xany.window == root_window) hwnd = GetDesktopWindow();
wine_tsx11_unlock();
TRACE( "%s for hwnd/window %p/%lx\n",
dbgstr_event( event.type ), hwnd, event.xany.window );
handler( hwnd, &event );
wine_tsx11_lock();
}
XFlush( gdi_display );
wine_tsx11_unlock();
if (count) TRACE( "processed %d events\n", count );
return count;
}
static char *x_getkey(void)
{
XWindowAttributes winattrs;
XEvent evt;
static char kbuf[32];
int i;
if (!display)
return NULL;
while (XCheckIfEvent(display, &evt, predicate, NULL)) {
switch (evt.type) {
case KeyPress:
i = XLookupString((XKeyEvent *)&evt, kbuf,
sizeof(kbuf)-1, NULL, NULL);
if (i) {
kbuf[i] = 0;
return kbuf;
}
continue;
case DestroyNotify:
XCloseDisplay(display);
exit(0);
case Expose:
XGetWindowAttributes(display, window, &winattrs);
XCopyArea(display, window, pixmap, gc, 0, 0,
winattrs.width, winattrs.height, 0, 0);
continue;
default:
continue;
}
}
return NULL;
}
void psb_xrandr_thread(void* arg)
{
VADriverContextP ctx = (VADriverContextP)arg;
INIT_DRIVER_DATA;
int event_base, error_base;
XEvent event;
XRRQueryExtension(psb_xrandr_info->dpy, &event_base, &error_base);
XRRSelectInput(psb_xrandr_info->dpy, psb_xrandr_info->root, RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask | RROutputChangeNotifyMask | RROutputPropertyNotifyMask);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: psb xrandr thread start\n");
while (1) {
if (XCheckIfEvent(psb_xrandr_info->dpy, (XEvent *)&event, outputChangePredicate, NULL)) {
if (event.type == ClientMessage) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: receive ClientMessage event, thread should exit\n");
XClientMessageEvent *evt;
evt = (XClientMessageEvent*) & event;
if (evt->message_type == psb_xrandr_info->psb_exit_atom) {
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: xrandr thread exit safely\n");
pthread_exit(NULL);
}
}
switch (event.type - event_base) {
case RRNotify_OutputChange:
XRRUpdateConfiguration(&event);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "Xrandr: receive RRNotify_OutputChange event, refresh output/crtc info\n");
driver_data->xrandr_update = 1;
psb_xrandr_refresh(ctx);
break;
default:
break;
}
}
usleep(200000);
}
}
///////////////////////////////////////////////////////////////////////
/// Function: PeekXEvent
///
/// Author: $author$
/// Date: 5/21/2012
///////////////////////////////////////////////////////////////////////
virtual bool PeekXEvent(XEvent& xEvent, Display& xDisplay)
{
if (False != (XCheckIfEvent
(&xDisplay, &xEvent, IsXEvent, (XPointer)(this))))
return true;
return false;
}
void Workspace::propertyNotifyEvent( const XPropertyEvent *event )
{
//char *name = XGetAtomName( dpy, event->atom );
//std::cout << "property \"" << name << "\" changed.\n";
//XFree( name );
// Handle property events for the root window
if ( event->window == rootId() ) {
// Major optimization when switching desktops; we'll block updates and just
// let damage accumulate until all newly mapped windows have been painted.
if ( event->atom == ATOM(_NET_CURRENT_DESKTOP) )
{
mWaitForClients = true;
XSync( dpy, false ); // Helps to accumulate more events
}
// If the root window pixmap was changed
else if ( event->atom == ATOM(_XROOTPMAP_ID) ||
event->atom == ATOM(_XSETROOT_ID) ||
event->atom == ATOM(ESETROOT_PMAP_ID) )
{
// Compress these events
XEvent dummy;
while ( XCheckIfEvent( dpy, &dummy, rootPixmapPredicate, XPointer( rootId() ) ) );
// Destroy the root tile picture
releasePicture( mRootTile );
// Damage the whole display
XserverRegion r = createRegionFromQRect( QRect( 0, 0, width(), height() ) );
addDamage( r );
}
}
// Handle notifications of changes to window opacity hints
else if ( event->atom == ATOM(_NET_WM_WINDOW_OPACITY))
{
// Compress opacity change events for the window
XEvent dummy;
while ( XCheckIfEvent( dpy, &dummy, windowOpacityPredicate, XPointer(event->window) ) );
Client *client = find( event->window );
if ( client )
client->opacityChanged();
}
}
i32 xwl_pollevent( xwl_event_t *event )
{
#ifdef _WIN32
MSG msg;
while ( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
#endif
#if LINUX
XEvent ev;
i32 i;
xwl_window_handle_t *wh = 0;
XEvent lastKeyReleaseEvent;
for( i = 0; i < XWL_MAX_WINDOW_HANDLES; ++i )
{
wh = &xwl_windowHandles[i];
if ( wh->handle.handle != 0 )
{
while (XCheckIfEvent( currentDisplay, &ev, &CheckEvent, wh->handle.handle) )
{
if ((ev.type == KeyPress) || (ev.type == KeyRelease) )
{
if ( ev.xkey.keycode < 256 )
{
// To detect if it is a repeated key event, we check the current state of the key.
// - If the state is "down", KeyReleased events must obviously be discarded.
// - KeyPress events are a little bit harder to handle: they depend on the EnableKeyRepeat state,
// and we need to properly forward the first one.
char keys[32];
XQueryKeymap(currentDisplay, keys);
if (keys[ev.xkey.keycode >> 3] & (1 << (ev.xkey.keycode % 8)))
{
// KeyRelease event + key down = repeated event --> discard
if (ev.type == KeyRelease)
{
lastKeyReleaseEvent = ev;
continue;
}
// KeyPress event + key repeat disabled + matching KeyRelease event = repeated event --> discard
if ((ev.type == KeyPress) &&
(lastKeyReleaseEvent.xkey.keycode == ev.xkey.keycode) &&
(lastKeyReleaseEvent.xkey.time == ev.xkey.time))
{
continue;
}
}
}
}
ProcessEvent( ev, wh );
}
}
}
static void
dga_vbl( void )
{
XEvent event;
while( XCheckIfEvent( x11.disp, &event, event_predicate, NULL ) )
handle_event( &event );
}
int MagellanRemoveMotionEvents(Display* display)
{
XEvent event;
while (XCheckIfEvent(display,&event,MagellanCheckMotionEvent,(char*)MagellanMotionEvent) == True ) {
}
return true;
}
static PyObject *xextdev_poll(PyObject *self, PyObject *args)
{
fd_set in_fds;
XEvent event;
struct timeval tv;
int gotsome = FALSE;
FD_ZERO(&in_fds);
FD_SET(x11_fd, &in_fds);
tv.tv_sec = 1;
tv.tv_usec = 0;
PyObject *list = PyList_New(0);
while(!term) {
if (XCheckIfEvent(display,&event,predicate,NULL)) {
do {
PyObject *py = process_event(&event);
if (py) {
PyList_Append(list,py);
gotsome = TRUE;
}
} while (XCheckIfEvent(display,&event,predicate,NULL));
if (gotsome)
break;
}
Py_BEGIN_ALLOW_THREADS
select(x11_fd+1, &in_fds, 0, 0, &tv);
tv.tv_sec = 1;
tv.tv_usec = 0;
Py_END_ALLOW_THREADS
}
if (term) {
fprintf(stderr,"Ungrabbing device...\n");
XUngrabDevice(display,xdev,CurrentTime);
//while (XPending(display))
// XNextEvent(display,&event);
XCloseDisplay(display);
display = NULL;
}
return list;
}
/*
Updates qt_x_time. This used to simply fetch current timestamp from the server,
but that can cause qt_x_time to be newer than timestamp of events that are
still in our events queue, thus e.g. making XSetInputFocus() caused by such
event to be ignored. Therefore events queue is searched for first
event with timestamp, and extra PropertyNotify is generated in order to make
sure such event is found.
*/
void updateXTime()
{
static QWidget *w = 0;
if(!w)
w = new QWidget;
long data = 1;
XChangeProperty(qt_xdisplay(), w->winId(), atoms->kwin_running, atoms->kwin_running, 32, PropModeAppend, (unsigned char *)&data, 1);
next_x_time = CurrentTime;
XEvent dummy;
XCheckIfEvent(qt_xdisplay(), &dummy, update_x_time_predicate, NULL);
if(next_x_time == CurrentTime)
{
XSync(qt_xdisplay(), False);
XCheckIfEvent(qt_xdisplay(), &dummy, update_x_time_predicate, NULL);
}
assert(next_x_time != CurrentTime);
qt_x_time = next_x_time;
XEvent ev; // remove the PropertyNotify event from the events queue
XWindowEvent(qt_xdisplay(), w->winId(), PropertyChangeMask, &ev);
}
int OGLwin_QTest(void)
{
XEvent e;
if (XCheckIfEvent(Dsp, &e, CheckForWindowEvent, (XPointer) XWindow)) {
XPutBackEvent(Dsp, &e);
return (1);
} else
return (0);
}
/* This isn't perfect. If there were motion events in the queue
* before this was called, then it flushes nothing. If we don't
* check for them, we might lose a legitamate enter event.
*/
uint
flushenterevents(void) {
XEvent e;
long l;
int n;
l = 0;
n = 0;
while(XCheckIfEvent(display, &e, findenter, (void*)&l))
n++;
return n;
}
bool
x_gui_rep::get_selection (string key, tree& t, string& s) {
t= "none";
s= "";
bool res=false;
if (selection_t->contains (key)) {
t= copy (selection_t [key]);
s= copy (selection_s [key]);
return true;
}
Atom xsel;
if (key == "primary") xsel = XA_CLIPBOARD;
else if (key == "mouse") xsel = XA_PRIMARY;
else return res;
Window selown = XGetSelectionOwner(dpy, xsel);
if (selown == None ||
is_nil (windows_l) ||
contains (windows_l, selown)) return res;
Window win= windows_l->item;
x_window x_win= (x_window) Window_to_window[win];
Atom prop= XInternAtom (dpy, "MY_STRING_SELECTION", false);
XConvertSelection (dpy, xsel, XA_STRING, prop, win, CurrentTime);
int i;
XEvent ev;
for (i=0; i<1000000; i++)
if (XCheckIfEvent (dpy, &ev, my_selnotify_predicate, (XPointer) x_win))
break;
if (i==1000000) return res;
XSelectionEvent& sel= ev.xselection;
if (sel.property==prop) {
long offset=0;
Atom type;
int fm;
unsigned long n, remains;
unsigned char* ret;
do {
XGetWindowProperty (dpy, win, sel.property,
offset, 1024, true, AnyPropertyType,
&type, &fm, &n, &remains, &ret);
s << string ((char*) ret, n);
offset += (n >> 2);
XFree (ret);
} while (remains>0);
t= tuple ("extern", s);
return true;
}
/* Find oldest possible serial for an outstanding expose event
*/
static gulong
find_current_serial (Display *xdisplay)
{
XEvent xev;
gulong serial = NextRequest (xdisplay);
XSync (xdisplay, False);
XCheckIfEvent (xdisplay, &xev, expose_serial_predicate, (XPointer)&serial);
return serial;
}
int spnav_remove_events(int type)
{
int rm_count = 0;
#ifdef USE_X11
if(dpy) {
XEvent xev;
while(XCheckIfEvent(dpy, &xev, match_events, (char*)&type)) {
rm_count++;
}
return rm_count;
}
#endif
if(sock) {
struct event_node *tmplist, *tmptail;
if(!(tmplist = tmptail = malloc(sizeof *tmplist))) {
return -1;
}
tmplist->next = 0;
/* while there are events in the event queue, or the daemon socket */
while(event_pending(sock)) {
spnav_event event;
read_event(sock, &event); /* remove next event */
if(event.type != type) {
/* We don't want to drop this one, wrong type. Keep the event
* in the temporary list, for deferred reinsertion
*/
enqueue_event(&event, &tmptail);
} else {
rm_count++;
}
}
/* reinsert any events we removed that we didn't mean to */
while(tmplist->next) {
struct event_node *node = tmplist->next;
enqueue_event(&node->event, 0);
free(tmplist);
tmplist = node;
}
return rm_count;
}
return 0;
}
static bool
wait_for_retrieval(GtkClipboard *clipboard, retrieval_context *r_context)
{
if (r_context->completed) // the request completed synchronously
return true;
Display *xDisplay = GDK_DISPLAY();
checkEventContext context;
context.cbWidget = NULL;
context.selAtom = gdk_x11_atom_to_xatom(gdk_atom_intern("GDK_SELECTION",
FALSE));
// Send X events which are relevant to the ongoing selection retrieval
// to the clipboard widget. Wait until either the operation completes, or
// we hit our timeout. All other X events remain queued.
int select_result;
int cnumber = ConnectionNumber(xDisplay);
fd_set select_set;
FD_ZERO(&select_set);
FD_SET(cnumber, &select_set);
++cnumber;
struct timeval tv;
do {
XEvent xevent;
while (XCheckIfEvent(xDisplay, &xevent, checkEventProc,
(XPointer) &context)) {
if (xevent.xany.type == SelectionNotify)
DispatchSelectionNotifyEvent(context.cbWidget, &xevent);
else
DispatchPropertyNotifyEvent(context.cbWidget, &xevent);
if (r_context->completed)
return true;
}
tv.tv_sec = 0;
tv.tv_usec = kClipboardTimeout;
select_result = select(cnumber, &select_set, NULL, NULL, &tv);
} while (select_result == 1);
#ifdef DEBUG_CLIPBOARD
printf("exceeded clipboard timeout\n");
#endif
r_context->timed_out = true;
return false;
}
static int spnav_remove_events(int type)
{
int rm_count = 0;
if(dpy) {
XEvent xev;
while(XCheckIfEvent(dpy, &xev, match_events, (char*)&type)) {
rm_count++;
}
return rm_count;
}
return 0;
}
bool i_drag(arg_t a) {
int dx = 0, dy = 0, i, ox, oy, x, y;
unsigned int ui;
bool dragging = true, next = false;
XEvent e;
Window w;
if (mode != MODE_IMAGE)
return false;
if (!XQueryPointer(win.env.dpy, win.xwin, &w, &w, &i, &i, &ox, &oy, &ui))
return false;
win_set_cursor(&win, CURSOR_HAND);
while (dragging) {
if (!next)
XMaskEvent(win.env.dpy,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask, &e);
switch (e.type) {
case ButtonPress:
case ButtonRelease:
dragging = false;
break;
case MotionNotify:
x = e.xmotion.x;
y = e.xmotion.y;
if (x >= 0 && x <= win.w && y >= 0 && y <= win.h) {
dx += x - ox;
dy += y - oy;
}
ox = x;
oy = y;
break;
}
if (dragging)
next = XCheckIfEvent(win.env.dpy, &e, is_motionnotify, None);
if ((!dragging || !next) && (dx != 0 || dy != 0)) {
if (img_move(&img, dx, dy))
img_render(&img);
dx = dy = 0;
}
}
win_set_cursor(&win, CURSOR_ARROW);
set_timeout(reset_cursor, TO_CURSOR_HIDE, true);
reset_timeout(redraw);
return false;
}
bool x11EventFilter ( XEvent * event )
{
if(event->type == KeyPress || event->type == KeyRelease)
{
XKeyEvent* key = reinterpret_cast<XKeyEvent*> (event);
bool autor = false;
static uint curr_autorep = 0;
if (event->type == KeyPress)
{
if (curr_autorep == event->xkey.keycode)
{
autor = true;
curr_autorep = 0;
}
}
else
{
// look ahead for auto-repeat
XEvent nextpress;
Display* dpy = QX11Info::display();
// was this the last auto-repeater?
x_auto_repeat_data auto_repeat_data;
auto_repeat_data.keycode = event->xkey.keycode;
auto_repeat_data.timestamp = event->xkey.time;
auto_repeat_data.release = true;
auto_repeat_data.error = false;
if (XCheckIfEvent(dpy, &nextpress, &qt_keypress_scanner,
(XPointer) &auto_repeat_data)) {
autor = true;
XPutBackEvent(dpy,&nextpress);
}
curr_autorep = autor ? event->xkey.keycode : 0;
}
if(!autor)
m_mainwindow->keysActive(key->keycode, key->state, event->type == KeyPress);
}
return QApplication::x11EventFilter(event);
}
void CUnixEventEmitter::emulateMouseRawMode(bool enable)
{
_emulateRawMode = enable;
if(_emulateRawMode)
{
XWindowAttributes xwa;
XGetWindowAttributes(_dpy, _win, &xwa);
XWarpPointer(_dpy, None, _win, None, None, None, None,
(xwa.width / 2), (xwa.height / 2));
// remove all outstanding mouse move events, they happened before the mouse
// was pulled back to 0.5 / 0.5, so a wrong movement delta would be
// reported otherwise
XEvent event;
while(XCheckIfEvent(_dpy, &event, &isMouseMoveEvent, NULL)) { };
}
}
void tick(const xen::TickContext& tick){
//////////////////////////////////////////////////////////////////
// Update the cached state of the keyboard
XQueryKeymap(xwn::state->display, xwn::state->keymap_state);
//////////////////////////////////////////////////////////////////
// Update modifier key state
// :TODO: we should really update this in response to actual events as well,
// but issue is that the press or release of one of the keys does not
// guarentee state (eg, if holding both shift keys simultaneously)
// This is rare, but possible...
xen::setBitState(xwn::state->modifier_keys,
(xen::ModifierKeyState)xen::ModifierKeys::Control,
xwn::isKeyPressed(xen::Key::RCtrl) || xwn::isKeyPressed(xen::Key::LCtrl));
xen::setBitState(xwn::state->modifier_keys,
(xen::ModifierKeyState)xen::ModifierKeys::Alt,
xwn::isKeyPressed(xen::Key::RAlt) || xwn::isKeyPressed(xen::Key::LAlt));
xen::setBitState(xwn::state->modifier_keys,
(xen::ModifierKeyState)xen::ModifierKeys::Shift,
xwn::isKeyPressed(xen::Key::RShift) || xwn::isKeyPressed(xen::Key::LShift));
xen::setBitState(xwn::state->modifier_keys,
(xen::ModifierKeyState)xen::ModifierKeys::System,
xwn::isKeyPressed(xen::Key::RSystem) || xwn::isKeyPressed(xen::Key::LSystem));
//////////////////////////////////////////////////////////////////
// Process window events
XEvent event;
for(uint i = 0; i < xwn::state->windows.size; ++i){
xen::Window* win = &xwn::state->windows[i];
while(XCheckIfEvent(xwn::state->display, &event,
&checkEventMatchesWindow,
reinterpret_cast<XPointer>(win->xwindow))
){
processWindowEvent(win, &event);
}
}
//while(XPending(xwn::state->display)){
// XNextEvent(xwn::state->display, &event);
// printf("Found pending event\n");
//}
}
QClipboard::QClipboard(QObject *parent)
: QObject(*new QClipboardPrivate, parent)
{
// create desktop widget since we need it to get PropertyNotify or
// XFixesSelectionNotify events when someone changes the
// clipboard.
(void)QApplication::desktop();
#ifndef QT_NO_XFIXES
if (X11->use_xfixes && X11->ptrXFixesSelectSelectionInput) {
const unsigned long eventMask =
XFixesSetSelectionOwnerNotifyMask | XFixesSelectionWindowDestroyNotifyMask | XFixesSelectionClientCloseNotifyMask;
for (int i = 0; i < X11->screenCount; ++i) {
X11->ptrXFixesSelectSelectionInput(X11->display, QX11Info::appRootWindow(i),
XA_PRIMARY, eventMask);
X11->ptrXFixesSelectSelectionInput(X11->display, QX11Info::appRootWindow(i),
ATOM(CLIPBOARD), eventMask);
}
}
#endif // QT_NO_XFIXES
if (X11->time == CurrentTime) {
// send a dummy event to myself to get the timestamp from X11.
qt_init_timestamp_data data;
data.timestamp = CurrentTime;
XEvent ev;
XCheckIfEvent(X11->display, &ev, &qt_init_timestamp_scanner, (XPointer)&data);
if (data.timestamp == CurrentTime) {
setupOwner();
// We need this value just for completeness, we don't use it.
long dummy = 0;
Window ownerId = owner->internalWinId();
XChangeProperty(X11->display, ownerId,
ATOM(CLIP_TEMPORARY), XA_INTEGER, 32,
PropModeReplace, (uchar*)&dummy, 1);
XWindowEvent(X11->display, ownerId, PropertyChangeMask, &ev);
data.timestamp = ev.xproperty.time;
XDeleteProperty(X11->display, ownerId, ATOM(CLIP_TEMPORARY));
}
X11->time = data.timestamp;
}
}
void _glfwPushSelectionToManager(_GLFWwindow* window)
{
XConvertSelection(_glfw.x11.display,
_glfw.x11.CLIPBOARD_MANAGER,
_glfw.x11.SAVE_TARGETS,
None,
window->x11.handle,
CurrentTime);
for (;;)
{
XEvent event;
if (!XCheckIfEvent(_glfw.x11.display, &event, isSelectionEvent, NULL))
continue;
switch (event.type)
{
case SelectionRequest:
_glfwHandleSelectionRequest(&event);
break;
case SelectionClear:
_glfwHandleSelectionClear(&event);
break;
case SelectionNotify:
{
if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
{
// This means one of two things; either the selection was
// not owned, which means there is no clipboard manager, or
// the transfer to the clipboard manager has completed
// In either case, it means we are done here
return;
}
break;
}
}
}
}
void
XpCancelJob (
Display *dpy,
Bool discard
)
{
xPrintEndJobReq *req;
XExtDisplayInfo *info = (XExtDisplayInfo *) xp_find_display (dpy);
_XpDiscardJobRec disrec;
XEvent event;
if (XpCheckExtInit(dpy, XP_INITIAL_RELEASE) == -1)
return; /* NoSuchExtension */
LockDisplay (dpy);
GetReq(PrintEndJob,req);
req->reqType = info->codes->major_opcode;
req->printReqType = X_PrintEndJob;
req->cancel = True;
UnlockDisplay (dpy);
SyncHandle ();
if (discard) {
/*
* get context and effectively do a sync of events.
*/
disrec.event_base_return = info->codes->first_event;
disrec.context = XpGetContext(dpy);
/*
* discard job, and also doc and page XPPrintNotify events.
*/
while (XCheckIfEvent(dpy, &event, _XpDiscardJob, (XPointer) &disrec))
{
/*EMPTY*/
}
}
}
static gboolean
handle_io (GIOChannel *source,
GIOCondition condition,
gpointer data)
{
SpiDEController *controller = (SpiDEController *) data;
DEControllerPrivateData *priv = controller->priv;
gboolean is_consumed = FALSE;
XEvent ev;
while (XCheckIfEvent(priv->xevie_display, &ev, isEvent, NULL))
{
if (ev.type == KeyPress || ev.type == KeyRelease)
is_consumed = spi_device_event_controller_forward_key_event (controller, &ev);
if (! is_consumed)
XevieSendEvent(priv->xevie_display, &ev, XEVIE_UNMODIFIED);
}
return TRUE;
}
gboolean
xfwm_device_check_mask_event (XfwmDevices *devices, Display *display,
guint event_mask, XfwmEvent *event)
{
gboolean result;
#ifdef HAVE_XI2
XI2CheckMaskContext context;
#endif
#ifdef HAVE_XI2
if (devices->xi2_available && event->meta.device != None)
{
context.devices = devices;
context.event = event;
xfwm_device_fill_xi2_event_mask (&context.xievent_mask, event_mask);
result = XCheckIfEvent (display, event->meta.x,
xfwm_device_check_mask_event_xi2_predicate, (XPointer)&context);
g_free (context.xievent_mask.mask);
if (result)
{
/* Previos data was released in predicate, allocate a new data for the new event */
XGetEventData (display, &event->meta.x->xcookie);
}
}
else
#endif
{
result = XCheckMaskEvent (display, event_mask, event->meta.x);
}
if (result)
{
xfwm_device_translate_event (devices, event->meta.x, event);
}
return result;
}
void
xnestCollectExposures(void)
{
XEvent X;
WindowPtr pWin;
RegionRec Rgn;
BoxRec Box;
while (XCheckIfEvent(xnestDisplay, &X, xnestExposurePredicate, NULL)) {
pWin = xnestWindowPtr(X.xexpose.window);
if (pWin && X.xexpose.width && X.xexpose.height) {
Box.x1 = pWin->drawable.x + wBorderWidth(pWin) + X.xexpose.x;
Box.y1 = pWin->drawable.y + wBorderWidth(pWin) + X.xexpose.y;
Box.x2 = Box.x1 + X.xexpose.width;
Box.y2 = Box.y1 + X.xexpose.height;
RegionInit(&Rgn, &Box, 1);
miSendExposures(pWin, &Rgn, Box.x2, Box.y2);
}
}
}
bool QXlibScreen::waitForClipboardEvent(Window win, int type, XEvent *event, int timeout)
{
QElapsedTimer timer;
timer.start();
do {
if (XCheckTypedWindowEvent(mDisplay->nativeDisplay(),win,type,event))
return true;
// process other clipboard events, since someone is probably requesting data from us
XEvent e;
if (XCheckIfEvent(mDisplay->nativeDisplay(), &e, checkForClipboardEvents, 0))
handleEvent(&e);
mDisplay->flush();
// sleep 50 ms, so we don't use up CPU cycles all the time.
struct timeval usleep_tv;
usleep_tv.tv_sec = 0;
usleep_tv.tv_usec = 50000;
select(0, 0, 0, 0, &usleep_tv);
} while (timer.elapsed() < timeout);
return false;
}
void fgPlatformProcessSingleEvent ( void )
{
SFG_Window* window;
XEvent event;
/* This code was repeated constantly, so here it goes into a definition: */
#define GETWINDOW(a) \
window = fgWindowByHandle( event.a.window ); \
if( window == NULL ) \
break;
#define GETMOUSE(a) \
window->State.MouseX = event.a.x; \
window->State.MouseY = event.a.y;
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoopEvent" );
while( XPending( fgDisplay.pDisplay.Display ) )
{
XNextEvent( fgDisplay.pDisplay.Display, &event );
#if _DEBUG
fghPrintEvent( &event );
#endif
switch( event.type )
{
case ClientMessage:
if (fgStructure.CurrentWindow)
if(fgIsSpaceballXEvent(&event)) {
fgSpaceballHandleXEvent(&event);
break;
}
/* Destroy the window when the WM_DELETE_WINDOW message arrives */
if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.pDisplay.DeleteWindow )
{
GETWINDOW( xclient );
fgDestroyWindow ( window );
if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
{
fgDeinitialize( );
exit( 0 );
}
else if( fgState.ActionOnWindowClose == GLUT_ACTION_GLUTMAINLOOP_RETURNS )
fgState.ExecState = GLUT_EXEC_STATE_STOP;
return;
}
break;
/*
* CreateNotify causes a configure-event so that sub-windows are
* handled compatibly with GLUT. Otherwise, your sub-windows
* (in freeglut only) will not get an initial reshape event,
* which can break things.
*
* GLUT presumably does this because it generally tries to treat
* sub-windows the same as windows.
*/
case CreateNotify:
case ConfigureNotify:
{
int width, height, x, y;
if( event.type == CreateNotify ) {
GETWINDOW( xcreatewindow );
width = event.xcreatewindow.width;
height = event.xcreatewindow.height;
x = event.xcreatewindow.x;
y = event.xcreatewindow.y;
} else {
GETWINDOW( xconfigure );
width = event.xconfigure.width;
height = event.xconfigure.height;
x = event.xconfigure.x;
y = event.xconfigure.y;
}
/* Update state and call callback, if there was a change */
fghOnPositionNotify(window, x, y, GL_FALSE);
/* Update state and call callback, if there was a change */
fghOnReshapeNotify(window, width, height, GL_FALSE);
}
break;
case DestroyNotify:
/*
* This is sent to confirm the XDestroyWindow call.
*
* XXX WHY is this commented out? Should we re-enable it?
*/
/* fgAddToWindowDestroyList ( window ); */
break;
case Expose:
/*
* We are too dumb to process partial exposes...
*
* XXX Well, we could do it. However, it seems to only
* XXX be potentially useful for single-buffered (since
* XXX double-buffered does not respect viewport when we
* XXX do a buffer-swap).
*
*/
if( event.xexpose.count == 0 )
{
GETWINDOW( xexpose );
window->State.WorkMask |= GLUT_DISPLAY_WORK;
}
break;
case MapNotify:
break;
case UnmapNotify:
/* We get this when iconifying a window. */
GETWINDOW( xunmap );
INVOKE_WCB( *window, WindowStatus, ( GLUT_HIDDEN ) );
window->State.Visible = GL_FALSE;
break;
case MappingNotify:
/*
* Have the client's keyboard knowledge updated (xlib.ps,
* page 206, says that's a good thing to do)
*/
XRefreshKeyboardMapping( (XMappingEvent *) &event );
break;
case VisibilityNotify:
{
/*
* Sending this event, the X server can notify us that the window
* has just acquired one of the three possible visibility states:
* VisibilityUnobscured, VisibilityPartiallyObscured or
* VisibilityFullyObscured. Note that we DO NOT receive a
* VisibilityNotify event when iconifying a window, we only get an
* UnmapNotify then.
*/
GETWINDOW( xvisibility );
switch( event.xvisibility.state )
{
case VisibilityUnobscured:
INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_RETAINED ) );
window->State.Visible = GL_TRUE;
break;
case VisibilityPartiallyObscured:
INVOKE_WCB( *window, WindowStatus,
( GLUT_PARTIALLY_RETAINED ) );
window->State.Visible = GL_TRUE;
break;
case VisibilityFullyObscured:
INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_COVERED ) );
window->State.Visible = GL_FALSE;
break;
default:
fgWarning( "Unknown X visibility state: %d",
event.xvisibility.state );
break;
}
}
break;
case EnterNotify:
case LeaveNotify:
GETWINDOW( xcrossing );
GETMOUSE( xcrossing );
if( ( event.type == LeaveNotify ) && window->IsMenu &&
window->ActiveMenu && window->ActiveMenu->IsActive )
fgUpdateMenuHighlight( window->ActiveMenu );
INVOKE_WCB( *window, Entry, ( ( EnterNotify == event.type ) ?
GLUT_ENTERED :
GLUT_LEFT ) );
break;
case MotionNotify:
{
/* if GLUT_SKIP_STALE_MOTION_EVENTS is true, then discard all but
* the last motion event from the queue
*/
if(fgState.SkipStaleMotion) {
while(XCheckIfEvent(fgDisplay.pDisplay.Display, &event, match_motion, 0));
}
GETWINDOW( xmotion );
GETMOUSE( xmotion );
if( window->ActiveMenu )
{
if( window == window->ActiveMenu->ParentWindow )
{
window->ActiveMenu->Window->State.MouseX =
event.xmotion.x_root - window->ActiveMenu->X;
window->ActiveMenu->Window->State.MouseY =
event.xmotion.y_root - window->ActiveMenu->Y;
}
fgUpdateMenuHighlight( window->ActiveMenu );
break;
}
/*
* XXX For more than 5 buttons, just check {event.xmotion.state},
* XXX rather than a host of bit-masks? Or maybe we need to
* XXX track ButtonPress/ButtonRelease events in our own
* XXX bit-mask?
*/
fgState.Modifiers = fgPlatformGetModifiers( event.xmotion.state );
if ( event.xmotion.state & ( Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask ) ) {
INVOKE_WCB( *window, Motion, ( event.xmotion.x,
event.xmotion.y ) );
} else {
INVOKE_WCB( *window, Passive, ( event.xmotion.x,
event.xmotion.y ) );
}
fgState.Modifiers = INVALID_MODIFIERS;
}
break;
case ButtonRelease:
case ButtonPress:
{
GLboolean pressed = GL_TRUE;
int button;
if( event.type == ButtonRelease )
pressed = GL_FALSE ;
/*
* A mouse button has been pressed or released. Traditionally,
* break if the window was found within the freeglut structures.
*/
GETWINDOW( xbutton );
GETMOUSE( xbutton );
/*
* An X button (at least in XFree86) is numbered from 1.
* A GLUT button is numbered from 0.
* Old GLUT passed through buttons other than just the first
* three, though it only gave symbolic names and official
* support to the first three.
*/
button = event.xbutton.button - 1;
/*
* Do not execute the application's mouse callback if a menu
* is hooked to this button. In that case an appropriate
* private call should be generated.
*/
if( fgCheckActiveMenu( window, button, pressed,
event.xbutton.x, event.xbutton.y ) )
break;
/*
* Check if there is a mouse or mouse wheel callback hooked to the
* window
*/
if( ! FETCH_WCB( *window, Mouse ) &&
! FETCH_WCB( *window, MouseWheel ) )
break;
fgState.Modifiers = fgPlatformGetModifiers( event.xbutton.state );
/* Finally execute the mouse or mouse wheel callback */
if( ( button < glutDeviceGet ( GLUT_NUM_MOUSE_BUTTONS ) ) || ( ! FETCH_WCB( *window, MouseWheel ) ) )
INVOKE_WCB( *window, Mouse, ( button,
pressed ? GLUT_DOWN : GLUT_UP,
event.xbutton.x,
event.xbutton.y )
);
else
{
/*
* Map 4 and 5 to wheel zero; EVEN to +1, ODD to -1
* " 6 and 7 " " one; ...
*
* XXX This *should* be behind some variables/macros,
* XXX since the order and numbering isn't certain
* XXX See XFree86 configuration docs (even back in the
* XXX 3.x days, and especially with 4.x).
*
* XXX Note that {button} has already been decremented
* XXX in mapping from X button numbering to GLUT.
*
* XXX Should add support for partial wheel turns as Windows does -- 5/27/11
*/
int wheel_number = (button - glutDeviceGet ( GLUT_NUM_MOUSE_BUTTONS )) / 2;
int direction = -1;
if( button % 2 )
direction = 1;
if( pressed )
INVOKE_WCB( *window, MouseWheel, ( wheel_number,
direction,
event.xbutton.x,
event.xbutton.y )
);
}
fgState.Modifiers = INVALID_MODIFIERS;
}
break;
case KeyRelease:
case KeyPress:
{
FGCBKeyboard keyboard_cb;
FGCBSpecial special_cb;
GETWINDOW( xkey );
GETMOUSE( xkey );
/* Detect auto repeated keys, if configured globally or per-window */
if ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE )
{
if (event.type==KeyRelease)
{
/*
* Look at X11 keystate to detect repeat mode.
* While X11 says the key is actually held down, we'll ignore KeyRelease/KeyPress pairs.
*/
char keys[32];
XQueryKeymap( fgDisplay.pDisplay.Display, keys ); /* Look at X11 keystate to detect repeat mode */
if ( event.xkey.keycode<256 ) /* XQueryKeymap is limited to 256 keycodes */
{
if ( keys[event.xkey.keycode>>3] & (1<<(event.xkey.keycode%8)) )
window->State.pWState.KeyRepeating = GL_TRUE;
else
window->State.pWState.KeyRepeating = GL_FALSE;
}
}
}
else
window->State.pWState.KeyRepeating = GL_FALSE;
/* Cease processing this event if it is auto repeated */
if (window->State.pWState.KeyRepeating)
{
if (event.type == KeyPress) window->State.pWState.KeyRepeating = GL_FALSE;
break;
}
if( event.type == KeyPress )
{
keyboard_cb = (FGCBKeyboard)( FETCH_WCB( *window, Keyboard ));
special_cb = (FGCBSpecial) ( FETCH_WCB( *window, Special ));
}
else
{
keyboard_cb = (FGCBKeyboard)( FETCH_WCB( *window, KeyboardUp ));
special_cb = (FGCBSpecial) ( FETCH_WCB( *window, SpecialUp ));
}
/* Is there a keyboard/special callback hooked for this window? */
if( keyboard_cb || special_cb )
{
XComposeStatus composeStatus;
char asciiCode[ 32 ];
KeySym keySym;
int len;
/* Check for the ASCII/KeySym codes associated with the event: */
len = XLookupString( &event.xkey, asciiCode, sizeof(asciiCode),
&keySym, &composeStatus
);
/* GLUT API tells us to have two separate callbacks... */
if( len > 0 )
{
/* ...one for the ASCII translateable keypresses... */
if( keyboard_cb )
{
fgSetWindow( window );
fgState.Modifiers = fgPlatformGetModifiers( event.xkey.state );
keyboard_cb( asciiCode[ 0 ],
event.xkey.x, event.xkey.y
);
fgState.Modifiers = INVALID_MODIFIERS;
}
}
else
{
int special = -1;
/*
* ...and one for all the others, which need to be
* translated to GLUT_KEY_Xs...
*/
switch( keySym )
{
case XK_F1: special = GLUT_KEY_F1; break;
case XK_F2: special = GLUT_KEY_F2; break;
case XK_F3: special = GLUT_KEY_F3; break;
case XK_F4: special = GLUT_KEY_F4; break;
case XK_F5: special = GLUT_KEY_F5; break;
case XK_F6: special = GLUT_KEY_F6; break;
case XK_F7: special = GLUT_KEY_F7; break;
case XK_F8: special = GLUT_KEY_F8; break;
case XK_F9: special = GLUT_KEY_F9; break;
case XK_F10: special = GLUT_KEY_F10; break;
case XK_F11: special = GLUT_KEY_F11; break;
case XK_F12: special = GLUT_KEY_F12; break;
case XK_KP_Left:
case XK_Left: special = GLUT_KEY_LEFT; break;
case XK_KP_Right:
case XK_Right: special = GLUT_KEY_RIGHT; break;
case XK_KP_Up:
case XK_Up: special = GLUT_KEY_UP; break;
case XK_KP_Down:
case XK_Down: special = GLUT_KEY_DOWN; break;
case XK_KP_Prior:
case XK_Prior: special = GLUT_KEY_PAGE_UP; break;
case XK_KP_Next:
case XK_Next: special = GLUT_KEY_PAGE_DOWN; break;
case XK_KP_Home:
case XK_Home: special = GLUT_KEY_HOME; break;
case XK_KP_End:
case XK_End: special = GLUT_KEY_END; break;
case XK_KP_Insert:
case XK_Insert: special = GLUT_KEY_INSERT; break;
case XK_Num_Lock : special = GLUT_KEY_NUM_LOCK; break;
case XK_KP_Begin : special = GLUT_KEY_BEGIN; break;
case XK_KP_Delete: special = GLUT_KEY_DELETE; break;
case XK_Shift_L: special = GLUT_KEY_SHIFT_L; break;
case XK_Shift_R: special = GLUT_KEY_SHIFT_R; break;
case XK_Control_L: special = GLUT_KEY_CTRL_L; break;
case XK_Control_R: special = GLUT_KEY_CTRL_R; break;
case XK_Alt_L: special = GLUT_KEY_ALT_L; break;
case XK_Alt_R: special = GLUT_KEY_ALT_R; break;
}
/*
* Execute the callback (if one has been specified),
* given that the special code seems to be valid...
*/
if( special_cb && (special != -1) )
{
fgSetWindow( window );
fgState.Modifiers = fgPlatformGetModifiers( event.xkey.state );
special_cb( special, event.xkey.x, event.xkey.y );
fgState.Modifiers = INVALID_MODIFIERS;
}
}
}
}
bool wxApp::ProcessXEvent(WXEvent* _event)
{
XEvent* event = (XEvent*) _event;
wxWindow* win = NULL;
Window window = XEventGetWindow(event);
#if 0
Window actualWindow = window;
#endif
// Find the first wxWindow that corresponds to this event window
// Because we're receiving events after a window
// has been destroyed, assume a 1:1 match between
// Window and wxWindow, so if it's not in the table,
// it must have been destroyed.
win = wxGetWindowFromTable(window);
if (!win)
{
#if wxUSE_TWO_WINDOWS
win = wxGetClientWindowFromTable(window);
if (!win)
#endif
return false;
}
switch (event->type)
{
case Expose:
{
#if wxUSE_TWO_WINDOWS && !wxUSE_NANOX
if (event->xexpose.window != (Window)win->GetClientAreaWindow())
{
XEvent tmp_event;
wxExposeInfo info;
info.window = event->xexpose.window;
info.found_non_matching = false;
while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, wxX11ExposePredicate, (XPointer) &info ))
{
// Don't worry about optimizing redrawing the border etc.
}
win->NeedUpdateNcAreaInIdle();
}
else
#endif
{
win->GetUpdateRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
XExposeEventGetWidth(event), XExposeEventGetHeight(event));
win->GetClearRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
XExposeEventGetWidth(event), XExposeEventGetHeight(event));
#if !wxUSE_NANOX
XEvent tmp_event;
wxExposeInfo info;
info.window = event->xexpose.window;
info.found_non_matching = false;
while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, wxX11ExposePredicate, (XPointer) &info ))
{
win->GetUpdateRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
tmp_event.xexpose.width, tmp_event.xexpose.height );
win->GetClearRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
tmp_event.xexpose.width, tmp_event.xexpose.height );
}
#endif
// This simplifies the expose and clear areas to simple
// rectangles.
win->GetUpdateRegion() = win->GetUpdateRegion().GetBox();
win->GetClearRegion() = win->GetClearRegion().GetBox();
// If we only have one X11 window, always indicate
// that borders might have to be redrawn.
if (win->X11GetMainWindow() == win->GetClientAreaWindow())
win->NeedUpdateNcAreaInIdle();
// Only erase background, paint in idle time.
win->SendEraseEvents();
// EXPERIMENT
//win->Update();
}
return true;
}
#if !wxUSE_NANOX
case GraphicsExpose:
{
wxLogTrace( wxT("expose"), wxT("GraphicsExpose from %s"), win->GetName().c_str());
win->GetUpdateRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
event->xgraphicsexpose.width, event->xgraphicsexpose.height);
win->GetClearRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
event->xgraphicsexpose.width, event->xgraphicsexpose.height);
if (event->xgraphicsexpose.count == 0)
{
// Only erase background, paint in idle time.
win->SendEraseEvents();
// win->Update();
}
return true;
}
#endif
case KeyPress:
{
if (!win->IsEnabled())
return false;
wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
wxTranslateKeyEvent(keyEvent, win, window, event);
// wxLogDebug( "OnKey from %s", win->GetName().c_str() );
// We didn't process wxEVT_KEY_DOWN, so send wxEVT_CHAR
if (win->HandleWindowEvent( keyEvent ))
return true;
keyEvent.SetEventType(wxEVT_CHAR);
// Do the translation again, retaining the ASCII
// code.
if (wxTranslateKeyEvent(keyEvent, win, window, event, true) &&
win->HandleWindowEvent( keyEvent ))
return true;
if ( (keyEvent.m_keyCode == WXK_TAB) &&
win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
{
wxNavigationKeyEvent new_event;
new_event.SetEventObject( win->GetParent() );
/* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
new_event.SetDirection( (keyEvent.m_keyCode == WXK_TAB) );
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( keyEvent.ControlDown() );
new_event.SetCurrentFocus( win );
return win->GetParent()->HandleWindowEvent( new_event );
}
return false;
}
case KeyRelease:
{
if (!win->IsEnabled())
return false;
wxKeyEvent keyEvent(wxEVT_KEY_UP);
wxTranslateKeyEvent(keyEvent, win, window, event);
return win->HandleWindowEvent( keyEvent );
}
case ConfigureNotify:
{
#if wxUSE_NANOX
if (event->update.utype == GR_UPDATE_SIZE)
#endif
{
wxTopLevelWindow *tlw = wxDynamicCast(win, wxTopLevelWindow);
if ( tlw )
{
tlw->SetConfigureGeometry( XConfigureEventGetX(event), XConfigureEventGetY(event),
XConfigureEventGetWidth(event), XConfigureEventGetHeight(event) );
}
if ( tlw && tlw->IsShown() )
{
tlw->SetNeedResizeInIdle();
}
else
{
wxSizeEvent sizeEvent( wxSize(XConfigureEventGetWidth(event), XConfigureEventGetHeight(event)), win->GetId() );
sizeEvent.SetEventObject( win );
return win->HandleWindowEvent( sizeEvent );
}
}
return false;
}
#if !wxUSE_NANOX
case PropertyNotify:
return HandlePropertyChange(_event);
case ClientMessage:
{
if (!win->IsEnabled())
return false;
Atom wm_delete_window = XInternAtom(wxGlobalDisplay(), "WM_DELETE_WINDOW", True);
Atom wm_protocols = XInternAtom(wxGlobalDisplay(), "WM_PROTOCOLS", True);
if (event->xclient.message_type == wm_protocols)
{
if ((Atom) (event->xclient.data.l[0]) == wm_delete_window)
{
win->Close(false);
return true;
}
}
return false;
}
#if 0
case DestroyNotify:
{
printf( "destroy from %s\n", win->GetName().c_str() );
break;
}
case CreateNotify:
{
printf( "create from %s\n", win->GetName().c_str() );
break;
}
case MapRequest:
{
printf( "map request from %s\n", win->GetName().c_str() );
break;
}
case ResizeRequest:
{
printf( "resize request from %s\n", win->GetName().c_str() );
Display *disp = (Display*) wxGetDisplay();
XEvent report;
// to avoid flicker
report = * event;
while( XCheckTypedWindowEvent (disp, actualWindow, ResizeRequest, &report));
wxSize sz = win->GetSize();
wxSizeEvent sizeEvent(sz, win->GetId());
sizeEvent.SetEventObject(win);
return win->HandleWindowEvent( sizeEvent );
}
#endif
#endif
#if wxUSE_NANOX
case GR_EVENT_TYPE_CLOSE_REQ:
{
if (win)
{
win->Close(false);
return true;
}
return false;
break;
}
#endif
case EnterNotify:
case LeaveNotify:
case ButtonPress:
case ButtonRelease:
case MotionNotify:
{
if (!win->IsEnabled())
return false;
// Here we check if the top level window is
// disabled, which is one aspect of modality.
wxWindow *tlw = win;
while (tlw && !tlw->IsTopLevel())
tlw = tlw->GetParent();
if (tlw && !tlw->IsEnabled())
return false;
if (event->type == ButtonPress)
{
if ((win != wxWindow::FindFocus()) && win->CanAcceptFocus())
{
// This might actually be done in wxWindow::SetFocus()
// and not here. TODO.
g_prevFocus = wxWindow::FindFocus();
g_nextFocus = win;
wxLogTrace( wxT("focus"), wxT("About to call SetFocus on %s of type %s due to button press"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
// Record the fact that this window is
// getting the focus, because we'll need to
// check if its parent is getting a bogus
// focus and duly ignore it.
// TODO: may need to have this code in SetFocus, too.
extern wxWindow* g_GettingFocus;
g_GettingFocus = win;
win->SetFocus();
}
}
#if !wxUSE_NANOX
if (event->type == LeaveNotify || event->type == EnterNotify)
{
// Throw out NotifyGrab and NotifyUngrab
if (event->xcrossing.mode != NotifyNormal)
return false;
}
#endif
wxMouseEvent wxevent;
wxTranslateMouseEvent(wxevent, win, window, event);
return win->HandleWindowEvent( wxevent );
}
case FocusIn:
#if !wxUSE_NANOX
if ((event->xfocus.detail != NotifyPointer) &&
(event->xfocus.mode == NotifyNormal))
#endif
{
wxLogTrace( wxT("focus"), wxT("FocusIn from %s of type %s"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
extern wxWindow* g_GettingFocus;
if (g_GettingFocus && g_GettingFocus->GetParent() == win)
{
// Ignore this, this can be a spurious FocusIn
// caused by a child having its focus set.
g_GettingFocus = NULL;
wxLogTrace( wxT("focus"), wxT("FocusIn from %s of type %s being deliberately ignored"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
return true;
}
else
{
wxFocusEvent focusEvent(wxEVT_SET_FOCUS, win->GetId());
focusEvent.SetEventObject(win);
focusEvent.SetWindow( g_prevFocus );
g_prevFocus = NULL;
return win->HandleWindowEvent(focusEvent);
}
}
return false;
case FocusOut:
#if !wxUSE_NANOX
if ((event->xfocus.detail != NotifyPointer) &&
(event->xfocus.mode == NotifyNormal))
#endif
{
wxLogTrace( wxT("focus"), wxT("FocusOut from %s of type %s"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
wxFocusEvent focusEvent(wxEVT_KILL_FOCUS, win->GetId());
focusEvent.SetEventObject(win);
focusEvent.SetWindow( g_nextFocus );
g_nextFocus = NULL;
return win->HandleWindowEvent(focusEvent);
}
return false;
}
return false;
}
