andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use C99 designated initializers in extension Events

Browse Source 
Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com>
Reviewed-by: Keith Packard <keithp@keithp.com>
Tested-by: Daniel Stone <daniel@fooishbar.org>
This commit is contained in:
Alan Coopersmith 2012-07-09 19:12:44 -07:00 committed by Keith Packard
parent 0af79b124e
commit 9805cedf7b
23 changed files with 320 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
Xext/saver.c
View File

@ -406,7 +406,6 @@ SendScreenSaverNotify(ScreenPtr pScreen, int state, Bool forced)
ScreenSaverScreenPrivatePtr pPriv;
ScreenSaverEventPtr pEv;
unsigned long mask;
xScreenSaverNotifyEvent ev;
int kind;
UpdateCurrentTimeIf();
@ -424,16 +423,18 @@ SendScreenSaverNotify(ScreenPtr pScreen, int state, Bool forced)
else
kind = ScreenSaverInternal;
for (pEv = pPriv->events; pEv; pEv = pEv->next) {
if (!(pEv->mask & mask))
continue;
ev.type = ScreenSaverNotify + ScreenSaverEventBase;
ev.state = state;
ev.timestamp = currentTime.milliseconds;
ev.root = pScreen->root->drawable.id;
ev.window = pScreen->screensaver.wid;
ev.kind = kind;
ev.forced = forced;
WriteEventsToClient(pEv->client, 1, (xEvent *) &ev);
if (pEv->mask & mask) {
xScreenSaverNotifyEvent ev = {
.type = ScreenSaverNotify + ScreenSaverEventBase,
.state = state,
.timestamp = currentTime.milliseconds,
.root = pScreen->root->drawable.id,
.window = pScreen->screensaver.wid,
.kind = kind,
.forced = forced
};
WriteEventsToClient(pEv->client, 1, (xEvent *) &ev);
}
}
}

8
Xext/security.c
View File

@ -192,10 +192,10 @@ SecurityDeleteAuthorization(pointer value, XID id)
while ((pEventClient = pAuth->eventClients)) {
/* send revocation event event */
xSecurityAuthorizationRevokedEvent are;
are.type = SecurityEventBase + XSecurityAuthorizationRevoked;
are.authId = pAuth->id;
xSecurityAuthorizationRevokedEvent are = {
.type = SecurityEventBase + XSecurityAuthorizationRevoked,
.authId = pAuth->id
};
WriteEventsToClient(rClient(pEventClient), 1, (xEvent *) &are);
FreeResource(pEventClient->resource, RT_NONE);
}

21
Xext/shape.c
View File

@ -826,7 +826,6 @@ void
SendShapeNotify(WindowPtr pWin, int which)
{
ShapeEventPtr *pHead, pShapeEvent;
xShapeNotifyEvent se;
BoxRec extents;
RegionPtr region;
BYTE shaped;
@ -883,15 +882,17 @@ SendShapeNotify(WindowPtr pWin, int which)
return;
}
for (pShapeEvent = *pHead; pShapeEvent; pShapeEvent = pShapeEvent->next) {
se.type = ShapeNotify + ShapeEventBase;
se.kind = which;
se.window = pWin->drawable.id;
se.x = extents.x1;
se.y = extents.y1;
se.width = extents.x2 - extents.x1;
se.height = extents.y2 - extents.y1;
se.time = currentTime.milliseconds;
se.shaped = shaped;
xShapeNotifyEvent se = {
.type = ShapeNotify + ShapeEventBase,
.kind = which,
.window = pWin->drawable.id,
.x = extents.x1,
.y = extents.y1,
.width = extents.x2 - extents.x1,
.height = extents.y2 - extents.y1,
.time = currentTime.milliseconds,
.shaped = shaped
};
WriteEventsToClient(pShapeEvent->client, 1, (xEvent *) &se);
}
}

16
Xext/shm.c
View File

@ -595,14 +595,14 @@ ProcShmPutImage(ClientPtr client)
stuff->dstX, stuff->dstY, shmdesc->addr + stuff->offset);
if (stuff->sendEvent) {
xShmCompletionEvent ev;
ev.type = ShmCompletionCode;
ev.drawable = stuff->drawable;
ev.minorEvent = X_ShmPutImage;
ev.majorEvent = ShmReqCode;
ev.shmseg = stuff->shmseg;
ev.offset = stuff->offset;
xShmCompletionEvent ev = {
.type = ShmCompletionCode,
.drawable = stuff->drawable,
.minorEvent = X_ShmPutImage,
.majorEvent = ShmReqCode,
.shmseg = stuff->shmseg,
.offset = stuff->offset
};
WriteEventsToClient(client, 1, (xEvent *) &ev);
}

18
Xext/sync.c
View File

