lkn
/
windowmaker-wl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wings: phase α.2 — rename X11 event masks to WM_EVMASK_* 

Sed pass.  KeyPressMask, KeyReleaseMask, ButtonPressMask,
ButtonReleaseMask, EnterWindowMask, LeaveWindowMask,
PointerMotionMask, PointerMotionHintMask, Button{1..5}MotionMask,
ButtonMotionMask, KeymapStateMask, ExposureMask,
VisibilityChangeMask, StructureNotifyMask, ResizeRedirectMask,
SubstructureNotifyMask, SubstructureRedirectMask, FocusChangeMask,
PropertyChangeMask, ColormapChangeMask all renamed to the
corresponding WM_EVMASK_* names defined in wnative.h.

Numeric values still match the X11 layout, so wevent_x11.c's
matching tables and any code that masks bits keep working
unchanged.  Build clean across WINGs/, src/, WPrefs.app/.
This commit is contained in:
Window Maker 2026-05-24 10:43:23 +02:00
parent 5f65867974
commit 82e3c3b65d
57 changed files with 245 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
WINGs/Extras/wtableview.c
View File

@ -423,7 +423,7 @@ static void splitterHandler(XEvent * event, void *data)
while (!done) {
XEvent ev;
WMMaskEvent(scr, ButtonMotionMask | ButtonReleaseMask, &ev);
WMMaskEvent(scr, WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE, &ev);
switch (ev.type) {
case MotionNotify:
@ -548,10 +548,10 @@ WMTableView *WMCreateTableView(WMWidget * parent)
table->canSelectRow = 1;
WMCreateEventHandler(table->view, ExposureMask | StructureNotifyMask, handleEvents, table);
WMCreateEventHandler(table->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, table);
WMCreateEventHandler(table->tableView, ExposureMask | ButtonPressMask |
ButtonReleaseMask | ButtonMotionMask, handleTableEvents, table);
WMCreateEventHandler(table->tableView, WM_EVMASK_EXPOSURE | WM_EVMASK_BUTTON_PRESS |
WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_MOTION, handleTableEvents, table);
WMResizeWidget(table, 50, 50);
@ -599,7 +599,7 @@ void WMAddTableViewColumn(WMTableView * table, WMTableColumn * column)
W_MapView(splitter);
W_SetViewCursor(splitter, table->splitterCursor);
WMCreateEventHandler(splitter, ButtonPressMask | ButtonReleaseMask, splitterHandler, column);
WMCreateEventHandler(splitter, WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE, splitterHandler, column);
WMAddToArray(table->splitters, splitter);
}

6
WINGs/Tests/mywidget.c
View File

@ -109,15 +109,15 @@ MyWidget *CreateMyWidget(WMWidget * parent)
/*
* Intercept some events for our widget, so that we can handle them.
*/
WMCreateEventHandler(mPtr->view, ExposureMask /* this allows us to know when we should paint */
| StructureNotifyMask, /* this allows us to know things like when we are destroyed */
WMCreateEventHandler(mPtr->view, WM_EVMASK_EXPOSURE /* this allows us to know when we should paint */
| WM_EVMASK_STRUCTURE_NOTIFY, /* this allows us to know things like when we are destroyed */
handleEvents, mPtr);
/*
* Intercept some other events. This could be merged with the above
* call, but we separate for more organization.
*/
WMCreateEventHandler(mPtr->view, ButtonPressMask, handleActionEvents, mPtr);
WMCreateEventHandler(mPtr->view, WM_EVMASK_BUTTON_PRESS, handleActionEvents, mPtr);
return mPtr;
}

2
WINGs/Tests/wtest.c
View File

@ -851,7 +851,7 @@ void testSplitView(WMScreen * scr)
WMMoveWidget(splitv1, 5, 50);
WMResizeWidget(splitv1, 290, 345);
WMSetSplitViewConstrainProc(splitv1, splitViewConstrainProc);
WMCreateEventHandler(WMWidgetView(win), StructureNotifyMask, resizeSplitView, splitv1);
WMCreateEventHandler(WMWidgetView(win), WM_EVMASK_STRUCTURE_NOTIFY, resizeSplitView, splitv1);
button = WMCreateCommandButton(frame);
WMSetButtonText(button, "+");

2
WINGs/WINGs/wnative.h
View File

@ -73,7 +73,7 @@ typedef int WMNativeBool;
/* ------------------------------------------------------------------ */
/* Event-mask bits — used by W_EventBackend.check_mask matching. */
/* Values match X11's KeyPressMask..VisibilityChangeMask layout. */
/* Values match X11's WM_EVMASK_KEY_PRESS..WM_EVMASK_VISIBILITY_CHANGE layout. */
/* ------------------------------------------------------------------ */
#define WM_EVMASK_KEY_PRESS (1L<<0)

4
WINGs/dragsource.c
View File

@ -1152,13 +1152,13 @@ void WMReleaseViewDragImage(WMView * view)
void WMCreateDragHandler(WMView * view, WMEventProc * dragEventProc, void *clientData)
{
WMCreateEventHandler(view,
ButtonPressMask | ButtonReleaseMask | Button1MotionMask, dragEventProc, clientData);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON1_MOTION, dragEventProc, clientData);
}
void WMDeleteDragHandler(WMView * view, WMEventProc * dragEventProc, void *clientData)
{
WMDeleteEventHandler(view,
ButtonPressMask | ButtonReleaseMask | Button1MotionMask, dragEventProc, clientData);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON1_MOTION, dragEventProc, clientData);
}
/* set default drag handler for view */

2
WINGs/wballoon.c
View File

@ -60,7 +60,7 @@ struct W_Balloon *W_CreateBalloon(WMScreen * scr)
bPtr->textColor = WMRetainColor(bPtr->view->screen->black);
WMCreateEventHandler(bPtr->view, StructureNotifyMask, handleEvents, bPtr);
WMCreateEventHandler(bPtr->view, WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, bPtr);
W_ResizeView(bPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
bPtr->flags.alignment = DEFAULT_ALIGNMENT;

2
WINGs/wbox.c
View File

@ -58,7 +58,7 @@ WMBox *WMCreateBox(WMWidget * parent)
bPtr->subviews = WMCreateArrayWithDestructor(2, wfree);
WMCreateEventHandler(bPtr->view, StructureNotifyMask, handleEvents, bPtr);
WMCreateEventHandler(bPtr->view, WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, bPtr);
WMResizeWidget(bPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);

2
WINGs/wbrowser.c
View File

@ -107,7 +107,7 @@ WMBrowser *WMCreateBrowser(WMWidget * parent)
bPtr->view->delegate = &_BrowserViewDelegate;
WMCreateEventHandler(bPtr->view, ExposureMask | StructureNotifyMask
WMCreateEventHandler(bPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY
| ClientMessageMask, handleEvents, bPtr);
/* default configuration */

6
WINGs/wbutton.c
View File

@ -132,10 +132,10 @@ WMButton *WMCreateCustomButton(WMWidget * parent, int behaviourMask)
bPtr->flags.enabled = 1;
bPtr->flags.dimsWhenDisabled = 1;
WMCreateEventHandler(bPtr->view, ExposureMask | StructureNotifyMask, handleEvents, bPtr);
WMCreateEventHandler(bPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, bPtr);
WMCreateEventHandler(bPtr->view, ButtonPressMask | ButtonReleaseMask
| EnterWindowMask | LeaveWindowMask, handleActionEvents, bPtr);
WMCreateEventHandler(bPtr->view, WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW, handleActionEvents, bPtr);
W_ResizeView(bPtr->view, DEFAULT_BUTTON_WIDTH, DEFAULT_BUTTON_HEIGHT);
bPtr->flags.alignment = DEFAULT_BUTTON_ALIGNMENT;

16
WINGs/wcolorpanel.c
View File

@ -455,10 +455,10 @@ static WMColorPanel *makeColorPanel(WMScreen * scrPtr, const char *name)
/* Create an event handler to handle expose/click events in ColorWheel */
WMCreateEventHandler(panel->wheelView,
ButtonPressMask | ButtonReleaseMask | EnterWindowMask |
LeaveWindowMask | ButtonMotionMask, wheelHandleActionEvents, panel);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_ENTER_WINDOW |
WM_EVMASK_LEAVE_WINDOW | WM_EVMASK_BUTTON_MOTION, wheelHandleActionEvents, panel);
WMCreateEventHandler(panel->wheelView, ExposureMask, wheelHandleEvents, panel);
WMCreateEventHandler(panel->wheelView, WM_EVMASK_EXPOSURE, wheelHandleEvents, panel);
panel->wheelBrightnessS = WMCreateSlider(panel->wheelFrm);
WMResizeWidget(panel->wheelBrightnessS, 16, 153);
@ -963,10 +963,10 @@ static WMColorPanel *makeColorPanel(WMScreen * scrPtr, const char *name)
/* Create event handler to handle expose/click events in CustomPalette */
WMCreateEventHandler(panel->customPaletteContentView,
ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask |
ButtonMotionMask, customPaletteHandleActionEvents, panel);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW |
WM_EVMASK_BUTTON_MOTION, customPaletteHandleActionEvents, panel);
WMCreateEventHandler(panel->customPaletteContentView, ExposureMask, customPaletteHandleEvents, panel);
WMCreateEventHandler(panel->customPaletteContentView, WM_EVMASK_EXPOSURE, customPaletteHandleEvents, panel);
panel->customPaletteMenuBtn = WMCreatePopUpButton(panel->customPaletteFrm);
WMSetPopUpButtonPullsDown(panel->customPaletteMenuBtn, 1);
@ -1638,7 +1638,7 @@ static Cursor magnifyGrabPointer(W_ColorPanel * panel)
/* Set up Pointer */
XGrabPointer(scr->display, panel->magnifyGlass->view->window, True,
PointerMotionMask | ButtonPressMask,
WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_PRESS,
GrabModeAsync, GrabModeAsync, scr->rootWin, magCursor, CurrentTime);
return magCursor;
@ -1833,7 +1833,7 @@ void W_ColorPanelMagnify(WMWidget * w, void *data)
W_MapView(panel->magnifyGlass->view);
XGrabPointer(scr->display, panel->magnifyGlass->view->window,
True, PointerMotionMask | ButtonPressMask,
True, WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_PRESS,
GrabModeAsync, GrabModeAsync, scr->rootWin, magCursor, CurrentTime);
break;
#endif