@ -437,9 +437,16 @@ SyncSendAlarmNotifyEvents(SyncAlarm * pAlarm)
UpdateCurrentTime();
ane.type = SyncEventBase + XSyncAlarmNotify;
ane.kind = XSyncAlarmNotify;
ane.alarm = pAlarm->alarm_id;
ane = (xSyncAlarmNotifyEvent) {
.type = SyncEventBase + XSyncAlarmNotify,
.kind = XSyncAlarmNotify,
.alarm = pAlarm->alarm_id,
.alarm_value_hi = XSyncValueHigh32(pTrigger->test_value),
.alarm_value_lo = XSyncValueLow32(pTrigger->test_value),
.time = currentTime.milliseconds,
.state = pAlarm->state
};
if (pTrigger->pSync && SYNC_COUNTER == pTrigger->pSync->type) {
ane.counter_value_hi = XSyncValueHigh32(pCounter->value);
ane.counter_value_lo = XSyncValueLow32(pCounter->value);
@ -449,11 +456,6 @@ SyncSendAlarmNotifyEvents(SyncAlarm * pAlarm)
ane.counter_value_hi = ane.counter_value_lo = 0;
}
ane.alarm_value_hi = XSyncValueHigh32(pTrigger->test_value);
ane.alarm_value_lo = XSyncValueLow32(pTrigger->test_value);
ane.time = currentTime.milliseconds;
ane.state = pAlarm->state;
/* send to owner */
if (pAlarm->events)
WriteEventsToClient(pAlarm->client, 1, (xEvent *) &ane);

16
Xext/xvdisp.c
View File

@ -1029,14 +1029,14 @@ ProcXvShmPutImage(ClientPtr client)
stuff->send_event, stuff->width, stuff->height);
if ((status == Success) && stuff->send_event) {
xShmCompletionEvent ev;
ev.type = ShmCompletionCode;
ev.drawable = stuff->drawable;
ev.minorEvent = xv_ShmPutImage;
ev.majorEvent = XvReqCode;
ev.shmseg = stuff->shmseg;
ev.offset = stuff->offset;
xShmCompletionEvent ev = {
.type = ShmCompletionCode,
.drawable = stuff->drawable,
.minorEvent = xv_ShmPutImage,
.majorEvent = XvReqCode,
.shmseg = stuff->shmseg,
.offset = stuff->offset
};
WriteEventsToClient(client, 1, (xEvent *) &ev);
}

26
Xext/xvmain.c
View File

@ -507,19 +507,20 @@ XvdiDestroyEncoding(pointer value, XID id)
static int
XvdiSendVideoNotify(XvPortPtr pPort, DrawablePtr pDraw, int reason)
{
xvEvent event;
XvVideoNotifyPtr pn;
dixLookupResourceByType((pointer *) &pn, pDraw->id, XvRTVideoNotifyList,
serverClient, DixReadAccess);
while (pn) {
xvEvent event = {
.u.videoNotify.reason = reason,
.u.videoNotify.time = currentTime.milliseconds,
.u.videoNotify.drawable = pDraw->id,
.u.videoNotify.port = pPort->id
};
event.u.u.type = XvEventBase + XvVideoNotify;
event.u.videoNotify.time = currentTime.milliseconds;
event.u.videoNotify.drawable = pDraw->id;
event.u.videoNotify.port = pPort->id;
event.u.videoNotify.reason = reason;
WriteEventsToClient(pn->client, 1, (xEventPtr) & event);
WriteEventsToClient(pn->client, 1, (xEventPtr) &event);
pn = pn->next;
}
@ -530,18 +531,19 @@ XvdiSendVideoNotify(XvPortPtr pPort, DrawablePtr pDraw, int reason)
int
XvdiSendPortNotify(XvPortPtr pPort, Atom attribute, INT32 value)
{
xvEvent event;
XvPortNotifyPtr pn;
pn = pPort->pNotify;
while (pn) {
xvEvent event = {
.u.portNotify.time = currentTime.milliseconds,
.u.portNotify.port = pPort->id,
.u.portNotify.attribute = attribute,
.u.portNotify.value = value
};
event.u.u.type = XvEventBase + XvPortNotify;
event.u.portNotify.time = currentTime.milliseconds;
event.u.portNotify.port = pPort->id;
event.u.portNotify.attribute = attribute;
event.u.portNotify.value = value;
WriteEventsToClient(pn->client, 1, (xEventPtr) & event);
WriteEventsToClient(pn->client, 1, (xEventPtr) &event);
pn = pn->next;
}

13
Xi/chgdctl.c
View File

@ -113,7 +113,6 @@ ProcXChangeDeviceControl(ClientPtr client)
AxisInfoPtr a;
CARD32 *resolution;
xDeviceEnableCtl *e;
devicePresenceNotify dpn;
REQUEST(xChangeDeviceControlReq);
REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
@ -211,11 +210,13 @@ ProcXChangeDeviceControl(ClientPtr client)
out:
if (ret == Success) {
dpn.type = DevicePresenceNotify;
dpn.time = currentTime.milliseconds;
dpn.devchange = DeviceControlChanged;
dpn.deviceid = dev->id;
dpn.control = stuff->control;
devicePresenceNotify dpn = {
.type = DevicePresenceNotify,
.time = currentTime.milliseconds,
.devchange = DeviceControlChanged,
.deviceid = dev->id,
.control = stuff->control
};
SendEventToAllWindows(dev, DevicePresenceNotifyMask,
(xEvent *) &dpn, 1);

15
Xi/grabdevb.c
View File

@ -137,13 +137,14 @@ ProcXGrabDeviceButton(ClientPtr client)
X_GrabDeviceButton)) != Success)
return ret;
memset(&param, 0, sizeof(param));
param.grabtype = XI;
param.ownerEvents = stuff->ownerEvents;
param.this_device_mode = stuff->this_device_mode;
param.other_devices_mode = stuff->other_devices_mode;
param.grabWindow = stuff->grabWindow;
param.modifiers = stuff->modifiers;
param = (GrabParameters) {
.grabtype = XI,
.ownerEvents = stuff->ownerEvents,
.this_device_mode = stuff->this_device_mode,
.other_devices_mode = stuff->other_devices_mode,
.grabWindow = stuff->grabWindow,
.modifiers = stuff->modifiers
};
mask.xi = tmp[stuff->grabbed_device].mask;
ret = GrabButton(client, dev, mdev, stuff->button, &param, XI, &mask);

15
Xi/grabdevk.c
View File

@ -135,13 +135,14 @@ ProcXGrabDeviceKey(ClientPtr client)
X_GrabDeviceKey)) != Success)
return ret;
memset(&param, 0, sizeof(param));
param.grabtype = XI;
param.ownerEvents = stuff->ownerEvents;
param.this_device_mode = stuff->this_device_mode;
param.other_devices_mode = stuff->other_devices_mode;
param.grabWindow = stuff->grabWindow;
param.modifiers = stuff->modifiers;
param = (GrabParameters) {
.grabtype = XI,
.ownerEvents = stuff->ownerEvents,
.this_device_mode = stuff->this_device_mode,
.other_devices_mode = stuff->other_devices_mode,
.grabWindow = stuff->grabWindow,
.modifiers = stuff->modifiers
};
mask.xi = tmp[stuff->grabbed_device].mask;
ret = GrabKey(client, dev, mdev, stuff->key, &param, XI, &mask);

39
Xi/xiproperty.c
View File

@ -182,30 +182,27 @@ static long XIPropHandlerID = 1;
static void
send_property_event(DeviceIntPtr dev, Atom property, int what)
{
devicePropertyNotify event;
xXIPropertyEvent xi2;
int state;
int state = (what == XIPropertyDeleted) ? PropertyDelete : PropertyNewValue;
devicePropertyNotify event = {
.type = DevicePropertyNotify,
.deviceid = dev->id,
.state = state,
.atom = property,
.time = currentTime.milliseconds
};
xXIPropertyEvent xi2 = {
.type = GenericEvent,
.extension = IReqCode,
.length = 0,
.evtype = XI_PropertyEvent,
.deviceid = dev->id,
.time = currentTime.milliseconds,
.property = property,
.what = what
};
if (what == XIPropertyDeleted)
state = PropertyDelete;
else
state = PropertyNewValue;
event.type = DevicePropertyNotify;
event.deviceid = dev->id;
event.state = state;
event.atom = property;
event.time = currentTime.milliseconds;
SendEventToAllWindows(dev, DevicePropertyNotifyMask, (xEvent *) &event, 1);
xi2.type = GenericEvent;
xi2.extension = IReqCode;
xi2.length = 0;
xi2.evtype = XI_PropertyEvent;
xi2.deviceid = dev->id;
xi2.time = currentTime.milliseconds;
xi2.property = property;
xi2.what = what;
SendEventToAllWindows(dev, GetEventFilter(dev, (xEvent *) &xi2),
(xEvent *) &xi2, 1);
}

20
damageext/damageext.c
View File