8
WINGs/wcolorwell.c
View File

@ -142,15 +142,15 @@ WMColorWell *WMCreateColorWell(WMWidget * parent)
}
cPtr->colorView->self = cPtr;
WMCreateEventHandler(cPtr->view, ExposureMask | StructureNotifyMask
WMCreateEventHandler(cPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY
| ClientMessageMask, handleEvents, cPtr);
WMCreateEventHandler(cPtr->colorView, ExposureMask, handleEvents, cPtr);
WMCreateEventHandler(cPtr->colorView, WM_EVMASK_EXPOSURE, handleEvents, cPtr);
WMCreateDragHandler(cPtr->colorView, handleDragEvents, cPtr);
WMCreateEventHandler(cPtr->view, ButtonPressMask, handleActionEvents, cPtr);
WMCreateEventHandler(cPtr->colorView, ButtonPressMask, handleActionEvents, cPtr);
WMCreateEventHandler(cPtr->view, WM_EVMASK_BUTTON_PRESS, handleActionEvents, cPtr);
WMCreateEventHandler(cPtr->colorView, WM_EVMASK_BUTTON_PRESS, handleActionEvents, cPtr);
cPtr->colorView->flags.mapWhenRealized = 1;

52
WINGs/wevent.c
View File

@ -17,32 +17,32 @@
*/
static const unsigned long wmeventMasks[] = {
[WME_NONE] = 0,
[WME_KEY_PRESS] = KeyPressMask,
[WME_KEY_RELEASE] = KeyReleaseMask,
[WME_BUTTON_PRESS] = ButtonPressMask,
[WME_BUTTON_RELEASE] = ButtonReleaseMask,
[WME_MOTION] = PointerMotionMask | ButtonMotionMask
| Button1MotionMask | Button2MotionMask
| Button3MotionMask,
[WME_ENTER] = EnterWindowMask,
[WME_LEAVE] = LeaveWindowMask,
[WME_EXPOSE] = ExposureMask,
[WME_CONFIGURE] = StructureNotifyMask,
[WME_CONFIGURE_REQUEST] = SubstructureRedirectMask,
[WME_MAP] = StructureNotifyMask,
[WME_MAP_REQUEST] = SubstructureRedirectMask,
[WME_UNMAP] = StructureNotifyMask,
[WME_DESTROY] = StructureNotifyMask,
[WME_REPARENT] = StructureNotifyMask,
[WME_FOCUS_IN] = FocusChangeMask,
[WME_FOCUS_OUT] = FocusChangeMask,
[WME_PROPERTY] = PropertyChangeMask,
[WME_KEY_PRESS] = WM_EVMASK_KEY_PRESS,
[WME_KEY_RELEASE] = WM_EVMASK_KEY_RELEASE,
[WME_BUTTON_PRESS] = WM_EVMASK_BUTTON_PRESS,
[WME_BUTTON_RELEASE] = WM_EVMASK_BUTTON_RELEASE,
[WME_MOTION] = WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_MOTION
| WM_EVMASK_BUTTON1_MOTION | WM_EVMASK_BUTTON2_MOTION
| WM_EVMASK_BUTTON3_MOTION,
[WME_ENTER] = WM_EVMASK_ENTER_WINDOW,
[WME_LEAVE] = WM_EVMASK_LEAVE_WINDOW,
[WME_EXPOSE] = WM_EVMASK_EXPOSURE,
[WME_CONFIGURE] = WM_EVMASK_STRUCTURE_NOTIFY,
[WME_CONFIGURE_REQUEST] = WM_EVMASK_SUBSTRUCTURE_REDIRECT,
[WME_MAP] = WM_EVMASK_STRUCTURE_NOTIFY,
[WME_MAP_REQUEST] = WM_EVMASK_SUBSTRUCTURE_REDIRECT,
[WME_UNMAP] = WM_EVMASK_STRUCTURE_NOTIFY,
[WME_DESTROY] = WM_EVMASK_STRUCTURE_NOTIFY,
[WME_REPARENT] = WM_EVMASK_STRUCTURE_NOTIFY,
[WME_FOCUS_IN] = WM_EVMASK_FOCUS_CHANGE,
[WME_FOCUS_OUT] = WM_EVMASK_FOCUS_CHANGE,
[WME_PROPERTY] = WM_EVMASK_PROPERTY_CHANGE,
[WME_SELECTION] = 0,
[WME_SELECTION_REQUEST] = 0,
[WME_SELECTION_CLEAR] = 0,
[WME_CLIENT_MESSAGE] = 0,
[WME_COLORMAP] = ColormapChangeMask,
[WME_VISIBILITY] = VisibilityChangeMask,
[WME_COLORMAP] = WM_EVMASK_COLORMAP_CHANGE,
[WME_VISIBILITY] = WM_EVMASK_VISIBILITY_CHANGE,
[WME_MAPPING] = 0,
};
@ -135,7 +135,7 @@ void W_CallDestroyHandlers(W_View * view)
event.u.lifecycle.event = (WNativeWindow)view->window;
WM_ITERATE_ARRAY(view->eventHandlers, hPtr, iter) {
if (hPtr->eventMask & StructureNotifyMask) {
if (hPtr->eventMask & WM_EVMASK_STRUCTURE_NOTIFY) {
(*hPtr->proc) (&event, hPtr->clientData);
}
}
@ -178,7 +178,7 @@ int WMHandleEvent(WMEvent * event)
window = event->window;
/* differentiate SubstructureNotify with StructureNotify */
if (mask == StructureNotifyMask) {
if (mask == WM_EVMASK_STRUCTURE_NOTIFY) {
if (event->type == WME_MAP || event->type == WME_UNMAP ||
event->type == WME_DESTROY || event->type == WME_CONFIGURE) {
WNativeWindow ev_win = WNATIVE_NONE;
@ -188,7 +188,7 @@ int WMHandleEvent(WMEvent * event)
else if (event->type == WME_CONFIGURE)
ev_win = event->u.configure.event;
if (ev_win != WNATIVE_NONE && ev_win != window) {
mask = SubstructureNotifyMask;
mask = WM_EVMASK_SUBSTRUCTURE_NOTIFY;
window = ev_win;
}
}
@ -215,7 +215,7 @@ int WMHandleEvent(WMEvent * event)
if (!toplevel)
toplevel = view;
if (mask & (KeyPressMask | KeyReleaseMask)) {
if (mask & (WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE)) {
W_View *focused = W_FocusedViewOfToplevel(toplevel);
if (focused)
view = focused;

32
WINGs/wevent_wl.c
View File

@ -82,23 +82,23 @@ static unsigned long
wme_mask(int type)
{
switch (type) {
case WME_KEY_PRESS: return KeyPressMask;
case WME_KEY_RELEASE: return KeyReleaseMask;
case WME_BUTTON_PRESS: return ButtonPressMask;
case WME_BUTTON_RELEASE: return ButtonReleaseMask;
case WME_MOTION: return PointerMotionMask | ButtonMotionMask;
case WME_ENTER: return EnterWindowMask;
case WME_LEAVE: return LeaveWindowMask;
case WME_EXPOSE: return ExposureMask;
case WME_CONFIGURE: return StructureNotifyMask;
case WME_MAP: return StructureNotifyMask;
case WME_UNMAP: return StructureNotifyMask;
case WME_DESTROY: return StructureNotifyMask;
case WME_KEY_PRESS: return WM_EVMASK_KEY_PRESS;
case WME_KEY_RELEASE: return WM_EVMASK_KEY_RELEASE;
case WME_BUTTON_PRESS: return WM_EVMASK_BUTTON_PRESS;
case WME_BUTTON_RELEASE: return WM_EVMASK_BUTTON_RELEASE;
case WME_MOTION: return WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_MOTION;
case WME_ENTER: return WM_EVMASK_ENTER_WINDOW;
case WME_LEAVE: return WM_EVMASK_LEAVE_WINDOW;
case WME_EXPOSE: return WM_EVMASK_EXPOSURE;
case WME_CONFIGURE: return WM_EVMASK_STRUCTURE_NOTIFY;
case WME_MAP: return WM_EVMASK_STRUCTURE_NOTIFY;
case WME_UNMAP: return WM_EVMASK_STRUCTURE_NOTIFY;
case WME_DESTROY: return WM_EVMASK_STRUCTURE_NOTIFY;
case WME_FOCUS_IN:
case WME_FOCUS_OUT: return FocusChangeMask;
case WME_PROPERTY: return PropertyChangeMask;
case WME_COLORMAP: return ColormapChangeMask;
case WME_VISIBILITY: return VisibilityChangeMask;
case WME_FOCUS_OUT: return WM_EVMASK_FOCUS_CHANGE;
case WME_PROPERTY: return WM_EVMASK_PROPERTY_CHANGE;
case WME_COLORMAP: return WM_EVMASK_COLORMAP_CHANGE;
case WME_VISIBILITY: return WM_EVMASK_VISIBILITY_CHANGE;
default: return 0;
}
}

2
WINGs/wfilepanel.c
View File

@ -173,7 +173,7 @@ static WMFilePanel *makeFilePanel(WMScreen * scrPtr, const char *name, const cha
WMResizeWidget(fPtr->win, PWIDTH, PHEIGHT);
WMSetWindowTitle(fPtr->win, "");
WMCreateEventHandler(WMWidgetView(fPtr->win), StructureNotifyMask, handleEvents, fPtr);
WMCreateEventHandler(WMWidgetView(fPtr->win), WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, fPtr);
WMSetWindowMinSize(fPtr->win, PWIDTH, PHEIGHT);
fPtr->iconLabel = WMCreateLabel(fPtr->win);

2
WINGs/wframe.c
View File

@ -208,7 +208,7 @@ WMFrame *WMCreateFrame(WMWidget * parent)
fPtr->view->self = fPtr;
fPtr->textColor = WMRetainColor(fPtr->view->screen->black);
WMCreateEventHandler(fPtr->view, ExposureMask | StructureNotifyMask, handleEvents, fPtr);
WMCreateEventHandler(fPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, fPtr);
fPtr->flags.relief = DEFAULT_RELIEF;
fPtr->flags.titlePosition = DEFAULT_TITLE_POSITION;

4
WINGs/winputmethod.c
View File

@ -122,8 +122,8 @@ void W_CreateIC(WMView * view)
unsigned long fevent = 0;
XGetICValues(view->xic, XNFilterEvents, &fevent, NULL);
XSelectInput(scr->display, view->window,
ButtonPressMask | ButtonReleaseMask | ExposureMask |
KeyPressMask | FocusChangeMask | ButtonMotionMask | fevent);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_EXPOSURE |
WM_EVMASK_KEY_PRESS | WM_EVMASK_FOCUS_CHANGE | WM_EVMASK_BUTTON_MOTION | fevent);
}
}

2
WINGs/wlabel.c
View File

@ -51,7 +51,7 @@ WMLabel *WMCreateLabel(WMWidget * parent)
lPtr->textColor = WMRetainColor(lPtr->view->screen->black);
WMCreateEventHandler(lPtr->view, ExposureMask | StructureNotifyMask, handleEvents, lPtr);
WMCreateEventHandler(lPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, lPtr);
W_ResizeView(lPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
lPtr->flags.alignment = DEFAULT_ALIGNMENT;

6
WINGs/wlist.c
View File

@ -125,11 +125,11 @@ WMList *WMCreateList(WMWidget * parent)
lPtr->view->delegate = &_ListViewDelegate;
WMCreateEventHandler(lPtr->view, ExposureMask | StructureNotifyMask
WMCreateEventHandler(lPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY
| ClientMessageMask, handleEvents, lPtr);
WMCreateEventHandler(lPtr->view, ButtonPressMask | ButtonReleaseMask
| EnterWindowMask | LeaveWindowMask | ButtonMotionMask, handleActionEvents, lPtr);
WMCreateEventHandler(lPtr->view, WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW | WM_EVMASK_BUTTON_MOTION, handleActionEvents, lPtr);
lPtr->itemHeight = WMFontHeight(scrPtr->normalFont) + 1;

10
WINGs/wpanel.c
View File

@ -226,7 +226,7 @@ WMAlertPanel *WMCreateAlertPanel(WMScreen * scrPtr, WMWindow * owner,
WMMapSubwidgets(panel->hbox);
WMCreateEventHandler(W_VIEW(panel->win), KeyPressMask, handleKeyPress, panel);
WMCreateEventHandler(W_VIEW(panel->win), WM_EVMASK_KEY_PRESS, handleKeyPress, panel);
WMRealizeWidget(panel->win);
WMMapSubwidgets(panel->win);
@ -392,7 +392,7 @@ WMAlertPanel *WMCreateScaledAlertPanel(WMScreen * scrPtr, WMWindow * owner,
WMMapSubwidgets(panel->hbox);
WMCreateEventHandler(W_VIEW(panel->win), KeyPressMask, handleKeyPress, panel);
WMCreateEventHandler(W_VIEW(panel->win), WM_EVMASK_KEY_PRESS, handleKeyPress, panel);
WMRealizeWidget(panel->win);
WMMapSubwidgets(panel->win);
@ -590,7 +590,7 @@ WMInputPanel *WMCreateInputPanel(WMScreen * scrPtr, WMWindow * owner, const char
WMSetButtonFont(panel->altBtn, defaultFont);
}
WMCreateEventHandler(W_VIEW(panel->win), KeyPressMask, handleKeyPress2, panel);
WMCreateEventHandler(W_VIEW(panel->win), WM_EVMASK_KEY_PRESS, handleKeyPress2, panel);
WMRealizeWidget(panel->win);
WMMapSubwidgets(panel->win);
@ -687,7 +687,7 @@ WMInputPanel *WMCreateScaledInputPanel(WMScreen * scrPtr, WMWindow * owner, cons
WMSetButtonText(panel->altBtn, cancelButton);
}
WMCreateEventHandler(W_VIEW(panel->win), KeyPressMask, handleKeyPress2, panel);
WMCreateEventHandler(W_VIEW(panel->win), WM_EVMASK_KEY_PRESS, handleKeyPress2, panel);
WMRealizeWidget(panel->win);
WMMapSubwidgets(panel->win);
@ -836,7 +836,7 @@ WMGenericPanel *WMCreateGenericPanel(WMScreen * scrPtr, WMWindow * owner,
WMMapSubwidgets(hbox);
WMCreateEventHandler(W_VIEW(panel->win), KeyPressMask, handleKeyPress3, panel);
WMCreateEventHandler(W_VIEW(panel->win), WM_EVMASK_KEY_PRESS, handleKeyPress3, panel);
WMRealizeWidget(panel->win);
WMMapSubwidgets(panel->win);

10
WINGs/wpopupbutton.c
View File

@ -67,13 +67,13 @@ WMPopUpButton *WMCreatePopUpButton(WMWidget * parent)
}
bPtr->view->self = bPtr;
WMCreateEventHandler(bPtr->view, ExposureMask | StructureNotifyMask
WMCreateEventHandler(bPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY
| ClientMessageMask, handleEvents, bPtr);
W_ResizeView(bPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
bPtr->caption = wstrdup(DEFAULT_CAPTION);
WMCreateEventHandler(bPtr->view, ButtonPressMask | ButtonReleaseMask, handleActionEvents, bPtr);
WMCreateEventHandler(bPtr->view, WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE, handleActionEvents, bPtr);
bPtr->flags.enabled = 1;
@ -85,9 +85,9 @@ WMPopUpButton *WMCreatePopUpButton(WMWidget * parent)
W_ResizeView(bPtr->menuView, bPtr->view->size.width, 1);
WMCreateEventHandler(bPtr->menuView, ButtonPressMask | ButtonReleaseMask
| EnterWindowMask | LeaveWindowMask | ButtonMotionMask
| ExposureMask, handleActionEvents, bPtr);
WMCreateEventHandler(bPtr->menuView, WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW | WM_EVMASK_BUTTON_MOTION
| WM_EVMASK_EXPOSURE, handleActionEvents, bPtr);
return bPtr;
}

2
WINGs/wprogressindicator.c
View File

@ -56,7 +56,7 @@ WMProgressIndicator *WMCreateProgressIndicator(WMWidget * parent)
pPtr->view->delegate = &_ProgressIndicatorDelegate;
WMCreateEventHandler(pPtr->view, ExposureMask | StructureNotifyMask, handleEvents, pPtr);
WMCreateEventHandler(pPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, pPtr);
W_ResizeView(pPtr->view, DEFAULT_PROGRESS_INDICATOR_WIDTH, DEFAULT_PROGRESS_INDICATOR_HEIGHT);

8
WINGs/wruler.c
View File

@ -393,10 +393,10 @@ WMRuler *WMCreateRuler(WMWidget * parent)
W_ResizeView(rPtr->view, w, 40);
WMCreateEventHandler(rPtr->view, ExposureMask | StructureNotifyMask
| EnterWindowMask | LeaveWindowMask | FocusChangeMask
| ButtonReleaseMask | ButtonPressMask | KeyReleaseMask
| KeyPressMask | Button1MotionMask, handleEvents, rPtr);
WMCreateEventHandler(rPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY
| WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW | WM_EVMASK_FOCUS_CHANGE
| WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS | WM_EVMASK_KEY_RELEASE
| WM_EVMASK_KEY_PRESS | WM_EVMASK_BUTTON1_MOTION, handleEvents, rPtr);
rPtr->view->delegate = &_RulerViewDelegate;

6
WINGs/wscroller.c
View File

@ -103,14 +103,14 @@ WMScroller *WMCreateScroller(WMWidget * parent)
sPtr->flags.documentFullyVisible = 1;
WMCreateEventHandler(sPtr->view, ExposureMask | StructureNotifyMask
WMCreateEventHandler(sPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY
| ClientMessageMask, handleEvents, sPtr);
W_ResizeView(sPtr->view, SCROLLER_WIDTH, SCROLLER_WIDTH);
sPtr->flags.arrowsPosition = DEFAULT_ARROWS_POSITION;
WMCreateEventHandler(sPtr->view, ButtonPressMask | ButtonReleaseMask
| EnterWindowMask | LeaveWindowMask | ButtonMotionMask, handleActionEvents, sPtr);
WMCreateEventHandler(sPtr->view, WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW | WM_EVMASK_BUTTON_MOTION, handleActionEvents, sPtr);
sPtr->flags.hitPart = WSNoPart;

4
WINGs/wscrollview.c
View File

@ -64,8 +64,8 @@ WMScrollView *WMCreateScrollView(WMWidget * parent)
sPtr->viewport->flags.mapWhenRealized = 1;
WMCreateEventHandler(sPtr->view, StructureNotifyMask | ExposureMask, handleEvents, sPtr);
WMCreateEventHandler(sPtr->viewport, SubstructureNotifyMask, handleViewportEvents, sPtr);
WMCreateEventHandler(sPtr->view, WM_EVMASK_STRUCTURE_NOTIFY | WM_EVMASK_EXPOSURE, handleEvents, sPtr);
WMCreateEventHandler(sPtr->viewport, WM_EVMASK_SUBSTRUCTURE_NOTIFY, handleViewportEvents, sPtr);
sPtr->lineScroll = 4;

6
WINGs/wslider.c
View File

@ -71,10 +71,10 @@ WMSlider *WMCreateSlider(WMWidget * parent)
sPtr->view->delegate = &_SliderViewDelegate;
WMCreateEventHandler(sPtr->view, ExposureMask | StructureNotifyMask, handleEvents, sPtr);
WMCreateEventHandler(sPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, sPtr);
WMCreateEventHandler(sPtr->view, ButtonPressMask | ButtonReleaseMask
| EnterWindowMask | LeaveWindowMask | ButtonMotionMask, handleActionEvents, sPtr);
WMCreateEventHandler(sPtr->view, WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW | WM_EVMASK_BUTTON_MOTION, handleActionEvents, sPtr);
W_ResizeView(sPtr->view, 100, 16);
sPtr->flags.vertical = 0;

8
WINGs/wsplitview.c
View File

@ -514,7 +514,7 @@ static void dragDivider(WMSplitView * sPtr, int clickX, int clickY)
done = 0;
dragging = 0;
while (!done) {
WMMaskEvent(scr, ButtonMotionMask | ButtonReleaseMask | ExposureMask, &ev);
WMMaskEvent(scr, WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_EXPOSURE, &ev);
coord = (sPtr->flags.vertical) ? ev.u.motion.x : ev.u.motion.y;
@ -621,11 +621,11 @@ WMSplitView *WMCreateSplitView(WMWidget * parent)
WMSetViewNotifySizeChanges(sPtr->view, True);
WMCreateEventHandler(sPtr->view, ExposureMask | StructureNotifyMask
WMCreateEventHandler(sPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY
| ClientMessageMask, handleEvents, sPtr);
WMCreateEventHandler(sPtr->view, ButtonPressMask | ButtonReleaseMask
| EnterWindowMask | LeaveWindowMask, handleActionEvents, sPtr);
WMCreateEventHandler(sPtr->view, WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW, handleActionEvents, sPtr);
WMAddNotificationObserver(handleViewResized, sPtr, WMViewSizeDidChangeNotification, sPtr->view);

2
WINGs/wtabview.c
View File

@ -210,7 +210,7 @@ WMTabView *WMCreateTabView(WMWidget * parent)
tPtr->flags.uniformTabs = 0;
tPtr->flags.enabled = 1;
WMCreateEventHandler(tPtr->view, ExposureMask | StructureNotifyMask | ButtonPressMask, handleEvents, tPtr);
WMCreateEventHandler(tPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY | WM_EVMASK_BUTTON_PRESS, handleEvents, tPtr);
WMResizeWidget(tPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);

8
WINGs/wtext.c
View File

@ -3014,11 +3014,11 @@ WMText *WMCreateTextForDocumentType(WMWidget * parent, WMAction * parser, WMActi
tPtr->timerID = NULL;
#endif
WMCreateEventHandler(tPtr->view, ExposureMask | StructureNotifyMask
| EnterWindowMask | LeaveWindowMask | FocusChangeMask, handleEvents, tPtr);
WMCreateEventHandler(tPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY
| WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW | WM_EVMASK_FOCUS_CHANGE, handleEvents, tPtr);
WMCreateEventHandler(tPtr->view, ButtonReleaseMask | ButtonPressMask
| KeyReleaseMask | KeyPressMask | Button1MotionMask, handleActionEvents, tPtr);
WMCreateEventHandler(tPtr->view, WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS
| WM_EVMASK_KEY_RELEASE | WM_EVMASK_KEY_PRESS | WM_EVMASK_BUTTON1_MOTION, handleActionEvents, tPtr);
WMAddNotificationObserver(ownershipObserver, tPtr, WMSelectionOwnerDidChangeNotification, tPtr);

6
WINGs/wtextfield.c
View File

@ -346,7 +346,7 @@ WMTextField *WMCreateTextField(WMWidget * parent)
tPtr->flags.enabled = 1;
WMCreateEventHandler(tPtr->view, ExposureMask | StructureNotifyMask | FocusChangeMask, handleEvents, tPtr);
WMCreateEventHandler(tPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY | WM_EVMASK_FOCUS_CHANGE, handleEvents, tPtr);
tPtr->font = WMRetainFont(tPtr->view->screen->normalFont);
@ -357,8 +357,8 @@ WMTextField *WMCreateTextField(WMWidget * parent)
W_ResizeView(tPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
WMCreateEventHandler(tPtr->view, EnterWindowMask | LeaveWindowMask
| ButtonReleaseMask | ButtonPressMask | KeyPressMask | Button1MotionMask,
WMCreateEventHandler(tPtr->view, WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW
| WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS | WM_EVMASK_KEY_PRESS | WM_EVMASK_BUTTON1_MOTION,
handleTextFieldActionEvents, tPtr);
WMAddNotificationObserver(selectionNotification, tPtr->view,

8
WINGs/wview.c
View File

@ -64,10 +64,10 @@ static const XSetWindowAttributes defAtts = {
(unsigned)~0, /* backing_planes */
0, /* backing_pixel */
False, /* save_under */
KeyPressMask|KeyReleaseMask|ButtonPressMask|ButtonReleaseMask|
EnterWindowMask|LeaveWindowMask|PointerMotionMask|ExposureMask|
VisibilityChangeMask|FocusChangeMask|PropertyChangeMask|
SubstructureNotifyMask, /* event_mask */
WM_EVMASK_KEY_PRESS|WM_EVMASK_KEY_RELEASE|WM_EVMASK_BUTTON_PRESS|WM_EVMASK_BUTTON_RELEASE|
WM_EVMASK_ENTER_WINDOW|WM_EVMASK_LEAVE_WINDOW|WM_EVMASK_POINTER_MOTION|WM_EVMASK_EXPOSURE|
WM_EVMASK_VISIBILITY_CHANGE|WM_EVMASK_FOCUS_CHANGE|WM_EVMASK_PROPERTY_CHANGE|
WM_EVMASK_SUBSTRUCTURE_NOTIFY, /* event_mask */
0, /* do_not_propagate_mask */
False, /* override_redirect */
None, /* colormap */

4
WINGs/wview_wl.c
View File

@ -582,7 +582,7 @@ static void wl_drag_begin(void *vctx, W_View *view, WMEvent *event)
/* Wait for motion to confirm drag */
WMEvent ev;
WMMaskEvent(scr, ButtonMotionMask | ButtonReleaseMask, &ev);
WMMaskEvent(scr, WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE, &ev);
if (ev.type != WME_MOTION)
return;
@ -597,7 +597,7 @@ static void wl_drag_begin(void *vctx, W_View *view, WMEvent *event)
int done = 0;
while (!done) {
WMMaskEvent(scr, ButtonMotionMask | ButtonReleaseMask, &ev);
WMMaskEvent(scr, WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE, &ev);
switch (ev.type) {
case WME_MOTION:
/* Find view under cursor */

2
WINGs/wview_x11.c
View File

@ -254,7 +254,7 @@ static void x11_pointer_grab(void *vctx, W_View *view, int owner_events, unsigne
{
W_Screen *scr = (W_Screen *)vctx;
XGrabPointer(scr->display, view->window, owner_events,
ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask,
WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_MOTION | WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW,
GrabModeAsync, GrabModeAsync, None, None, time);
}

4
WINGs/wwindow.c
View File

@ -92,8 +92,8 @@ WMWindow *WMCreateWindowWithStyle(WMScreen * screen, const char *name, int style
win->nextPtr = screen->windowList;
screen->windowList = win;
WMCreateEventHandler(win->view, ExposureMask | StructureNotifyMask
| ClientMessageMask | FocusChangeMask, handleEvents, win);
WMCreateEventHandler(win->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY
| ClientMessageMask | WM_EVMASK_FOCUS_CHANGE, handleEvents, win);
W_ResizeView(win->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);

2
WPrefs.app/Appearance.c
View File

@ -1877,7 +1877,7 @@ static void createPanel(Panel * p)
WMSetLabelRelief(panel->prevL, WRSunken);
WMSetLabelImagePosition(panel->prevL, WIPImageOnly);
WMCreateEventHandler(WMWidgetView(panel->prevL), ButtonPressMask, previewClick, panel);
WMCreateEventHandler(WMWidgetView(panel->prevL), WM_EVMASK_BUTTON_PRESS, previewClick, panel);
/* tabview */

2
WPrefs.app/WPrefs.c
View File

@ -137,7 +137,7 @@ static void save(WMWidget * w, void *data)
strncpy(ev.xclient.data.b, "Reconfigure", sizeof(ev.xclient.data.b));
XSendEvent(WMScreenDisplay(WMWidgetScreen(w)),
DefaultRootWindow(WMScreenDisplay(WMWidgetScreen(w))), False, SubstructureRedirectMask, &ev);
DefaultRootWindow(WMScreenDisplay(WMWidgetScreen(w))), False, WM_EVMASK_SUBSTRUCTURE_REDIRECT, &ev);
XFlush(WMScreenDisplay(WMWidgetScreen(w)));
}

6
WPrefs.app/double.c
View File

@ -69,11 +69,11 @@ DoubleTest *CreateDoubleTest(WMWidget * parent, const char *text)
dPtr->text = wstrdup(text);
WMCreateEventHandler(dPtr->view, ExposureMask /* this allows us to know when we should paint */
| StructureNotifyMask, /* this allows us to know things like when we are destroyed */
WMCreateEventHandler(dPtr->view, WM_EVMASK_EXPOSURE /* this allows us to know when we should paint */
| WM_EVMASK_STRUCTURE_NOTIFY, /* this allows us to know things like when we are destroyed */
handleEvents, dPtr);
WMCreateEventHandler(dPtr->view, ButtonPressMask, handleActionEvents, dPtr);
WMCreateEventHandler(dPtr->view, WM_EVMASK_BUTTON_PRESS, handleActionEvents, dPtr);
return dPtr;
}

12
WPrefs.app/editmenu.c
View File

@ -144,10 +144,10 @@ WEditMenuItem *WCreateEditMenuItem(WMWidget * parent, const char *title, Bool is
WMSetWidgetBackgroundColor(iPtr, WMBlackColor(scr));
}
WMCreateEventHandler(iPtr->view, ExposureMask | StructureNotifyMask, handleItemEvents, iPtr);
WMCreateEventHandler(iPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY, handleItemEvents, iPtr);
WMCreateEventHandler(iPtr->view, ButtonPressMask | ButtonReleaseMask
| ButtonMotionMask, handleItemClick, iPtr);
WMCreateEventHandler(iPtr->view, WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_BUTTON_MOTION, handleItemClick, iPtr);
return iPtr;
}
@ -401,7 +401,7 @@ static WEditMenu *makeEditMenu(WMScreen * scr, WMWidget * parent, const char *ti
mPtr->items = WMCreateArray(4);
WMCreateEventHandler(mPtr->view, ExposureMask | StructureNotifyMask, handleEvents, mPtr);
WMCreateEventHandler(mPtr->view, WM_EVMASK_EXPOSURE | WM_EVMASK_STRUCTURE_NOTIFY, handleEvents, mPtr);
if (title != NULL) {
item = WCreateEditMenuItem(mPtr, title, True);
@ -1069,7 +1069,7 @@ static void dragMenu(WEditMenu * menu)
dy = menu->dragY - dy;
XGrabPointer(scr->display, scr->rootWin, False,
ButtonReleaseMask | ButtonMotionMask,
WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_MOTION,
GrabModeAsync, GrabModeAsync, None, scr->defaultCursor, CurrentTime);
if (menu->parent)
@ -1210,7 +1210,7 @@ static void dragItem(WEditMenu * menu, WEditMenuItem * item, Bool copy)
dy = menu->dragY - oriy;
XGrabPointer(dpy, scr->rootWin, False,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_MOTION,
GrabModeAsync, GrabModeAsync, None, scr->defaultCursor, CurrentTime);
if (menu->flags.acceptsDrop)

4
src/actions.c
View File

@ -253,7 +253,7 @@ void wShadeWindow(WWindow *wwin)
wwin->flags.shaded = 1;
wwin->flags.mapped = 0;
/* prevent window withdrawal when getting UnmapNotify */
wm_backend->window_select_events(wwin->client_win, wwin->event_mask & ~StructureNotifyMask);
wm_backend->window_select_events(wwin->client_win, wwin->event_mask & ~WM_EVMASK_STRUCTURE_NOTIFY);
wm_backend->window_unmap(wwin->client_win);
wm_backend->window_select_events(wwin->client_win, wwin->event_mask);
@ -1432,7 +1432,7 @@ void wIconifyWindow(WWindow *wwin)
if (present) {
/* icon creation may take a while */
wm_backend->pointer_grab(wwin->screen_ptr->root_win, WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE,
WCUR_NONE, False, 0);
}

8
src/appicon.c
View File

@ -674,7 +674,7 @@ void appIconMouseDown(WObjDescriptor * desc, WBackendEvent * event)
if (event->u.button.send_event &&
!wm_backend->pointer_grab((WNativeWindow)aicon->icon->core->window, WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NORMAL, True, 0)) {
wwarning("pointer grab failed for appicon menu");
return;
@ -738,7 +738,7 @@ Bool wHandleAppIconMove(WAppIcon *aicon, WMEvent *event)
}
if (!wm_backend->pointer_grab((WNativeWindow)icon->core->window, WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NORMAL, True, 0)) {
wwarning("Pointer grab failed in wHandleAppIconMove");
}
@ -795,8 +795,8 @@ Bool wHandleAppIconMove(WAppIcon *aicon, WMEvent *event)
wm_backend->window_map((WNativeWindow)scr->dock_shadow);
while (1) {
WMMaskEvent(scr->wmscreen, PointerMotionMask | ButtonReleaseMask | ButtonPressMask
| ButtonMotionMask | ExposureMask | EnterWindowMask, &ev);
WMMaskEvent(scr->wmscreen, WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS
| WM_EVMASK_BUTTON_MOTION | WM_EVMASK_EXPOSURE | WM_EVMASK_ENTER_WINDOW, &ev);
wwarning("wHandleAppIconMove: got event type=%d", ev.type);
switch (ev.type) {
case WME_EXPOSE:

2
src/application.c
View File

@ -61,7 +61,7 @@ static WWindow *makeMainWindow(WScreen * scr, Window window)
wDefaultFillAttributes(wwin->wm_instance, wwin->wm_class, &wwin->user_flags,
&wwin->defined_user_flags, True);
wm_backend->window_add_events(window, PropertyChangeMask | StructureNotifyMask);
wm_backend->window_add_events(window, WM_EVMASK_PROPERTY_CHANGE | WM_EVMASK_STRUCTURE_NOTIFY);
}
return wwin;

2
src/backend/backend.h
View File

@ -758,7 +758,7 @@ typedef struct WMBackend {
/*
* Drain all pending ButtonMotion events from the queue without
* processing them. Used to coalesce mouse-move updates.
* Equivalent to: while (XCheckMaskEvent(dpy, ButtonMotionMask, &ev)) ;
* Equivalent to: while (XCheckMaskEvent(dpy, WM_EVMASK_BUTTON_MOTION, &ev)) ;
*/
void (*event_drain_motion)(void);

6
src/backend/wayland/wl_backend.c
View File

@ -7437,13 +7437,13 @@ wl_screen_create_internals(WScreen *scr)
if (wl_state.x_display) {
XSetWindowAttributes attribs;
int vmask = CWEventMask | CWOverrideRedirect;
attribs.event_mask = KeyPressMask | FocusChangeMask;
attribs.event_mask = WM_EVMASK_KEY_PRESS | WM_EVMASK_FOCUS_CHANGE;
attribs.override_redirect = True;
Window xwin = XCreateWindow(wl_state.x_display, DefaultRootWindow(wl_state.x_display),
-10, -10, 4, 4, 0,
0, InputOnly, CopyFromParent, vmask, &attribs);
if (xwin) {
XSelectInput(wl_state.x_display, xwin, KeyPressMask | KeyReleaseMask);
XSelectInput(wl_state.x_display, xwin, WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE);
XMapWindow(wl_state.x_display, xwin);
/* Do NOT call XSetInputFocus here: the window may not be viewable
* yet in XWayland (map is async), triggering BadMatch that perturbs
@ -9031,7 +9031,7 @@ static void wl_client_send_key(WNativeWindow win, unsigned int keycode,
ev.xkey.keycode = keycode;
ev.xkey.state = modifier_mask;
XSendEvent(wl_state.x_display, (Window)win, press ? False : True,
press ? KeyPressMask : KeyReleaseMask, &ev);
press ? WM_EVMASK_KEY_PRESS : WM_EVMASK_KEY_RELEASE, &ev);
}
static int wl_noop_window_exists(WNativeWindow win) { (void)win; return 1; }
static void wl_noop_window_get_colormap(WNativeWindow win, unsigned long *c) { (void)win; (void)c; }

48
src/backend/x11/x11_backend.c
View File

@ -379,9 +379,9 @@ x11_frame_create_toplevel(WScreen *scr,
attribs.background_pixmap = None;
attribs.background_pixel = scr->black_pixel;
attribs.border_pixel = border_pixel;
attribs.event_mask = SubstructureRedirectMask | ButtonPressMask |
ButtonReleaseMask | ButtonMotionMask |
ExposureMask | EnterWindowMask | LeaveWindowMask;
attribs.event_mask = WM_EVMASK_SUBSTRUCTURE_REDIRECT | WM_EVMASK_BUTTON_PRESS |
WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_MOTION |
WM_EVMASK_EXPOSURE | WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW;
attribs.colormap = (Colormap)colormap;
if (wPreferences.use_saveunders) {
@ -408,9 +408,9 @@ x11_frame_create_child(WNativeWindow parent_win, WScreen *scr,
attribs.cursor = wPreferences.cursor[WCUR_NORMAL];
attribs.background_pixmap = None;
attribs.background_pixel = scr->black_pixel;
attribs.event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask |
ButtonReleaseMask | ButtonMotionMask |
ExposureMask | EnterWindowMask | LeaveWindowMask;
attribs.event_mask = WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE | WM_EVMASK_BUTTON_PRESS |
WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_MOTION |
WM_EVMASK_EXPOSURE | WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW;
attribs.colormap = scr->w_colormap;
win = XCreateWindow(dpy, WNW_TO_XID(parent_win),
@ -606,7 +606,7 @@ x11_client_synth_configure(WNativeWindow client_win,
sevent.xconfigure.border_width = border_width;
sevent.xconfigure.above = WNW_TO_XID(above);
sevent.xconfigure.override_redirect = False;
XSendEvent(dpy, WNW_TO_XID(client_win), False, StructureNotifyMask, &sevent);
XSendEvent(dpy, WNW_TO_XID(client_win), False, WM_EVMASK_STRUCTURE_NOTIFY, &sevent);
XFlush(dpy);
}
@ -1001,7 +1001,7 @@ x11_event_drain_motion(void)
{
XEvent ev;
while (XCheckMaskEvent(dpy, ButtonMotionMask, &ev)) ;
while (XCheckMaskEvent(dpy, WM_EVMASK_BUTTON_MOTION, &ev)) ;
}
static void
@ -1180,9 +1180,9 @@ x11_client_adopt_attributes(WNativeWindow win, unsigned long event_mask)
{
XSetWindowAttributes attr;
attr.event_mask = (long)event_mask;
attr.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask
| ButtonMotionMask
| KeyPressMask | KeyReleaseMask;
attr.do_not_propagate_mask = WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_BUTTON_MOTION
| WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE;
attr.save_under = False;
XChangeWindowAttributes(dpy, WNW_TO_XID(win),
CWEventMask | CWDontPropagate | CWSaveUnder,
@ -1709,7 +1709,7 @@ x11_screen_replace_wm(WScreen *scr)
wwarning(_("use the --replace flag to replace it"));
return 0;
}
attribs.event_mask = StructureNotifyMask;
attribs.event_mask = WM_EVMASK_STRUCTURE_NOTIFY;
if (!XChangeWindowAttributes(dpy, wm, CWEventMask, &attribs))
wm = None;
}
@ -1735,7 +1735,7 @@ x11_screen_replace_wm(WScreen *scr)
if (!(wait % 1000000))
wmessage(_("waiting %lus for other window manager to exit"), (timeout - wait) / 1000000L);
if (XCheckWindowEvent(dpy, wm, StructureNotifyMask, &xev))
if (XCheckWindowEvent(dpy, wm, WM_EVMASK_STRUCTURE_NOTIFY, &xev))
if (xev.type == DestroyNotify)
break;
@ -1768,7 +1768,7 @@ x11_screen_replace_wm(WScreen *scr)
event.data.l[3] = 0L;
event.data.l[4] = 0L;
event.window = WNW_TO_XID(scr->root_win);
XSendEvent(dpy, WNW_TO_XID(scr->root_win), False, StructureNotifyMask, (XEvent *)&event);
XSendEvent(dpy, WNW_TO_XID(scr->root_win), False, WM_EVMASK_STRUCTURE_NOTIFY, (XEvent *)&event);
#endif
return 1;
@ -1924,11 +1924,11 @@ x11_screen_create_internals(WScreen *scr)
XSetWindowAttributes attribs;
vmask = CWEventMask | CWOverrideRedirect;
attribs.event_mask = KeyPressMask | FocusChangeMask;
attribs.event_mask = WM_EVMASK_KEY_PRESS | WM_EVMASK_FOCUS_CHANGE;
attribs.override_redirect = True;
scr->no_focus_win = XID_TO_WNW(XCreateWindow(dpy, WNW_TO_XID(scr->root_win), -10, -10, 4, 4, 0,
0, InputOnly, CopyFromParent, vmask, &attribs));
XSelectInput(dpy, WNW_TO_XID(scr->no_focus_win), KeyPressMask | KeyReleaseMask);
XSelectInput(dpy, WNW_TO_XID(scr->no_focus_win), WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE);
XMapWindow(dpy, WNW_TO_XID(scr->no_focus_win));
XSetInputFocus(dpy, WNW_TO_XID(scr->no_focus_win), RevertToParent, CurrentTime);
@ -2137,7 +2137,7 @@ x11_screen_capture_area(WScreen *scr)
XImage *pimg;
if (XGrabPointer(dpy, WNW_TO_XID(scr->root_win), False,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
GrabModeAsync, GrabModeAsync, None,
wPreferences.cursor[WCUR_CAPTURE], CurrentTime) != Success)
return NULL;
@ -2145,8 +2145,8 @@ x11_screen_capture_area(WScreen *scr)
XGrabServer(dpy);
while (!quit) {
WMMaskEvent(scr->wmscreen, ButtonReleaseMask | PointerMotionMask
| ButtonPressMask | KeyPressMask, &event);
WMMaskEvent(scr->wmscreen, WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_POINTER_MOTION
| WM_EVMASK_BUTTON_PRESS | WM_EVMASK_KEY_PRESS, &event);
switch (event.type) {
case WME_BUTTON_PRESS:
@ -3435,7 +3435,7 @@ static void x11_cursor_set(WNativeWindow window, Cursor cursor)
static void x11_pointer_change_cursor(int cursor_id)
{
XChangeActivePointerGrab(dpy, ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
XChangeActivePointerGrab(dpy, WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
wPreferences.cursor[cursor_id], CurrentTime);
}
@ -3604,7 +3604,7 @@ static void x11_client_send_key(WNativeWindow win, unsigned int keycode,
ev.xkey.keycode = keycode;
ev.xkey.state = modifier_mask;
XSendEvent(dpy, (Window)win, press ? False : True,
press ? KeyPressMask : KeyReleaseMask, &ev);
press ? WM_EVMASK_KEY_PRESS : WM_EVMASK_KEY_RELEASE, &ev);
}
static int x11_window_exists(WNativeWindow win)
{
@ -3904,8 +3904,8 @@ static void x11_client_get_colormap_windows(WWindow *wwin)
static void x11_eat_expose(void)
{
XEvent event, foo;
if (XCheckMaskEvent(dpy, ExposureMask, &event)) {
while (XCheckWindowEvent(dpy, event.xexpose.window, ExposureMask, &foo))
if (XCheckMaskEvent(dpy, WM_EVMASK_EXPOSURE, &event)) {
while (XCheckWindowEvent(dpy, event.xexpose.window, WM_EVMASK_EXPOSURE, &foo))
;
x11_eat_expose();
event.xexpose.count = 0;
@ -4423,7 +4423,7 @@ static void x11_switchpanel_send_enter(WNativeWindow info_win, WNativeWindow win
ev.xclient.message_type = w_global.atom.wm.ignore_focus_events;
ev.xclient.format = 32;
ev.xclient.data.l[0] = True;
XSendEvent(dpy, (Window)info_win, True, EnterWindowMask, &ev);
XSendEvent(dpy, (Window)info_win, True, WM_EVMASK_ENTER_WINDOW, &ev);
(void)window;
}

4
src/cycling.c
View File

@ -143,8 +143,8 @@ void StartWindozeCycle(WWindow *wwin, WMEvent *event, Bool next, Bool class_only
}
while (hasModifier && !done) {
WMMaskEvent(scr->wmscreen, KeyPressMask | KeyReleaseMask | ExposureMask
| PointerMotionMask | ButtonReleaseMask | EnterWindowMask, &ev);
WMMaskEvent(scr->wmscreen, WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE | WM_EVMASK_EXPOSURE
| WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_ENTER_WINDOW, &ev);
/* ignore CapsLock */
modifiers = ev.u.key.state & w_global.shortcut.modifiers_mask;

10
src/dialog.c
View File

@ -445,13 +445,13 @@ int wAdvancedInputDialog(WScreen *scr, const char *title, const char *message, c
p->rest = NULL;
p->variants = NULL;
p->varpos = 0;
WMCreateEventHandler(WMWidgetView(p->panel->text), KeyPressMask, handleHistoryKeyPress, p);
WMCreateEventHandler(WMWidgetView(p->panel->text), WM_EVMASK_KEY_PRESS, handleHistoryKeyPress, p);
pwidth = WMWidgetWidth(p->panel->win);
pheight = WMWidgetHeight(p->panel->win);
parent = (Window)wm_backend->fake_leader_create(scr);
wm_backend->window_resize((WNativeWindow)parent, pwidth, pheight);
wm_backend->window_select_events((WNativeWindow)parent, KeyPressMask | KeyReleaseMask);
wm_backend->window_select_events((WNativeWindow)parent, WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE);
wm_backend->client_reparent((WNativeWindow)WMWidgetXID(p->panel->win), (WNativeWindow)parent, 0, 0);
@ -508,7 +508,7 @@ int wInputDialog(WScreen *scr, const char *title, const char *message, char **te
parent = (Window)wm_backend->fake_leader_create(scr);
wm_backend->window_resize((WNativeWindow)parent, pwidth, pheight);
wm_backend->window_select_events((WNativeWindow)parent, KeyPressMask | KeyReleaseMask);
wm_backend->window_select_events((WNativeWindow)parent, WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE);
wm_backend->client_reparent((WNativeWindow)WMWidgetXID(panel->win), (WNativeWindow)parent, 0, 0);
@ -932,7 +932,7 @@ Bool wIconChooserDialog(WScreen *scr, char **file, const char *instance, const c
pheight = WMScaleY(280);
WMResizeWidget(panel->win, pwidth, pheight);
WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask | KeyReleaseMask, keyPressHandler, panel);
WMCreateEventHandler(WMWidgetView(panel->win), WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE, keyPressHandler, panel);
boldFont = WMBoldSystemFontOfSize(scr->wmscreen, WMScaleY(12));
panel->normalfont = WMSystemFontOfSize(WMWidgetScreen(panel->win), WMScaleY(12));
@ -1789,7 +1789,7 @@ int wShowCrashingDialogPanel(int whatSig)
panel->done = 0;
WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask, handleKeyPress, panel);
WMCreateEventHandler(WMWidgetView(panel->win), WM_EVMASK_KEY_PRESS, handleKeyPress, panel);
WMRealizeWidget(panel->win);
WMMapSubwidgets(panel->win);

10
src/dock.c
View File

@ -3595,7 +3595,7 @@ static void handleDockMove(WDock *dock, WAppIcon *aicon, WMEvent *event)
Pixmap ghost = None;
int superfluous = wPreferences.superfluous; /* we catch it to avoid problems */
if (!wm_backend->pointer_grab((WNativeWindow)aicon->icon->core->window, WNATIVE_NONE, ButtonMotionMask | ButtonReleaseMask | ButtonPressMask, WCUR_NORMAL, True, 0))
if (!wm_backend->pointer_grab((WNativeWindow)aicon->icon->core->window, WNATIVE_NONE, WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS, WCUR_NORMAL, True, 0))
@ -3624,8 +3624,8 @@ static void handleDockMove(WDock *dock, WAppIcon *aicon, WMEvent *event)
previous_x_pos = dock->x_pos;
done = 0;
while (!done) {
WMMaskEvent(scr->wmscreen, PointerMotionMask | ButtonReleaseMask | ButtonPressMask
| ButtonMotionMask | ExposureMask | EnterWindowMask, &ev);
WMMaskEvent(scr->wmscreen, WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS
| WM_EVMASK_BUTTON_MOTION | WM_EVMASK_EXPOSURE | WM_EVMASK_ENTER_WINDOW, &ev);
switch (ev.type) {
case WME_EXPOSE:
WMHandleEvent(&ev);
@ -3826,7 +3826,7 @@ static void handleClipChangeWorkspace(WScreen *scr, WMEvent *event)
wClipIconPaint(scr->clip_icon);
done = 0;
while (!done) {
WMMaskEvent(scr->wmscreen, ExposureMask | ButtonMotionMask | ButtonReleaseMask | ButtonPressMask, &ev);
WMMaskEvent(scr->wmscreen, WM_EVMASK_EXPOSURE | WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS, &ev);
switch (ev.type) {
case WME_EXPOSE:
WMHandleEvent(&ev);
@ -3949,7 +3949,7 @@ static void iconMouseDown(WObjDescriptor *desc, WBackendEvent *event)
wClipMakeIconOmnipresent(aicon, !aicon->omnipresent);
} else if (event->u.button.button == Button3) {
if (event->u.button.send_event &&
!wm_backend->pointer_grab((WNativeWindow)aicon->icon->core->window, WNATIVE_NONE, ButtonMotionMask | ButtonReleaseMask | ButtonPressMask, WCUR_NORMAL, True, 0)) {
!wm_backend->pointer_grab((WNativeWindow)aicon->icon->core->window, WNATIVE_NONE, WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS, WCUR_NORMAL, True, 0)) {

2
src/dockedapp.c
View File

@ -368,7 +368,7 @@ void ShowDockAppSettingsPanel(WAppIcon * aicon)
parent = (Window)wm_backend->fake_leader_create(scr);
wm_backend->window_resize((WNativeWindow)parent, pwidth, pheight);
wm_backend->window_select_events((WNativeWindow)parent, KeyPressMask | KeyReleaseMask);
wm_backend->window_select_events((WNativeWindow)parent, WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE);
wm_backend->client_reparent((WNativeWindow)WMWidgetXID(panel->win), (WNativeWindow)parent, 0, 0);

4
src/framewin.c
View File

@ -1205,8 +1205,8 @@ static void buttonMouseDown(WObjDescriptor * desc, WBackendEvent * event)
paintButton(button, texture, pixel, image, True);
while (!done) {
WMMaskEvent(fwin->core->screen_ptr->wmscreen, LeaveWindowMask | EnterWindowMask | ButtonReleaseMask
| ButtonPressMask | ExposureMask, &ev);
WMMaskEvent(fwin->core->screen_ptr->wmscreen, WM_EVMASK_LEAVE_WINDOW | WM_EVMASK_ENTER_WINDOW | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_BUTTON_PRESS | WM_EVMASK_EXPOSURE, &ev);
switch (ev.type) {
case WME_LEAVE:
execute = 0;

2
src/geomview.c
View File

@ -67,7 +67,7 @@ WGeometryView *WCreateGeometryView(WMScreen * scr)
gview->bgColor = WMCreateRGBColor(scr, 0x3333, 0x6666, 0x9999, True);
gview->color = WMWhiteColor(scr);
WMCreateEventHandler(gview->view, ExposureMask, handleEvents, gview);
WMCreateEventHandler(gview->view, WM_EVMASK_EXPOSURE, handleEvents, gview);
snprintf(buffer, sizeof(buffer), "%+05i, %+05i", 0, 0);

10
src/icon.c
View File

@ -758,9 +758,9 @@ static void set_dockapp_in_icon(WIcon *icon)
/* Needed to move the icon clicking on the application part */
if (wm_backend->window_get_event_mask((WNativeWindow)icon->icon_win) &&
ButtonPressMask)
WM_EVMASK_BUTTON_PRESS)
wHackedGrabButton(Button1, MOD_MASK, icon->core->window, True,
ButtonPressMask, GrabModeSync, GrabModeAsync,
WM_EVMASK_BUTTON_PRESS, GrabModeSync, GrabModeAsync,
None, wPreferences.cursor[WCUR_ARROW]);
}
@ -901,11 +901,11 @@ static void miniwindowMouseDown(WObjDescriptor *desc, WBackendEvent *event)
}
wm_backend->pointer_grab((WNativeWindow)icon->core->window, WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NORMAL, False, 0);
while (1) {
WMMaskEvent(wwin->screen_ptr->wmscreen, PointerMotionMask | ButtonReleaseMask | ButtonPressMask
| ButtonMotionMask | ExposureMask, &ev);
WMMaskEvent(wwin->screen_ptr->wmscreen, WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS
| WM_EVMASK_BUTTON_MOTION | WM_EVMASK_EXPOSURE, &ev);
switch (ev.type) {
case WME_EXPOSE:
WMHandleEvent(&ev);

10
src/menu.c
View File

@ -727,8 +727,8 @@ static int keyboardMenu(WMenu * menu)
while (!done && menu->flags.mapped) {
wm_backend->event_allow_async();
WMMaskEvent(menu->frame->screen_ptr->wmscreen, ExposureMask | ButtonMotionMask | ButtonPressMask
| ButtonReleaseMask | KeyPressMask | KeyReleaseMask | SubstructureNotifyMask, &event);
WMMaskEvent(menu->frame->screen_ptr->wmscreen, WM_EVMASK_EXPOSURE | WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_PRESS
| WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE | WM_EVMASK_SUBSTRUCTURE_NOTIFY, &event);
switch (event.type) {
case WME_KEY_PRESS:
@ -1710,7 +1710,7 @@ static void menuMouseDown(WObjDescriptor * desc, WBackendEvent * event)
wm_backend->event_allow_async();
WMMaskEvent(scr->wmscreen, ExposureMask | ButtonMotionMask | ButtonReleaseMask | ButtonPressMask, &ev);
WMMaskEvent(scr->wmscreen, WM_EVMASK_EXPOSURE | WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS, &ev);
switch (ev.type) {
case WME_MOTION:
smenu = findMenu(scr, &x, &y);
@ -2068,7 +2068,7 @@ static void menuTitleMouseDown(WCoreWindow * sender, void *data, WMEvent * event
started = False;
while (1) {
WMMaskEvent(menu->frame->screen_ptr->wmscreen, ButtonMotionMask | ButtonReleaseMask | ButtonPressMask | ExposureMask, &ev);
WMMaskEvent(menu->frame->screen_ptr->wmscreen, WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS | WM_EVMASK_EXPOSURE, &ev);
switch (ev.type) {
case WME_MOTION:
if (started) {
@ -2081,7 +2081,7 @@ static void menuTitleMouseDown(WCoreWindow * sender, void *data, WMEvent * event
if (abs(ev.u.motion.x_root - dx) > MOVE_THRESHOLD
|| abs(ev.u.motion.y_root - dy) > MOVE_THRESHOLD) {
started = True;
wm_backend->pointer_grab((WNativeWindow)menu->frame->titlebar->window, WNATIVE_NONE, ButtonMotionMask | ButtonReleaseMask | ButtonPressMask, WCUR_MOVE, False, 0);
wm_backend->pointer_grab((WNativeWindow)menu->frame->titlebar->window, WNATIVE_NONE, WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS, WCUR_MOVE, False, 0);

42
src/moveres.c
View File

@ -550,7 +550,7 @@ static void crossWorkspace(WScreen * scr, WWindow * wwin, int opaque_move, int n
if (!opaque_move) {
wm_backend->pointer_grab(scr->root_win, WNATIVE_NONE,
PointerMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_MOVE, True, 0);
}
}
@ -1381,7 +1381,7 @@ int wKeyboardMoveResizeWindow(WWindow * wwin)
}
wm_backend->server_grab();
wm_backend->pointer_grab(scr->root_win, WNATIVE_NONE,
PointerMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NORMAL, True, 0);
@ -1408,8 +1408,8 @@ int wKeyboardMoveResizeWindow(WWindow * wwin)
looper.oy=off_y;
*/
do {
WMMaskEvent(scr->wmscreen, KeyPressMask | ButtonReleaseMask
| ButtonPressMask | ExposureMask, &event);
WMMaskEvent(scr->wmscreen, WM_EVMASK_KEY_PRESS | WM_EVMASK_BUTTON_RELEASE
| WM_EVMASK_BUTTON_PRESS | WM_EVMASK_EXPOSURE, &event);
if (event.type == WME_EXPOSE) {
WMHandleEvent(&event);
}
@ -1735,9 +1735,9 @@ int wMouseMoveWindow(WWindow * wwin, WMEvent * ev)
wm_backend->pointer_query(root, &event.u.motion.x_root,
&event.u.motion.y_root);
} else {
WMMaskEvent(scr->wmscreen, KeyPressMask | ButtonMotionMask
| PointerMotionHintMask
| ButtonReleaseMask | ButtonPressMask | ExposureMask, &event);
WMMaskEvent(scr->wmscreen, WM_EVMASK_KEY_PRESS | WM_EVMASK_BUTTON_MOTION
| WM_EVMASK_POINTER_MOTION_HINT
| WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS | WM_EVMASK_EXPOSURE, &event);
if (event.type == WME_MOTION) {
/* compress MotionNotify events */
@ -1869,7 +1869,7 @@ int wMouseMoveWindow(WWindow * wwin, WMEvent * ev)
}
wm_backend->pointer_change_grab(
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_MOVE, 0);
started = 1;
wm_backend->keyboard_grab(root);
@ -2081,8 +2081,8 @@ void wMouseResizeWindow(WWindow * wwin, WMEvent * ev)
shiftr = wm_backend->keysym_to_keycode(WM_KEY_SHIFT_R);
while (1) {
WMMaskEvent(scr->wmscreen, KeyPressMask | ButtonMotionMask
| ButtonReleaseMask | PointerMotionHintMask | ButtonPressMask | ExposureMask, &event);
WMMaskEvent(scr->wmscreen, WM_EVMASK_KEY_PRESS | WM_EVMASK_BUTTON_MOTION
| WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_POINTER_MOTION_HINT | WM_EVMASK_BUTTON_PRESS | WM_EVMASK_EXPOSURE, &event);
if (!checkMouseSamplingRate(&event))
continue;
@ -2160,31 +2160,31 @@ void wMouseResizeWindow(WWindow * wwin, WMEvent * ev)
if (res == (UP | LEFT))
wm_backend->pointer_change_grab(
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_TOPLEFTRESIZE, 0);
else if (res == (UP | RIGHT))
wm_backend->pointer_change_grab(
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_TOPRIGHTRESIZE, 0);
else if (res == (DOWN | LEFT))
wm_backend->pointer_change_grab(
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_BOTTOMLEFTRESIZE, 0);
else if (res == (DOWN | RIGHT))
wm_backend->pointer_change_grab(
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_BOTTOMRIGHTRESIZE, 0);
else if (res == DOWN || res == UP)
wm_backend->pointer_change_grab(
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_VERTICALRESIZE, 0);
else if (res & (DOWN | UP))
wm_backend->pointer_change_grab(
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_VERTICALRESIZE, 0);
else if (res & (LEFT | RIGHT))
wm_backend->pointer_change_grab(
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_HORIZONRESIZE, 0);
wm_backend->keyboard_grab(root);
@ -2320,7 +2320,7 @@ void wSelectWindows(WScreen * scr, int xp, int yp)
int x = xp, y = yp;
if (!wm_backend->pointer_grab(scr->root_win, WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NORMAL, False, 0)) {
return;
}
@ -2330,7 +2330,7 @@ void wSelectWindows(WScreen * scr, int xp, int yp)
wm_backend->overlay_draw_rect(scr, xp, yp, w, h);
while (1) {
WMMaskEvent(scr->wmscreen, ButtonReleaseMask | PointerMotionMask | ButtonPressMask, &event);
WMMaskEvent(scr->wmscreen, WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_PRESS, &event);
switch (event.type) {
case WME_MOTION:
@ -2379,7 +2379,7 @@ void InteractivePlaceWindow(WWindow * wwin, int *x_ret, int *y_ret, unsigned wid
unsigned int shiftl, shiftr;
if (!wm_backend->pointer_grab(root, WNATIVE_NONE,
PointerMotionMask | ButtonPressMask,
WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_PRESS,
WCUR_NORMAL, True, 0)) {
*x_ret = 0;
*y_ret = 0;
@ -2409,7 +2409,7 @@ void InteractivePlaceWindow(WWindow * wwin, int *x_ret, int *y_ret, unsigned wid
shiftl = wm_backend->keysym_to_keycode(WM_KEY_SHIFT_L);
shiftr = wm_backend->keysym_to_keycode(WM_KEY_SHIFT_R);
while (1) {
WMMaskEvent(scr->wmscreen, PointerMotionMask | ButtonPressMask | ExposureMask | KeyPressMask, &event);
WMMaskEvent(scr->wmscreen, WM_EVMASK_POINTER_MOTION | WM_EVMASK_BUTTON_PRESS | WM_EVMASK_EXPOSURE | WM_EVMASK_KEY_PRESS, &event);
if (!checkMouseSamplingRate(&event))
continue;

8
src/screen.c
View File

@ -57,10 +57,10 @@
#include "defaults.h"
#define EVENT_MASK (LeaveWindowMask|EnterWindowMask|PropertyChangeMask\
|SubstructureNotifyMask|PointerMotionMask \
|SubstructureRedirectMask|ButtonPressMask|ButtonReleaseMask\
|KeyPressMask|KeyReleaseMask)
#define EVENT_MASK (WM_EVMASK_LEAVE_WINDOW|WM_EVMASK_ENTER_WINDOW|WM_EVMASK_PROPERTY_CHANGE\
|WM_EVMASK_SUBSTRUCTURE_NOTIFY|WM_EVMASK_POINTER_MOTION \
|WM_EVMASK_SUBSTRUCTURE_REDIRECT|WM_EVMASK_BUTTON_PRESS|WM_EVMASK_BUTTON_RELEASE\
|WM_EVMASK_KEY_PRESS|WM_EVMASK_KEY_RELEASE)
static WMPropList *dApplications = NULL;
static WMPropList *dWorkspace;

30
src/window.c
View File

@ -527,7 +527,7 @@ static void fixLeaderProperties(WWindow *wwin)
/* Make sure we get notification when this window is destroyed */
wm_backend->window_add_events(window,
StructureNotifyMask | PropertyChangeMask);
WM_EVMASK_STRUCTURE_NOTIFY | WM_EVMASK_PROPERTY_CHANGE);
}
}
@ -1147,7 +1147,7 @@ WWindow *wManageWindow(WScreen *scr, WNativeWindow window)
wwin->frame->on_mousedown_resizebar = resizebarMouseDown;
wm_backend->window_select_events(wwin->client_win,
wwin->event_mask & ~StructureNotifyMask);
wwin->event_mask & ~WM_EVMASK_STRUCTURE_NOTIFY);
wm_backend->client_reparent(wwin->client_win, wwin->frame->core->window,
0, wwin->frame->top_width);
wm_backend->window_select_events(wwin->client_win, wwin->event_mask);
@ -1495,7 +1495,7 @@ void wUnmanageWindow(WWindow *wwin, Bool restore, Bool destroyed)
* DestroyNotify and PropertyNotify. */
if (wApplicationOf(wwin->client_win))
wm_backend->window_select_events(wwin->client_win,
StructureNotifyMask | PropertyChangeMask);
WM_EVMASK_STRUCTURE_NOTIFY | WM_EVMASK_PROPERTY_CHANGE);
else
wm_backend->window_select_events(wwin->client_win, NoEventMask);
@ -1638,7 +1638,7 @@ void wWindowMap(WWindow *wwin)
if (!wwin->flags.shaded) {
/* window will be remapped when getting MapNotify */
wm_backend->window_select_events(wwin->client_win,
wwin->event_mask & ~StructureNotifyMask);
wwin->event_mask & ~WM_EVMASK_STRUCTURE_NOTIFY);
wm_backend->window_map(wwin->client_win);
wm_backend->window_select_events(wwin->client_win, wwin->event_mask);
@ -1652,7 +1652,7 @@ void wWindowUnmap(WWindow *wwin)
/* prevent window withdrawal when getting UnmapNotify */
wm_backend->window_select_events(wwin->client_win,
wwin->event_mask & ~StructureNotifyMask);
wwin->event_mask & ~WM_EVMASK_STRUCTURE_NOTIFY);
wm_backend->window_unmap(wwin->client_win);
wm_backend->window_select_events(wwin->client_win, wwin->event_mask);
@ -2362,7 +2362,7 @@ void wWindowResetMouseGrabs(WWindow * wwin)
if (!WFLAGP(wwin, no_bind_mouse)) {
/* grabs for Meta+drag */
wm_backend->button_grab(wwin->client_win, WM_ANY_BUTTON, MOD_MASK,
ButtonPressMask | ButtonReleaseMask, True);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE, True);
/* for CTRL+Wheel to Scroll Horiz, we have to grab CTRL as well
* but we only grab it for Button4 and Button 5 since a lot of apps
@ -2370,13 +2370,13 @@ void wWindowResetMouseGrabs(WWindow * wwin)
*/
if (wPreferences.resize_increment > 0) {
wm_backend->button_grab(wwin->client_win, Button4, WM_MOD_CONTROL,
ButtonPressMask | ButtonReleaseMask, True);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE, True);
wm_backend->button_grab(wwin->client_win, Button5, WM_MOD_CONTROL,
ButtonPressMask | ButtonReleaseMask, True);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE, True);
wm_backend->button_grab(wwin->client_win, Button4, MOD_MASK | WM_MOD_CONTROL,
ButtonPressMask | ButtonReleaseMask, True);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE, True);
wm_backend->button_grab(wwin->client_win, Button5, MOD_MASK | WM_MOD_CONTROL,
ButtonPressMask | ButtonReleaseMask, True);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE, True);
}
}
@ -2384,7 +2384,7 @@ void wWindowResetMouseGrabs(WWindow * wwin)
&& !wwin->flags.is_gnustep) {
/* the passive grabs to focus the window */
wm_backend->button_grab(wwin->client_win, WM_ANY_BUTTON, WM_ANY_MODIFIER,
ButtonPressMask | ButtonReleaseMask, True);
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE, True);
}
wm_backend->event_flush();
}
@ -2575,7 +2575,7 @@ static void resizebarMouseDown(WCoreWindow *sender, void *data, WMEvent *event)
if (event->u.button.window != wwin->frame->resizebar->window) {
if (!wm_backend->pointer_grab(wwin->frame->resizebar->window, WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NONE, 1, 0)) {
return;
}
@ -2702,7 +2702,7 @@ static void frameMouseDown(WObjDescriptor *desc, WBackendEvent *event)
if (event->u.button.state & MOD_MASK) {
/* move the window */
if (!wm_backend->pointer_grab(wwin->client_win, WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NONE, 0, 0)) {
return;
}
@ -2758,7 +2758,7 @@ static void titlebarMouseDown(WCoreWindow *sender, void *data, WMEvent *event)
}
if (event->u.button.window != wwin->frame->titlebar->window
&& !wm_backend->pointer_grab(wwin->frame->titlebar->window, WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NONE, 0, 0)) {
return;
}
@ -2773,7 +2773,7 @@ static void titlebarMouseDown(WCoreWindow *sender, void *data, WMEvent *event)
if (event->u.button.window != wwin->frame->titlebar->window
&& !wm_backend->pointer_grab(wwin->frame->titlebar->window, WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NONE, 0, 0)) {
return;
}

6
src/window.h
View File

@ -43,9 +43,9 @@
#define BORDER_ALL (1|2|4|8)
#define CLIENT_EVENTS (StructureNotifyMask | PropertyChangeMask\
| EnterWindowMask | LeaveWindowMask | ColormapChangeMask \
| FocusChangeMask | VisibilityChangeMask)
#define CLIENT_EVENTS (WM_EVMASK_STRUCTURE_NOTIFY | WM_EVMASK_PROPERTY_CHANGE\
| WM_EVMASK_ENTER_WINDOW | WM_EVMASK_LEAVE_WINDOW | WM_EVMASK_COLORMAP_CHANGE \
| WM_EVMASK_FOCUS_CHANGE | WM_EVMASK_VISIBILITY_CHANGE)
typedef enum {
WFM_PASSIVE, WFM_NO_INPUT, WFM_LOCALLY_ACTIVE, WFM_GLOBALLY_ACTIVE

6
src/winspector.c
View File

@ -1024,13 +1024,13 @@ static void selectWindow(WMWidget *bPtr, void *data)
(void) bPtr;
if (!wm_backend->pointer_grab((WNativeWindow)scr->root_win, WNATIVE_NONE,
ButtonPressMask, WCUR_SELECT, True, 0)) {
WM_EVMASK_BUTTON_PRESS, WCUR_SELECT, True, 0)) {
wwarning("could not grab mouse pointer");
return;
}
WMSetLabelText(panel->specLbl, _("Click in the window you wish to inspect."));
WMMaskEvent(scr->wmscreen, ButtonPressMask, &event);
WMMaskEvent(scr->wmscreen, WM_EVMASK_BUTTON_PRESS, &event);
wm_backend->pointer_ungrab(0);
{
@ -1219,7 +1219,7 @@ static InspectorPanel *createInspectorForWindow(WWindow *wwin, int xpos, int ypo
parent = (Window)wm_backend->fake_leader_create(scr);
wm_backend->window_resize((WNativeWindow)parent, PWIDTH, PHEIGHT);
wm_backend->window_select_events((WNativeWindow)parent, KeyPressMask | KeyReleaseMask);
wm_backend->window_select_events((WNativeWindow)parent, WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE);
panel->parent = parent;
wm_backend->client_reparent((WNativeWindow)WMWidgetXID(panel->win), (WNativeWindow)parent, 0, 0);

6
src/wsmap.c
View File

@ -477,13 +477,13 @@ static void handle_event(WWorkspaceMap *wsmap, W_WorkspaceMap *wsmap_array)
wm_backend->keyboard_grab((WNativeWindow)WMWidgetXID(wsmap->win));
wm_backend->pointer_grab((WNativeWindow)WMWidgetXID(wsmap->win), WNATIVE_NONE,
ButtonMotionMask | ButtonReleaseMask | ButtonPressMask,
WM_EVMASK_BUTTON_MOTION | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_BUTTON_PRESS,
WCUR_NORMAL, True, 0);
w_global.process_workspacemap_event = True;
while (w_global.process_workspacemap_event) {
WMMaskEvent(wsmap->scr->wmscreen, KeyPressMask | KeyReleaseMask | ExposureMask | PointerMotionMask |
ButtonPressMask | ButtonReleaseMask | EnterWindowMask | FocusChangeMask, &ev);
WMMaskEvent(wsmap->scr->wmscreen, WM_EVMASK_KEY_PRESS | WM_EVMASK_KEY_RELEASE | WM_EVMASK_EXPOSURE | WM_EVMASK_POINTER_MOTION |
WM_EVMASK_BUTTON_PRESS | WM_EVMASK_BUTTON_RELEASE | WM_EVMASK_ENTER_WINDOW | WM_EVMASK_FOCUS_CHANGE, &ev);
modifiers = ev.u.key.state & w_global.shortcut.modifiers_mask;