@ -46,15 +46,17 @@ DamageExtNotify(DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
int i;
UpdateCurrentTimeIf();
ev.type = DamageEventBase + XDamageNotify;
ev.level = pDamageExt->level;
ev.drawable = pDamageExt->drawable;
ev.damage = pDamageExt->id;
ev.timestamp = currentTime.milliseconds;
ev.geometry.x = pDrawable->x;
ev.geometry.y = pDrawable->y;
ev.geometry.width = pDrawable->width;
ev.geometry.height = pDrawable->height;
ev = (xDamageNotifyEvent) {
.type = DamageEventBase + XDamageNotify,
.level = pDamageExt->level,
.drawable = pDamageExt->drawable,
.damage = pDamageExt->id,
.timestamp = currentTime.milliseconds,
.geometry.x = pDrawable->x,
.geometry.y = pDrawable->y,
.geometry.width = pDrawable->width,
.geometry.height = pDrawable->height
};
if (pBoxes) {
for (i = 0; i < nBoxes; i++) {
ev.level = pDamageExt->level;

5
glx/glxdri2.c
View File

@ -178,12 +178,13 @@ __glXdriSwapEvent(ClientPtr client, void *data, int type, CARD64 ust,
CARD64 msc, CARD32 sbc)
{
__GLXdrawable *drawable = data;
xGLXBufferSwapComplete2 wire;
xGLXBufferSwapComplete2 wire = {
.type = __glXEventBase + GLX_BufferSwapComplete
};
if (!(drawable->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
return;
wire.type = __glXEventBase + GLX_BufferSwapComplete;
switch (type) {
case DRI2_EXCHANGE_COMPLETE:
wire.event_type = GLX_EXCHANGE_COMPLETE_INTEL;

120
hw/xfree86/common/xf86DGA.c
View File

@ -900,15 +900,16 @@ DGAStealKeyEvent(DeviceIntPtr dev, int index, int key_code, int is_down)
if (!pScreenPriv || !pScreenPriv->grabKeyboard) /* no direct mode */
return FALSE;
memset(&event, 0, sizeof(event));
event.header = ET_Internal;
event.type = ET_DGAEvent;
event.length = sizeof(event);
event.time = GetTimeInMillis();
event.subtype = (is_down ? ET_KeyPress : ET_KeyRelease);
event.detail = key_code;
event.dx = 0;
event.dy = 0;
event = (DGAEvent) {
.header = ET_Internal,
.type = ET_DGAEvent,
.length = sizeof(event),
.time = GetTimeInMillis(),
.subtype = (is_down ? ET_KeyPress : ET_KeyRelease),
.detail = key_code,
.dx = 0,
.dy = 0
};
mieqEnqueue(dev, (InternalEvent *) &event);
return TRUE;
@ -928,15 +929,16 @@ DGAStealMotionEvent(DeviceIntPtr dev, int index, int dx, int dy)
if (!pScreenPriv || !pScreenPriv->grabMouse) /* no direct mode */
return FALSE;
memset(&event, 0, sizeof(event));
event.header = ET_Internal;
event.type = ET_DGAEvent;
event.length = sizeof(event);
event.time = GetTimeInMillis();
event.subtype = ET_Motion;
event.detail = 0;
event.dx = dx;
event.dy = dy;
event = (DGAEvent) {
.header = ET_Internal,
.type = ET_DGAEvent,
.length = sizeof(event),
.time = GetTimeInMillis(),
.subtype = ET_Motion,
.detail = 0,
.dx = dx,
.dy = dy
};
mieqEnqueue(dev, (InternalEvent *) &event);
return TRUE;
}
@ -955,15 +957,16 @@ DGAStealButtonEvent(DeviceIntPtr dev, int index, int button, int is_down)
if (!pScreenPriv || !pScreenPriv->grabMouse)
return FALSE;
memset(&event, 0, sizeof(event));
event.header = ET_Internal;
event.type = ET_DGAEvent;
event.length = sizeof(event);
event.time = GetTimeInMillis();
event.subtype = (is_down ? ET_ButtonPress : ET_ButtonRelease);
event.detail = button;
event.dx = 0;
event.dy = 0;
event = (DGAEvent) {
.header = ET_Internal,
.type = ET_DGAEvent,
.length = sizeof(event),
.time = GetTimeInMillis(),
.subtype = (is_down ? ET_ButtonPress : ET_ButtonRelease),
.detail = button,
.dx = 0,
.dy = 0
};
mieqEnqueue(dev, (InternalEvent *) &event);
return TRUE;
@ -988,16 +991,15 @@ DGAProcessKeyboardEvent(ScreenPtr pScreen, DGAEvent * event, DeviceIntPtr keybd)
KeyClassPtr keyc = keybd->key;
DGAScreenPtr pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);
DeviceIntPtr pointer = GetMaster(keybd, POINTER_OR_FLOAT);
DeviceEvent ev;
memset(&ev, 0, sizeof(ev));
ev.header = ET_Internal;
ev.length = sizeof(ev);
ev.detail.key = event->detail;
ev.type = event->subtype;
ev.root_x = 0;
ev.root_y = 0;
ev.corestate = XkbStateFieldFromRec(&keyc->xkbInfo->state);
DeviceEvent ev = {
.header = ET_Internal,
.length = sizeof(ev),
.detail.key = event->detail,
.type = event->subtype,
.root_x = 0,
.root_y = 0,
.corestate = XkbStateFieldFromRec(&keyc->xkbInfo->state)
};
ev.corestate |= pointer->button->state;
UpdateDeviceState(keybd, &ev);
@ -1006,15 +1008,15 @@ DGAProcessKeyboardEvent(ScreenPtr pScreen, DGAEvent * event, DeviceIntPtr keybd)
* Deliver the DGA event
*/
if (pScreenPriv->client) {
dgaEvent de;
dgaEvent de = {
.u.event.time = event->time,
.u.event.dx = event->dx,
.u.event.dy = event->dy,
.u.event.screen = pScreen->myNum,
.u.event.state = ev.corestate
};
de.u.u.type = *XDGAEventBase + GetCoreType(ev.type);
de.u.u.detail = event->detail;
de.u.event.time = event->time;
de.u.event.dx = event->dx;
de.u.event.dy = event->dy;
de.u.event.screen = pScreen->myNum;
de.u.event.state = ev.corestate;
/* If the DGA client has selected input, then deliver based on the usual filter */
TryClientEvents(pScreenPriv->client, keybd, (xEvent *) &de, 1,
@ -1039,14 +1041,14 @@ DGAProcessPointerEvent(ScreenPtr pScreen, DGAEvent * event, DeviceIntPtr mouse)
{
ButtonClassPtr butc = mouse->button;
DGAScreenPtr pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);
DeviceEvent ev;
DeviceIntPtr master = GetMaster(mouse, MASTER_KEYBOARD);
DeviceEvent ev = {
.header = ET_Internal,
.length = sizeof(ev),
.type = event->subtype,
.corestate = butc ? butc->state : 0
};
memset(&ev, 0, sizeof(ev));
ev.header = ET_Internal;
ev.length = sizeof(ev);
ev.type = event->subtype;
ev.corestate = butc ? butc->state : 0;
if (master && master->key)
ev.corestate |= XkbStateFieldFromRec(&master->key->xkbInfo->state);
@ -1056,18 +1058,16 @@ DGAProcessPointerEvent(ScreenPtr pScreen, DGAEvent * event, DeviceIntPtr mouse)
* Deliver the DGA event
*/
if (pScreenPriv->client) {
dgaEvent de;
int coreEquiv;
coreEquiv = GetCoreType(ev.type);
int coreEquiv = GetCoreType(ev.type);
dgaEvent de = {
.u.event.time = event->time,
.u.event.dx = event->dx,
.u.event.dy = event->dy,
.u.event.screen = pScreen->myNum,
.u.event.state = ev.corestate
};
de.u.u.type = *XDGAEventBase + coreEquiv;
de.u.u.detail = event->detail;
de.u.event.time = event->time;
de.u.event.dx = event->dx;
de.u.event.dy = event->dy;
de.u.event.screen = pScreen->myNum;
de.u.event.state = ev.corestate;
/* If the DGA client has selected input, then deliver based on the usual filter */
TryClientEvents(pScreenPriv->client, mouse, (xEvent *) &de, 1,

21
hw/xfree86/dixmods/extmod/xf86vmode.c
View File

@ -240,7 +240,6 @@ static void
SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced)
{
XF86VidModeScreenPrivatePtr pPriv;
XF86VidModeEventPtr pEv;
unsigned long mask;
xXF86VidModeNotifyEvent ev;
int kind;
@ -253,15 +252,17 @@ SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced)
return;
kind = XF86VidModeModeChange;
for (pEv = pPriv->events; pEv; pEv = pEv->next) {
if (!(pEv->mask & mask))
continue;
ev.type = XF86VidModeNotify + XF86VidModeEventBase;
ev.state = state;
ev.timestamp = currentTime.milliseconds;
ev.root = pScreen->root->drawable.id;
ev.kind = kind;
ev.forced = forced;
WriteEventsToClient(pEv->client, 1, (xEvent *) &ev);
if (pEv->mask & mask) {
XF86VidModeEventPtr pEv = {
.type = XF86VidModeNotify + XF86VidModeEventBase,
.state = state,
.timestamp = currentTime.milliseconds,
.root = pScreen->root->drawable.id,
.kind = kind,
.forced = forced
};
WriteEventsToClient(pEv->client, 1, (xEvent *) &ev);
}
}
}

28
hw/xfree86/dri2/dri2ext.c
View File

@ -161,11 +161,11 @@ ProcDRI2Authenticate(ClientPtr client)
static void
DRI2InvalidateBuffersEvent(DrawablePtr pDraw, void *priv, XID id)
{
xDRI2InvalidateBuffers event;
ClientPtr client = priv;
event.type = DRI2EventBase + DRI2_InvalidateBuffers;
event.drawable = id;
xDRI2InvalidateBuffers event = {
.type = DRI2EventBase + DRI2_InvalidateBuffers,
.drawable = id
};
WriteEventsToClient(client, 1, (xEvent *) &event);
}
@ -363,17 +363,17 @@ static void
DRI2SwapEvent(ClientPtr client, void *data, int type, CARD64 ust, CARD64 msc,
CARD32 sbc)
{
xDRI2BufferSwapComplete2 event;
DrawablePtr pDrawable = data;
event.type = DRI2EventBase + DRI2_BufferSwapComplete;
event.event_type = type;
event.drawable = pDrawable->id;
event.ust_hi = (CARD64) ust >> 32;
event.ust_lo = ust & 0xffffffff;
event.msc_hi = (CARD64) msc >> 32;
event.msc_lo = msc & 0xffffffff;
event.sbc = sbc;
xDRI2BufferSwapComplete2 event = {
.type = DRI2EventBase + DRI2_BufferSwapComplete,
.event_type = type,
.drawable = pDrawable->id,
.ust_hi = (CARD64) ust >> 32,
.ust_lo = ust & 0xffffffff,
.msc_hi = (CARD64) msc >> 32,
.msc_lo = msc & 0xffffffff,
.sbc = sbc
};
WriteEventsToClient(client, 1, (xEvent *) &event);
}

34
randr/rrcrtc.c
View File

@ -236,29 +236,21 @@ RRDeliverCrtcEvent(ClientPtr client, WindowPtr pWin, RRCrtcPtr crtc)
ScreenPtr pScreen = pWin->drawable.pScreen;
rrScrPriv(pScreen);
xRRCrtcChangeNotifyEvent ce;
RRModePtr mode = crtc->mode;
ce.type = RRNotify + RREventBase;
ce.subCode = RRNotify_CrtcChange;
ce.timestamp = pScrPriv->lastSetTime.milliseconds;
ce.window = pWin->drawable.id;
ce.crtc = crtc->id;
ce.rotation = crtc->rotation;
if (mode) {
ce.mode = mode->mode.id;
ce.x = crtc->x;
ce.y = crtc->y;
ce.width = mode->mode.width;
ce.height = mode->mode.height;
}
else {
ce.mode = None;
ce.x = 0;
ce.y = 0;
ce.width = 0;
ce.height = 0;
}
xRRCrtcChangeNotifyEvent ce = {
.type = RRNotify + RREventBase,
.subCode = RRNotify_CrtcChange,
.timestamp = pScrPriv->lastSetTime.milliseconds,
.window = pWin->drawable.id,
.crtc = crtc->id,
.mode = mode ? mode->mode.id : None,
.rotation = crtc->rotation,
.x = mode ? crtc->x : 0,
.y = mode ? crtc->y : 0,
.width = mode ? mode->mode.width : 0,
.height = mode ? mode->mode.height : 0
};
WriteEventsToClient(client, 1, (xEvent *) &ce);
}

34
randr/rroutput.c
View File

@ -305,28 +305,22 @@ RRDeliverOutputEvent(ClientPtr client, WindowPtr pWin, RROutputPtr output)
ScreenPtr pScreen = pWin->drawable.pScreen;
rrScrPriv(pScreen);
xRROutputChangeNotifyEvent oe;
RRCrtcPtr crtc = output->crtc;
RRModePtr mode = crtc ? crtc->mode : 0;
RRModePtr mode = crtc ? crtc->mode : NULL;
oe.type = RRNotify + RREventBase;
oe.subCode = RRNotify_OutputChange;
oe.timestamp = pScrPriv->lastSetTime.milliseconds;
oe.configTimestamp = pScrPriv->lastConfigTime.milliseconds;
oe.window = pWin->drawable.id;
oe.output = output->id;
if (crtc) {
oe.crtc = crtc->id;
oe.mode = mode ? mode->mode.id : None;
oe.rotation = crtc->rotation;
}
else {
oe.crtc = None;
oe.mode = None;
oe.rotation = RR_Rotate_0;
}
oe.connection = output->connection;
oe.subpixelOrder = output->subpixelOrder;
xRROutputChangeNotifyEvent oe = {
.type = RRNotify + RREventBase,
.subCode = RRNotify_OutputChange,
.timestamp = pScrPriv->lastSetTime.milliseconds,
.configTimestamp = pScrPriv->lastConfigTime.milliseconds,
.window = pWin->drawable.id,
.output = output->id,
.crtc = crtc ? crtc->id : None,
.mode = mode ? mode->mode.id : None,
.rotation = crtc ? crtc->rotation : RR_Rotate_0,
.connection = output->connection,
.subpixelOrder = output->subpixelOrder
};
WriteEventsToClient(client, 1, (xEvent *) &oe);
}

47
randr/rrproperty.c
View File

@ -65,14 +65,14 @@ RRDestroyOutputProperty(RRPropertyPtr prop)
static void
RRDeleteProperty(RROutputRec * output, RRPropertyRec * prop)
{
xRROutputPropertyNotifyEvent event;
event.type = RREventBase + RRNotify;
event.subCode = RRNotify_OutputProperty;
event.output = output->id;
event.state = PropertyDelete;
event.atom = prop->propertyName;
event.timestamp = currentTime.milliseconds;
xRROutputPropertyNotifyEvent event = {
.type = RREventBase + RRNotify,
.subCode = RRNotify_OutputProperty,
.output = output->id,
.state = PropertyDelete,
.atom = prop->propertyName,
.timestamp = currentTime.milliseconds
};
RRDeliverPropertyEvent(output->pScreen, (xEvent *) &event);
@ -138,7 +138,6 @@ RRChangeOutputProperty(RROutputPtr output, Atom property, Atom type,
pointer value, Bool sendevent, Bool pending)
{
RRPropertyPtr prop;
xRROutputPropertyNotifyEvent event;
rrScrPrivPtr pScrPriv = rrGetScrPriv(output->pScreen);
int size_in_bytes;
int total_size;
@ -237,12 +236,14 @@ RRChangeOutputProperty(RROutputPtr output, Atom property, Atom type,
output->pendingProperties = TRUE;
if (sendevent) {
event.type = RREventBase + RRNotify;
event.subCode = RRNotify_OutputProperty;
event.output = output->id;
event.state = PropertyNewValue;
event.atom = prop->propertyName;
event.timestamp = currentTime.milliseconds;
xRROutputPropertyNotifyEvent event = {
.type = RREventBase + RRNotify,
.subCode = RRNotify_OutputProperty,
.output = output->id,
.state = PropertyNewValue,
.atom = prop->propertyName,
.timestamp = currentTime.milliseconds
};
RRDeliverPropertyEvent(output->pScreen, (xEvent *) &event);
}
return Success;
@ -682,14 +683,14 @@ ProcRRGetOutputProperty(ClientPtr client)
reply.propertyType = prop_value->type;
if (stuff->delete && (reply.bytesAfter == 0)) {
xRROutputPropertyNotifyEvent event;
event.type = RREventBase + RRNotify;
event.subCode = RRNotify_OutputProperty;
event.output = output->id;
event.state = PropertyDelete;
event.atom = prop->propertyName;
event.timestamp = currentTime.milliseconds;
xRROutputPropertyNotifyEvent event = {
.type = RREventBase + RRNotify,
.subCode = RRNotify_OutputProperty,
.output = output->id,
.state = PropertyDelete,
.atom = prop->propertyName,
.timestamp = currentTime.milliseconds
};
RRDeliverPropertyEvent(output->pScreen, (xEvent *) &event);
}

41
randr/rrscreen.c
View File

@ -71,20 +71,20 @@ void
RRSendConfigNotify(ScreenPtr pScreen)
{
WindowPtr pWin = pScreen->root;
xEvent event;
event.u.u.type = ConfigureNotify;
event.u.configureNotify.window = pWin->drawable.id;
event.u.configureNotify.aboveSibling = None;
event.u.configureNotify.x = 0;
event.u.configureNotify.y = 0;
xEvent event = {
.u.configureNotify.window = pWin->drawable.id,
.u.configureNotify.aboveSibling = None,
.u.configureNotify.x = 0,
.u.configureNotify.y = 0,
/* XXX xinerama stuff ? */
event.u.configureNotify.width = pWin->drawable.width;
event.u.configureNotify.height = pWin->drawable.height;
event.u.configureNotify.borderWidth = wBorderWidth(pWin);
event.u.configureNotify.override = pWin->overrideRedirect;
.u.configureNotify.width = pWin->drawable.width,
.u.configureNotify.height = pWin->drawable.height,
.u.configureNotify.borderWidth = wBorderWidth(pWin),
.u.configureNotify.override = pWin->overrideRedirect
};
event.u.u.type = ConfigureNotify;
DeliverEvents(pWin, &event, 1, NullWindow);
}
@ -92,19 +92,20 @@ void
RRDeliverScreenEvent(ClientPtr client, WindowPtr pWin, ScreenPtr pScreen)
{
rrScrPriv(pScreen);
xRRScreenChangeNotifyEvent se;
RRCrtcPtr crtc = pScrPriv->numCrtcs ? pScrPriv->crtcs[0] : NULL;
WindowPtr pRoot = pScreen->root;
se.type = RRScreenChangeNotify + RREventBase;
se.rotation = (CARD8) (crtc ? crtc->rotation : RR_Rotate_0);
se.timestamp = pScrPriv->lastSetTime.milliseconds;
se.configTimestamp = pScrPriv->lastConfigTime.milliseconds;
se.root = pRoot->drawable.id;
se.window = pWin->drawable.id;
se.subpixelOrder = PictureGetSubpixelOrder(pScreen);
xRRScreenChangeNotifyEvent se = {
.type = RRScreenChangeNotify + RREventBase,
.rotation = (CARD8) (crtc ? crtc->rotation : RR_Rotate_0),
.timestamp = pScrPriv->lastSetTime.milliseconds,
.configTimestamp = pScrPriv->lastConfigTime.milliseconds,
.root = pRoot->drawable.id,
.window = pWin->drawable.id,
.subpixelOrder = PictureGetSubpixelOrder(pScreen),
se.sizeID = RR10CurrentSizeID(pScreen);
.sizeID = RR10CurrentSizeID(pScreen)
};
if (se.rotation & (RR_Rotate_90 | RR_Rotate_270)) {
se.widthInPixels = pScreen->height;

16
xfixes/cursor.c
View File

@ -172,14 +172,14 @@ CursorDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
CursorCurrent[pDev->id] = pCursor;
for (e = cursorEvents; e; e = e->next) {
if ((e->eventMask & XFixesDisplayCursorNotifyMask)) {
xXFixesCursorNotifyEvent ev;
ev.type = XFixesEventBase + XFixesCursorNotify;
ev.subtype = XFixesDisplayCursorNotify;
ev.window = e->pWindow->drawable.id;
ev.cursorSerial = pCursor ? pCursor->serialNumber : 0;
ev.timestamp = currentTime.milliseconds;
ev.name = pCursor ? pCursor->name : None;
xXFixesCursorNotifyEvent ev = {
.type = XFixesEventBase + XFixesCursorNotify,
.subtype = XFixesDisplayCursorNotify,
.window = e->pWindow->drawable.id,
.cursorSerial = pCursor ? pCursor->serialNumber : 0,
.timestamp = currentTime.milliseconds,
.name = pCursor ? pCursor->name : None
};
WriteEventsToClient(e->pClient, 1, (xEvent *) &ev);
}
}

23
xfixes/select.c
View File

@ -77,19 +77,16 @@ XFixesSelectionCallback(CallbackListPtr *callbacks, pointer data, pointer args)
}
for (e = selectionEvents; e; e = e->next) {
if (e->selection == selection->selection && (e->eventMask & eventMask)) {
xXFixesSelectionNotifyEvent ev;
memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent));
ev.type = XFixesEventBase + XFixesSelectionNotify;
ev.subtype = subtype;
ev.window = e->pWindow->drawable.id;
if (subtype == XFixesSetSelectionOwnerNotify)
ev.owner = selection->window;
else
ev.owner = 0;
ev.selection = e->selection;
ev.timestamp = currentTime.milliseconds;
ev.selectionTimestamp = selection->lastTimeChanged.milliseconds;
xXFixesSelectionNotifyEvent ev = {
.type = XFixesEventBase + XFixesSelectionNotify,
.subtype = subtype,
.window = e->pWindow->drawable.id,
.owner = (subtype == XFixesSetSelectionOwnerNotify) ?
selection->window : 0,
.selection = e->selection,
.timestamp = currentTime.milliseconds,
.selectionTimestamp = selection->lastTimeChanged.milliseconds
};
WriteEventsToClient(e->pClient, 1, (xEvent *) &ev);
}
}

39
xkb/xkbEvents.c
View File

@ -59,8 +59,6 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
int i;
int keymap_changed = 0;
int modmap_changed = 0;
xEvent core_mn;
deviceMappingNotify xi_mn;
CARD32 time = GetTimeInMillis();
if (xkb_event == XkbNewKeyboardNotify) {
@ -78,11 +76,6 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
if (!keymap_changed && !modmap_changed)
return;
core_mn.u.u.type = MappingNotify;
xi_mn.type = DeviceMappingNotify;
xi_mn.deviceid = kbd->id;
xi_mn.time = time;
/* 0 is serverClient. */
for (i = 1; i < currentMaxClients; i++) {
if (!clients[i] || clients[i]->clientState != ClientStateRunning)
@ -106,6 +99,7 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
continue;
if (keymap_changed) {
xEvent core_mn = { .u.u.type = MappingNotify };
core_mn.u.mappingNotify.request = MappingKeyboard;
/* Clip the keycode range to what the client knows about, so it
@ -123,9 +117,12 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
WriteEventsToClient(clients[i], 1, &core_mn);
}
if (modmap_changed) {
core_mn.u.mappingNotify.request = MappingModifier;
core_mn.u.mappingNotify.firstKeyCode = 0;
core_mn.u.mappingNotify.count = 0;
xEvent core_mn = {
.u.mappingNotify.request = MappingModifier,
.u.mappingNotify.firstKeyCode = 0,
.u.mappingNotify.count = 0
};
core_mn.u.u.type = MappingNotify;
WriteEventsToClient(clients[i], 1, &core_mn);
}
}
@ -134,16 +131,26 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
* here? Clients might be upset, but that seems better than the
* alternative of stale keymaps. -ds */
if (keymap_changed) {
xi_mn.request = MappingKeyboard;
xi_mn.firstKeyCode = first_key;
xi_mn.count = num_keys;
deviceMappingNotify xi_mn = {
.type = DeviceMappingNotify,
.deviceid = kbd->id,
.request = MappingKeyboard,
.firstKeyCode = first_key,
.count = num_keys,
.time = time
};
SendEventToAllWindows(kbd, DeviceMappingNotifyMask, (xEvent *) &xi_mn,
1);
}
if (modmap_changed) {
xi_mn.request = MappingModifier;
xi_mn.firstKeyCode = 0;
xi_mn.count = 0;
deviceMappingNotify xi_mn = {
.type = DeviceMappingNotify,
.deviceid = kbd->id,
.request = MappingModifier,
.firstKeyCode = 0,
.count = 0,
.time = time
};
SendEventToAllWindows(kbd, DeviceMappingNotifyMask, (xEvent *) &xi_mn,
1);
}