From 3f553aaceddc9b09363c73d9bea40eaea8164fc4 Mon Sep 17 00:00:00 2001 From: marha Date: Mon, 7 Jan 2013 11:56:06 +0100 Subject: pixman xkbcomp libX11 libXau mesa fontconfig xserver xkeyboard-config git update 7 jan 2013 fontconfig: 17eda89ed2e24a3fc5f68538dd7fd9ada8efb087 xserver: bd91b05b631f13afd1f7a9d6cbc4f0c5408b523a xkeyboard-config: 4779e2745094ebe0c06364b4099d7067ae750d07 libX11: cd25cab4b5b957641183ce72dd1ae0424aff1663 libXau: e04364efccbb3bb4cfc5f4cb491ffa1faaaacbdb mesa: afec10df373f342f058aab66c622237964a4a147 pixman: 35cc965514ca6e665c18411fcf66db826d559c2a xkbcomp: e4f767913338052527538d429931e8abd8c3fb88 --- xorg-server/Xext/saver.c | 2 +- xorg-server/Xi/Makefile.am | 2 + xorg-server/Xi/exevents.c | 47 ++ xorg-server/Xi/extinit.c | 47 +- xorg-server/Xi/gtmotion.c | 2 +- xorg-server/Xi/xibarriers.c | 916 +++++++++++++++++++++ xorg-server/Xi/xibarriers.h | 48 ++ xorg-server/Xi/xichangehierarchy.c | 16 +- xorg-server/Xi/xiquerydevice.c | 4 +- xorg-server/configure.ac | 8 +- xorg-server/dix/colormap.c | 8 +- xorg-server/dix/devices.c | 4 +- xorg-server/dix/dispatch.c | 2 +- xorg-server/dix/eventconvert.c | 45 +- xorg-server/dix/events.c | 26 +- xorg-server/dix/getevents.c | 15 +- xorg-server/dix/grabs.c | 5 +- xorg-server/dix/window.c | 2 +- xorg-server/exa/exa.c | 4 +- xorg-server/fb/fbgc.c | 4 +- xorg-server/glx/glapi.c | 2 +- xorg-server/glx/glxdri.c | 2 +- xorg-server/glx/indirect_program.c | 2 +- xorg-server/glx/indirect_texture_compression.c | 4 +- xorg-server/glx/renderpixswap.c | 20 +- xorg-server/glx/singlepix.c | 18 +- xorg-server/glx/singlepixswap.c | 18 +- xorg-server/glx/xfont.c | 2 +- xorg-server/hw/dmx/config/Canvas.c | 4 +- xorg-server/hw/dmx/dmx_glxvisuals.c | 4 +- xorg-server/hw/dmx/dmxinit.c | 2 +- xorg-server/hw/dmx/dmxwindow.c | 2 +- xorg-server/hw/dmx/examples/xinput.c | 4 +- xorg-server/hw/dmx/glxProxy/glxcmds.c | 16 +- xorg-server/hw/dmx/glxProxy/glxcmdsswap.c | 2 +- xorg-server/hw/dmx/glxProxy/glxscreens.c | 4 +- xorg-server/hw/dmx/glxProxy/glxsingle.c | 6 +- xorg-server/hw/dmx/glxProxy/glxvendor.c | 4 +- xorg-server/hw/dmx/glxProxy/renderpixswap.c | 310 +++---- xorg-server/hw/kdrive/ephyr/XF86dri.c | 18 +- xorg-server/hw/kdrive/ephyr/ephyrdriext.c | 4 +- xorg-server/hw/kdrive/ephyr/ephyrhostglx.c | 10 +- xorg-server/hw/kdrive/ephyr/ephyrhostproxy.c | 2 +- xorg-server/hw/kdrive/ephyr/ephyrhostvideo.c | 4 +- xorg-server/hw/kdrive/ephyr/ephyrvideo.c | 2 +- xorg-server/hw/xfree86/common/xf86cmap.c | 2 +- xorg-server/hw/xfree86/dri/xf86dri.c | 4 +- xorg-server/hw/xfree86/i2c/fi1236.c | 10 +- xorg-server/hw/xfree86/i2c/tda9850.c | 2 +- xorg-server/hw/xquartz/GL/visualConfigs.c | 214 ++--- xorg-server/hw/xquartz/darwin.c | 16 +- xorg-server/hw/xquartz/xpr/xprScreen.c | 5 + xorg-server/hw/xwin/InitOutput.c | 2 +- xorg-server/hw/xwin/glx/indirect.c | 4 +- xorg-server/hw/xwin/winclipboardxevents.c | 6 +- xorg-server/hw/xwin/wincursor.c | 6 +- xorg-server/hw/xwin/winengine.c | 2 +- xorg-server/hw/xwin/wingc.c | 4 +- xorg-server/hw/xwin/winmsg.c | 2 +- xorg-server/hw/xwin/winmultiwindowicons.c | 2 +- xorg-server/hw/xwin/winmultiwindowshape.c | 2 +- xorg-server/hw/xwin/winmultiwindowwndproc.c | 2 +- xorg-server/hw/xwin/winpfbdd.c | 8 +- xorg-server/hw/xwin/winpixmap.c | 2 +- xorg-server/hw/xwin/winscrinit.c | 2 +- xorg-server/hw/xwin/winsetsp.c | 4 +- xorg-server/hw/xwin/winshaddd.c | 8 +- xorg-server/hw/xwin/winshadddnl.c | 10 +- xorg-server/hw/xwin/winshadgdi.c | 2 +- xorg-server/hw/xwin/winwin32rootless.c | 6 +- xorg-server/hw/xwin/winwin32rootlesswndproc.c | 6 +- xorg-server/include/dix-config.h.in | 3 + xorg-server/include/events.h | 1 + xorg-server/include/eventstr.h | 24 +- xorg-server/include/input.h | 6 + xorg-server/include/inputstr.h | 2 +- xorg-server/mi/mieq.c | 4 + xorg-server/mi/miinitext.c | 9 +- xorg-server/mi/mipointer.c | 54 +- xorg-server/mi/mipointer.h | 3 +- xorg-server/os/access.c | 2 +- xorg-server/os/utils.c | 2 +- xorg-server/os/xdmcp.c | 12 +- xorg-server/test/fixes.c | 26 + xorg-server/test/input.c | 2 +- xorg-server/test/xi2/protocol-eventconvert.c | 218 ++++- xorg-server/test/xi2/protocol-xiquerydevice.c | 2 +- xorg-server/test/xi2/protocol-xiselectevents.c | 12 +- xorg-server/xfixes/cursor.c | 432 +--------- xorg-server/xfixes/xfixes.h | 17 +- xorg-server/xkb/xkb.c | 36 +- xorg-server/xkb/xkbout.c | 2 +- xorg-server/xkeyboard-config/rules/base.o_s.part | 2 +- xorg-server/xkeyboard-config/rules/base.xml.in | 4 +- .../rules/compat/layoutsMapping.lst | 1 - xorg-server/xkeyboard-config/symbols/altwin | 13 + xorg-server/xkeyboard-config/symbols/cd | 14 +- xorg-server/xkeyboard-config/symbols/gr | 6 +- 98 files changed, 1940 insertions(+), 975 deletions(-) create mode 100644 xorg-server/Xi/xibarriers.c create mode 100644 xorg-server/Xi/xibarriers.h (limited to 'xorg-server') diff --git a/xorg-server/Xext/saver.c b/xorg-server/Xext/saver.c index f73e2a21f..8de043f8e 100644 --- a/xorg-server/Xext/saver.c +++ b/xorg-server/Xext/saver.c @@ -837,7 +837,7 @@ ScreenSaverSetAttributes(ClientPtr client) if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth)) { fOK = FALSE; for (idepth = 0; idepth < pScreen->numDepths; idepth++) { - pDepth = (DepthPtr) & pScreen->allowedDepths[idepth]; + pDepth = (DepthPtr) &pScreen->allowedDepths[idepth]; if ((depth == pDepth->depth) || (depth == 0)) { for (ivisual = 0; ivisual < pDepth->numVids; ivisual++) { if (visual == pDepth->vids[ivisual]) { diff --git a/xorg-server/Xi/Makefile.am b/xorg-server/Xi/Makefile.am index 69c7886b9..af85bd049 100644 --- a/xorg-server/Xi/Makefile.am +++ b/xorg-server/Xi/Makefile.am @@ -78,6 +78,8 @@ libXi_la_SOURCES = \ ungrdevk.h \ xiallowev.c \ xiallowev.h \ + xibarriers.c \ + xibarriers.h \ xichangecursor.c \ xichangecursor.h \ xichangehierarchy.c \ diff --git a/xorg-server/Xi/exevents.c b/xorg-server/Xi/exevents.c index 4c1aeb4da..58fe49363 100644 --- a/xorg-server/Xi/exevents.c +++ b/xorg-server/Xi/exevents.c @@ -1648,6 +1648,49 @@ ProcessTouchEvent(InternalEvent *ev, DeviceIntPtr dev) UpdateDeviceState(dev, &ev->device_event); } +static void +ProcessBarrierEvent(InternalEvent *e, DeviceIntPtr dev) +{ + Mask filter; + WindowPtr pWin; + BarrierEvent *be = &e->barrier_event; + xEvent *ev; + int rc; + GrabPtr grab = dev->deviceGrab.grab; + + if (!IsMaster(dev)) + return; + + if (dixLookupWindow(&pWin, be->window, serverClient, DixReadAccess) != Success) + return; + + if (grab) + be->flags |= XIBarrierDeviceIsGrabbed; + + rc = EventToXI2(e, &ev); + if (rc != Success) { + ErrorF("[Xi] event conversion from %s failed with code %d\n", __func__, rc); + return; + } + + /* A client has a grab, deliver to this client if the grab_window is the + barrier window. + + Otherwise, deliver normally to the client. + */ + if (grab && + CLIENT_ID(be->barrierid) == CLIENT_ID(grab->resource) && + grab->window->drawable.id == be->window) { + DeliverGrabbedEvent(e, dev, FALSE); + } else { + filter = GetEventFilter(dev, ev); + + DeliverEventsToWindow(dev, pWin, ev, 1, + filter, NullGrab); + } + free(ev); +} + /** * Process DeviceEvents and DeviceChangedEvents. */ @@ -1797,6 +1840,10 @@ ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device) case ET_TouchEnd: ProcessTouchEvent(ev, device); break; + case ET_BarrierHit: + case ET_BarrierLeave: + ProcessBarrierEvent(ev, device); + break; default: ProcessDeviceEvent(ev, device); break; diff --git a/xorg-server/Xi/extinit.c b/xorg-server/Xi/extinit.c index 7e3075551..619d0e468 100644 --- a/xorg-server/Xi/extinit.c +++ b/xorg-server/Xi/extinit.c @@ -122,6 +122,7 @@ SOFTWARE. #include "xiqueryversion.h" #include "xisetclientpointer.h" #include "xiwarppointer.h" +#include "xibarriers.h" /* Masks for XI events have to be aligned with core event (partially anyway). * If DeviceButtonMotionMask is != ButtonMotionMask, event delivery @@ -251,7 +252,8 @@ static int (*ProcIVector[]) (ClientPtr) = { ProcXIChangeProperty, /* 57 */ ProcXIDeleteProperty, /* 58 */ ProcXIGetProperty, /* 59 */ - ProcXIGetSelectedEvents /* 60 */ + ProcXIGetSelectedEvents, /* 60 */ + ProcXIBarrierReleasePointer /* 61 */ }; /* For swapped clients */ @@ -316,7 +318,8 @@ static int (*SProcIVector[]) (ClientPtr) = { SProcXIChangeProperty, /* 57 */ SProcXIDeleteProperty, /* 58 */ SProcXIGetProperty, /* 59 */ - SProcXIGetSelectedEvents /* 60 */ + SProcXIGetSelectedEvents, /* 60 */ + SProcXIBarrierReleasePointer /* 61 */ }; /***************************************************************** @@ -646,7 +649,7 @@ SDeviceChangedEvent(xXIDeviceChangedEvent * from, xXIDeviceChangedEvent * to) *to = *from; memcpy(&to[1], &from[1], from->length * 4); - any = (xXIAnyInfo *) & to[1]; + any = (xXIAnyInfo *) &to[1]; for (i = 0; i < to->num_classes; i++) { int length = any->length; @@ -654,7 +657,7 @@ SDeviceChangedEvent(xXIDeviceChangedEvent * from, xXIDeviceChangedEvent * to) case KeyClass: { xXIKeyInfo *ki = (xXIKeyInfo *) any; - uint32_t *key = (uint32_t *) & ki[1]; + uint32_t *key = (uint32_t *) &ki[1]; for (j = 0; j < ki->num_keycodes; j++, key++) swapl(key); @@ -765,7 +768,7 @@ SDeviceHierarchyEvent(xXIHierarchyEvent * from, xXIHierarchyEvent * to) swapl(&to->flags); swaps(&to->num_info); - info = (xXIHierarchyInfo *) & to[1]; + info = (xXIHierarchyInfo *) &to[1]; for (i = 0; i < from->num_info; i++) { swaps(&info->deviceid); swaps(&info->attachment); @@ -839,6 +842,32 @@ STouchOwnershipEvent(xXITouchOwnershipEvent * from, xXITouchOwnershipEvent * to) swapl(&to->child); } +static void +SBarrierEvent(xXIBarrierEvent * from, + xXIBarrierEvent * to) { + + *to = *from; + + swaps(&from->sequenceNumber); + swapl(&from->length); + swaps(&from->evtype); + swapl(&from->time); + swaps(&from->deviceid); + swaps(&from->sourceid); + swapl(&from->event); + swapl(&from->root); + swapl(&from->root_x); + swapl(&from->root_y); + + swapl(&from->dx.integral); + swapl(&from->dx.frac); + swapl(&from->dy.integral); + swapl(&from->dy.frac); + swapl(&from->dtime); + swapl(&from->barrier); + swapl(&from->eventid); +} + /** Event swapping function for XI2 events. */ void XI2EventSwap(xGenericEvent *from, xGenericEvent *to) @@ -885,6 +914,11 @@ XI2EventSwap(xGenericEvent *from, xGenericEvent *to) case XI_RawTouchEnd: SRawEvent((xXIRawEvent *) from, (xXIRawEvent *) to); break; + case XI_BarrierHit: + case XI_BarrierLeave: + SBarrierEvent((xXIBarrierEvent *) from, + (xXIBarrierEvent *) to); + break; default: ErrorF("[Xi] Unknown event type to swap. This is a bug.\n"); break; @@ -1263,6 +1297,9 @@ XInputExtensionInit(void) if (!AddCallback(&ClientStateCallback, XIClientCallback, 0)) FatalError("Failed to add callback to XI.\n"); + if (!XIBarrierInit()) + FatalError("Could not initialize barriers.\n"); + extEntry = AddExtension(INAME, IEVENTS, IERRORS, ProcIDispatch, SProcIDispatch, IResetProc, StandardMinorOpcode); if (extEntry) { diff --git a/xorg-server/Xi/gtmotion.c b/xorg-server/Xi/gtmotion.c index 4642b194a..cde5351a6 100644 --- a/xorg-server/Xi/gtmotion.c +++ b/xorg-server/Xi/gtmotion.c @@ -131,7 +131,7 @@ ProcXGetDeviceMotionEvents(ClientPtr client) num_events = v->numMotionEvents; if (num_events) { size = sizeof(Time) + (axes * sizeof(INT32)); - rep.nEvents = GetMotionHistory(dev, (xTimecoord **) & coords, /* XXX */ + rep.nEvents = GetMotionHistory(dev, (xTimecoord **) &coords, /* XXX */ start.milliseconds, stop.milliseconds, (ScreenPtr) NULL, FALSE); } diff --git a/xorg-server/Xi/xibarriers.c b/xorg-server/Xi/xibarriers.c new file mode 100644 index 000000000..7b7b83f1c --- /dev/null +++ b/xorg-server/Xi/xibarriers.c @@ -0,0 +1,916 @@ +/* + * Copyright 2012 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Copyright © 2002 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#include "xibarriers.h" +#include "scrnintstr.h" +#include "cursorstr.h" +#include "dixevents.h" +#include "servermd.h" +#include "mipointer.h" +#include "inputstr.h" +#include "windowstr.h" +#include "xace.h" +#include "list.h" +#include "exglobals.h" +#include "eventstr.h" +#include "mi.h" + +RESTYPE PointerBarrierType; + +static DevPrivateKeyRec BarrierScreenPrivateKeyRec; + +#define BarrierScreenPrivateKey (&BarrierScreenPrivateKeyRec) + +typedef struct PointerBarrierClient *PointerBarrierClientPtr; + +struct PointerBarrierDevice { + struct xorg_list entry; + int deviceid; + Time last_timestamp; + int barrier_event_id; + int release_event_id; + Bool hit; + Bool seen; +}; + +struct PointerBarrierClient { + XID id; + ScreenPtr screen; + Window window; + struct PointerBarrier barrier; + struct xorg_list entry; + /* num_devices/device_ids are devices the barrier applies to */ + int num_devices; + int *device_ids; /* num_devices */ + + /* per_device keeps track of devices actually blocked by barriers */ + struct xorg_list per_device; +}; + +typedef struct _BarrierScreen { + struct xorg_list barriers; +} BarrierScreenRec, *BarrierScreenPtr; + +#define GetBarrierScreen(s) ((BarrierScreenPtr)dixLookupPrivate(&(s)->devPrivates, BarrierScreenPrivateKey)) +#define GetBarrierScreenIfSet(s) GetBarrierScreen(s) +#define SetBarrierScreen(s,p) dixSetPrivate(&(s)->devPrivates, BarrierScreenPrivateKey, p) + +static struct PointerBarrierDevice *AllocBarrierDevice(void) +{ + struct PointerBarrierDevice *pbd = NULL; + + pbd = malloc(sizeof(struct PointerBarrierDevice)); + if (!pbd) + return NULL; + + pbd->deviceid = -1; /* must be set by caller */ + pbd->barrier_event_id = 1; + pbd->release_event_id = 0; + pbd->hit = FALSE; + pbd->seen = FALSE; + xorg_list_init(&pbd->entry); + + return pbd; +} + +static void FreePointerBarrierClient(struct PointerBarrierClient *c) +{ + struct PointerBarrierDevice *pbd = NULL, *tmp = NULL; + + xorg_list_for_each_entry_safe(pbd, tmp, &c->per_device, entry) { + free(pbd); + } + free(c); +} + +static struct PointerBarrierDevice *GetBarrierDevice(struct PointerBarrierClient *c, int deviceid) +{ + struct PointerBarrierDevice *pbd = NULL; + + xorg_list_for_each_entry(pbd, &c->per_device, entry) { + if (pbd->deviceid == deviceid) + break; + } + + BUG_WARN(!pbd); + return pbd; +} + +static BOOL +barrier_is_horizontal(const struct PointerBarrier *barrier) +{ + return barrier->y1 == barrier->y2; +} + +static BOOL +barrier_is_vertical(const struct PointerBarrier *barrier) +{ + return barrier->x1 == barrier->x2; +} + +/** + * @return The set of barrier movement directions the movement vector + * x1/y1 → x2/y2 represents. + */ +int +barrier_get_direction(int x1, int y1, int x2, int y2) +{ + int direction = 0; + + /* which way are we trying to go */ + if (x2 > x1) + direction |= BarrierPositiveX; + if (x2 < x1) + direction |= BarrierNegativeX; + if (y2 > y1) + direction |= BarrierPositiveY; + if (y2 < y1) + direction |= BarrierNegativeY; + + return direction; +} + +/** + * Test if the barrier may block movement in the direction defined by + * x1/y1 → x2/y2. This function only tests whether the directions could be + * blocked, it does not test if the barrier actually blocks the movement. + * + * @return TRUE if the barrier blocks the direction of movement or FALSE + * otherwise. + */ +BOOL +barrier_is_blocking_direction(const struct PointerBarrier * barrier, + int direction) +{ + /* Barriers define which way is ok, not which way is blocking */ + return (barrier->directions & direction) != direction; +} + +static BOOL +inside_segment(int v, int v1, int v2) +{ + if (v1 < 0 && v2 < 0) /* line */ + return TRUE; + else if (v1 < 0) /* ray */ + return v <= v2; + else if (v2 < 0) /* ray */ + return v >= v1; + else /* line segment */ + return v >= v1 && v <= v2; +} + +#define T(v, a, b) (((float)v) - (a)) / ((b) - (a)) +#define F(t, a, b) ((t) * ((a) - (b)) + (a)) + +/** + * Test if the movement vector x1/y1 → x2/y2 is intersecting with the + * barrier. A movement vector with the startpoint or endpoint adjacent to + * the barrier itself counts as intersecting. + * + * @param x1 X start coordinate of movement vector + * @param y1 Y start coordinate of movement vector + * @param x2 X end coordinate of movement vector + * @param y2 Y end coordinate of movement vector + * @param[out] distance The distance between the start point and the + * intersection with the barrier (if applicable). + * @return TRUE if the barrier intersects with the given vector + */ +BOOL +barrier_is_blocking(const struct PointerBarrier * barrier, + int x1, int y1, int x2, int y2, double *distance) +{ + if (barrier_is_vertical(barrier)) { + float t, y; + t = T(barrier->x1, x1, x2); + if (t < 0 || t > 1) + return FALSE; + + /* Edge case: moving away from barrier. */ + if (x2 > x1 && t == 0) + return FALSE; + + y = F(t, y1, y2); + if (!inside_segment(y, barrier->y1, barrier->y2)) + return FALSE; + + *distance = sqrt((pow(y - y1, 2) + pow(barrier->x1 - x1, 2))); + return TRUE; + } + else { + float t, x; + t = T(barrier->y1, y1, y2); + if (t < 0 || t > 1) + return FALSE; + + /* Edge case: moving away from barrier. */ + if (y2 > y1 && t == 0) + return FALSE; + + x = F(t, x1, x2); + if (!inside_segment(x, barrier->x1, barrier->x2)) + return FALSE; + + *distance = sqrt((pow(x - x1, 2) + pow(barrier->y1 - y1, 2))); + return TRUE; + } +} + +#define HIT_EDGE_EXTENTS 2 +static BOOL +barrier_inside_hit_box(struct PointerBarrier *barrier, int x, int y) +{ + int x1, x2, y1, y2; + int dir; + + x1 = barrier->x1; + x2 = barrier->x2; + y1 = barrier->y1; + y2 = barrier->y2; + dir = ~(barrier->directions); + + if (barrier_is_vertical(barrier)) { + if (dir & BarrierPositiveX) + x1 -= HIT_EDGE_EXTENTS; + if (dir & BarrierNegativeX) + x2 += HIT_EDGE_EXTENTS; + } + if (barrier_is_horizontal(barrier)) { + if (dir & BarrierPositiveY) + y1 -= HIT_EDGE_EXTENTS; + if (dir & BarrierNegativeY) + y2 += HIT_EDGE_EXTENTS; + } + + return x >= x1 && x <= x2 && y >= y1 && y <= y2; +} + +static BOOL +barrier_blocks_device(struct PointerBarrierClient *client, + DeviceIntPtr dev) +{ + int i; + int master_id; + + /* Clients with no devices are treated as + * if they specified XIAllDevices. */ + if (client->num_devices == 0) + return TRUE; + + master_id = GetMaster(dev, POINTER_OR_FLOAT)->id; + + for (i = 0; i < client->num_devices; i++) { + int device_id = client->device_ids[i]; + if (device_id == XIAllDevices || + device_id == XIAllMasterDevices || + device_id == master_id) + return TRUE; + } + + return FALSE; +} + +/** + * Find the nearest barrier client that is blocking movement from x1/y1 to x2/y2. + * + * @param dir Only barriers blocking movement in direction dir are checked + * @param x1 X start coordinate of movement vector + * @param y1 Y start coordinate of movement vector + * @param x2 X end coordinate of movement vector + * @param y2 Y end coordinate of movement vector + * @return The barrier nearest to the movement origin that blocks this movement. + */ +static struct PointerBarrierClient * +barrier_find_nearest(BarrierScreenPtr cs, DeviceIntPtr dev, + int dir, + int x1, int y1, int x2, int y2) +{ + struct PointerBarrierClient *c, *nearest = NULL; + double min_distance = INT_MAX; /* can't get higher than that in X anyway */ + + xorg_list_for_each_entry(c, &cs->barriers, entry) { + struct PointerBarrier *b = &c->barrier; + struct PointerBarrierDevice *pbd; + double distance; + + pbd = GetBarrierDevice(c, dev->id); + if (pbd->seen) + continue; + + if (!barrier_is_blocking_direction(b, dir)) + continue; + + if (!barrier_blocks_device(c, dev)) + continue; + + if (barrier_is_blocking(b, x1, y1, x2, y2, &distance)) { + if (min_distance > distance) { + min_distance = distance; + nearest = c; + } + } + } + + return nearest; +} + +/** + * Clamp to the given barrier given the movement direction specified in dir. + * + * @param barrier The barrier to clamp to + * @param dir The movement direction + * @param[out] x The clamped x coordinate. + * @param[out] y The clamped x coordinate. + */ +void +barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x, + int *y) +{ + if (barrier_is_vertical(barrier)) { + if ((dir & BarrierNegativeX) & ~barrier->directions) + *x = barrier->x1; + if ((dir & BarrierPositiveX) & ~barrier->directions) + *x = barrier->x1 - 1; + } + if (barrier_is_horizontal(barrier)) { + if ((dir & BarrierNegativeY) & ~barrier->directions) + *y = barrier->y1; + if ((dir & BarrierPositiveY) & ~barrier->directions) + *y = barrier->y1 - 1; + } +} + +void +input_constrain_cursor(DeviceIntPtr dev, ScreenPtr screen, + int current_x, int current_y, + int dest_x, int dest_y, + int *out_x, int *out_y, + int *nevents, InternalEvent* events) +{ + /* Clamped coordinates here refer to screen edge clamping. */ + BarrierScreenPtr cs = GetBarrierScreen(screen); + int x = dest_x, + y = dest_y; + int dir; + struct PointerBarrier *nearest = NULL; + PointerBarrierClientPtr c; + Time ms = GetTimeInMillis(); + BarrierEvent ev = { + .header = ET_Internal, + .type = 0, + .length = sizeof (BarrierEvent), + .time = ms, + .deviceid = dev->id, + .sourceid = dev->id, + .dx = dest_x - current_x, + .dy = dest_y - current_y, + .root = screen->root->drawable.id, + }; + InternalEvent *barrier_events = events; + DeviceIntPtr master; + + if (nevents) + *nevents = 0; + + if (xorg_list_is_empty(&cs->barriers) || IsFloating(dev)) + goto out; + + /** + * This function is only called for slave devices, but pointer-barriers + * are for master-devices only. Flip the device to the master here, + * continue with that. + */ + master = GetMaster(dev, MASTER_POINTER); + + /* How this works: + * Given the origin and the movement vector, get the nearest barrier + * to the origin that is blocking the movement. + * Clamp to that barrier. + * Then, check from the clamped intersection to the original + * destination, again finding the nearest barrier and clamping. + */ + dir = barrier_get_direction(current_x, current_y, x, y); + + while (dir != 0) { + struct PointerBarrierDevice *pbd; + + c = barrier_find_nearest(cs, master, dir, current_x, current_y, x, y); + if (!c) + break; + + nearest = &c->barrier; + + pbd = GetBarrierDevice(c, master->id); + pbd->seen = TRUE; + pbd->hit = TRUE; + + if (pbd->barrier_event_id == pbd->release_event_id) + continue; + + ev.type = ET_BarrierHit; + barrier_clamp_to_barrier(nearest, dir, &x, &y); + + if (barrier_is_vertical(nearest)) { + dir &= ~(BarrierNegativeX | BarrierPositiveX); + current_x = x; + } + else if (barrier_is_horizontal(nearest)) { + dir &= ~(BarrierNegativeY | BarrierPositiveY); + current_y = y; + } + + ev.flags = 0; + ev.event_id = pbd->barrier_event_id; + ev.barrierid = c->id; + + ev.dt = ms - pbd->last_timestamp; + ev.window = c->window; + pbd->last_timestamp = ms; + + /* root x/y is filled in later */ + + barrier_events->barrier_event = ev; + barrier_events++; + *nevents += 1; + } + + xorg_list_for_each_entry(c, &cs->barriers, entry) { + struct PointerBarrierDevice *pbd; + int flags = 0; + + pbd = GetBarrierDevice(c, master->id); + pbd->seen = FALSE; + if (!pbd->hit) + continue; + + if (barrier_inside_hit_box(&c->barrier, x, y)) + continue; + + pbd->hit = FALSE; + + ev.type = ET_BarrierLeave; + + if (pbd->barrier_event_id == pbd->release_event_id) + flags |= XIBarrierPointerReleased; + + ev.flags = flags; + ev.event_id = pbd->barrier_event_id; + ev.barrierid = c->id; + + ev.dt = ms - pbd->last_timestamp; + ev.window = c->window; + pbd->last_timestamp = ms; + + /* root x/y is filled in later */ + + barrier_events->barrier_event = ev; + barrier_events++; + *nevents += 1; + + /* If we've left the hit box, this is the + * start of a new event ID. */ + pbd->barrier_event_id++; + } + + out: + *out_x = x; + *out_y = y; +} + +static void +sort_min_max(INT16 *a, INT16 *b) +{ + INT16 A, B; + if (*a < 0 || *b < 0) + return; + A = *a; + B = *b; + *a = min(A, B); + *b = max(A, B); +} + +static int +CreatePointerBarrierClient(ClientPtr client, + xXFixesCreatePointerBarrierReq * stuff, + PointerBarrierClientPtr *client_out) +{ + WindowPtr pWin; + ScreenPtr screen; + BarrierScreenPtr cs; + int err; + int size; + int i; + struct PointerBarrierClient *ret; + CARD16 *in_devices; + DeviceIntPtr dev; + + size = sizeof(*ret) + sizeof(DeviceIntPtr) * stuff->num_devices; + ret = malloc(size); + + if (!ret) { + return BadAlloc; + } + + xorg_list_init(&ret->per_device); + + err = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess); + if (err != Success) { + client->errorValue = stuff->window; + goto error; + } + + screen = pWin->drawable.pScreen; + cs = GetBarrierScreen(screen); + + ret->screen = screen; + ret->window = stuff->window; + ret->num_devices = stuff->num_devices; + if (ret->num_devices > 0) + ret->device_ids = (int*)&ret[1]; + else + ret->device_ids = NULL; + + in_devices = (CARD16 *) &stuff[1]; + for (i = 0; i < stuff->num_devices; i++) { + int device_id = in_devices[i]; + DeviceIntPtr device; + + if ((err = dixLookupDevice (&device, device_id, + client, DixReadAccess))) { + client->errorValue = device_id; + goto error; + } + + if (!IsMaster (device)) { + client->errorValue = device_id; + err = BadDevice; + goto error; + } + + ret->device_ids[i] = device_id; + } + + /* Alloc one per master pointer, they're the ones that can be blocked */ + xorg_list_init(&ret->per_device); + nt_list_for_each_entry(dev, inputInfo.devices, next) { + struct PointerBarrierDevice *pbd; + + if (dev->type != MASTER_POINTER) + continue; + + pbd = AllocBarrierDevice(); + if (!pbd) { + err = BadAlloc; + goto error; + } + pbd->deviceid = dev->id; + + xorg_list_add(&pbd->entry, &ret->per_device); + } + + ret->id = stuff->barrier; + ret->barrier.x1 = stuff->x1; + ret->barrier.x2 = stuff->x2; + ret->barrier.y1 = stuff->y1; + ret->barrier.y2 = stuff->y2; + sort_min_max(&ret->barrier.x1, &ret->barrier.x2); + sort_min_max(&ret->barrier.y1, &ret->barrier.y2); + ret->barrier.directions = stuff->directions & 0x0f; + if (barrier_is_horizontal(&ret->barrier)) + ret->barrier.directions &= ~(BarrierPositiveX | BarrierNegativeX); + if (barrier_is_vertical(&ret->barrier)) + ret->barrier.directions &= ~(BarrierPositiveY | BarrierNegativeY); + xorg_list_add(&ret->entry, &cs->barriers); + + *client_out = ret; + return Success; + + error: + *client_out = NULL; + FreePointerBarrierClient(ret); + return err; +} + +static int +BarrierFreeBarrier(void *data, XID id) +{ + struct PointerBarrierClient *c; + Time ms = GetTimeInMillis(); + DeviceIntPtr dev = NULL; + ScreenPtr screen; + + c = container_of(data, struct PointerBarrierClient, barrier); + screen = c->screen; + + for (dev = inputInfo.devices; dev; dev = dev->next) { + struct PointerBarrierDevice *pbd; + int root_x, root_y; + BarrierEvent ev = { + .header = ET_Internal, + .type = ET_BarrierLeave, + .length = sizeof (BarrierEvent), + .time = ms, + /* .deviceid */ + .sourceid = 0, + .barrierid = c->id, + .window = c->window, + .root = screen->root->drawable.id, + .dx = 0, + .dy = 0, + /* .root_x */ + /* .root_y */ + /* .dt */ + /* .event_id */ + .flags = XIBarrierPointerReleased, + }; + + + if (dev->type != MASTER_POINTER) + continue; + + pbd = GetBarrierDevice(c, dev->id); + if (!pbd->hit) + continue; + + ev.deviceid = dev->id; + ev.event_id = pbd->barrier_event_id, + ev.dt = ms - pbd->last_timestamp, + + GetSpritePosition(dev, &root_x, &root_y); + ev.root_x = root_x; + ev.root_y = root_y; + + mieqEnqueue(dev, (InternalEvent *) &ev); + } + + xorg_list_del(&c->entry); + + FreePointerBarrierClient(c); + return Success; +} + +static void add_master_func(pointer res, XID id, pointer devid) +{ + struct PointerBarrier *b; + struct PointerBarrierClient *barrier; + struct PointerBarrierDevice *pbd; + int *deviceid = devid; + + b = res; + barrier = container_of(b, struct PointerBarrierClient, barrier); + + + pbd = AllocBarrierDevice(); + pbd->deviceid = *deviceid; + + xorg_list_add(&pbd->entry, &barrier->per_device); +} + +static void remove_master_func(pointer res, XID id, pointer devid) +{ + struct PointerBarrierDevice *pbd; + struct PointerBarrierClient *barrier; + struct PointerBarrier *b; + DeviceIntPtr dev; + int *deviceid = devid; + int rc; + Time ms = GetTimeInMillis(); + + rc = dixLookupDevice(&dev, *deviceid, serverClient, DixSendAccess); + if (rc != Success) + return; + + b = res; + barrier = container_of(b, struct PointerBarrierClient, barrier); + + pbd = GetBarrierDevice(barrier, *deviceid); + + if (pbd->hit) { + BarrierEvent ev = { + .header = ET_Internal, + .type =ET_BarrierLeave, + .length = sizeof (BarrierEvent), + .time = ms, + .deviceid = *deviceid, + .sourceid = 0, + .dx = 0, + .dy = 0, + .root = barrier->screen->root->drawable.id, + .window = barrier->window, + .dt = ms - pbd->last_timestamp, + .flags = XIBarrierPointerReleased, + .event_id = pbd->barrier_event_id, + .barrierid = barrier->id, + }; + + mieqEnqueue(dev, (InternalEvent *) &ev); + } + + xorg_list_del(&pbd->entry); + free(pbd); +} + +void XIBarrierNewMasterDevice(ClientPtr client, int deviceid) +{ + FindClientResourcesByType(client, PointerBarrierType, add_master_func, &deviceid); +} + +void XIBarrierRemoveMasterDevice(ClientPtr client, int deviceid) +{ + FindClientResourcesByType(client, PointerBarrierType, remove_master_func, &deviceid); +} + +int +XICreatePointerBarrier(ClientPtr client, + xXFixesCreatePointerBarrierReq * stuff) +{ + int err; + struct PointerBarrierClient *barrier; + struct PointerBarrier b; + + b.x1 = stuff->x1; + b.x2 = stuff->x2; + b.y1 = stuff->y1; + b.y2 = stuff->y2; + + if (!barrier_is_horizontal(&b) && !barrier_is_vertical(&b)) + return BadValue; + + /* no 0-sized barriers */ + if (barrier_is_horizontal(&b) && barrier_is_vertical(&b)) + return BadValue; + + /* no infinite barriers on the wrong axis */ + if (barrier_is_horizontal(&b) && (b.y1 < 0 || b.y2 < 0)) + return BadValue; + + if (barrier_is_vertical(&b) && (b.x1 < 0 || b.x2 < 0)) + return BadValue; + + if ((err = CreatePointerBarrierClient(client, stuff, &barrier))) + return err; + + if (!AddResource(stuff->barrier, PointerBarrierType, &barrier->barrier)) + return BadAlloc; + + return Success; +} + +int +XIDestroyPointerBarrier(ClientPtr client, + xXFixesDestroyPointerBarrierReq * stuff) +{ + int err; + void *barrier; + + err = dixLookupResourceByType((void **) &barrier, stuff->barrier, + PointerBarrierType, client, DixDestroyAccess); + if (err != Success) { + client->errorValue = stuff->barrier; + return err; + } + + if (CLIENT_ID(stuff->barrier) != client->index) + return BadAccess; + + FreeResource(stuff->barrier, RT_NONE); + return Success; +} + +int +SProcXIBarrierReleasePointer(ClientPtr client) +{ + xXIBarrierReleasePointerInfo *info; + REQUEST(xXIBarrierReleasePointerReq); + int i; + + info = (xXIBarrierReleasePointerInfo*) &stuff[1]; + + swaps(&stuff->length); + swapl(&stuff->num_barriers); + for (i = 0; i < stuff->num_barriers; i++, info++) { + swaps(&info->deviceid); + swapl(&info->barrier); + swapl(&info->eventid); + } + + return (ProcXIBarrierReleasePointer(client)); +} + +int +ProcXIBarrierReleasePointer(ClientPtr client) +{ + int i; + int err; + struct PointerBarrierClient *barrier; + struct PointerBarrier *b; + xXIBarrierReleasePointerInfo *info; + + REQUEST(xXIBarrierReleasePointerReq); + REQUEST_AT_LEAST_SIZE(xXIBarrierReleasePointerReq); + + info = (xXIBarrierReleasePointerInfo*) &stuff[1]; + for (i = 0; i < stuff->num_barriers; i++, info++) { + struct PointerBarrierDevice *pbd; + DeviceIntPtr dev; + CARD32 barrier_id, event_id; + _X_UNUSED CARD32 device_id; + + barrier_id = info->barrier; + event_id = info->eventid; + + err = dixLookupDevice(&dev, info->deviceid, client, DixReadAccess); + if (err != Success) { + client->errorValue = BadDevice; + return err; + } + + err = dixLookupResourceByType((void **) &b, barrier_id, + PointerBarrierType, client, DixReadAccess); + if (err != Success) { + client->errorValue = barrier_id; + return err; + } + + if (CLIENT_ID(barrier_id) != client->index) + return BadAccess; + + + barrier = container_of(b, struct PointerBarrierClient, barrier); + + pbd = GetBarrierDevice(barrier, dev->id); + + if (pbd->barrier_event_id == event_id) + pbd->release_event_id = event_id; + } + + return Success; +} + +Bool +XIBarrierInit(void) +{ + int i; + + if (!dixRegisterPrivateKey(&BarrierScreenPrivateKeyRec, PRIVATE_SCREEN, 0)) + return FALSE; + + for (i = 0; i < screenInfo.numScreens; i++) { + ScreenPtr pScreen = screenInfo.screens[i]; + BarrierScreenPtr cs; + + cs = (BarrierScreenPtr) calloc(1, sizeof(BarrierScreenRec)); + if (!cs) + return FALSE; + xorg_list_init(&cs->barriers); + SetBarrierScreen(pScreen, cs); + } + + PointerBarrierType = CreateNewResourceType(BarrierFreeBarrier, + "XIPointerBarrier"); + + return PointerBarrierType; +} diff --git a/xorg-server/Xi/xibarriers.h b/xorg-server/Xi/xibarriers.h new file mode 100644 index 000000000..11e84ec9f --- /dev/null +++ b/xorg-server/Xi/xibarriers.h @@ -0,0 +1,48 @@ + +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#ifndef _XIBARRIERS_H_ +#define _XIBARRIERS_H_ + +#include "resource.h" + +extern _X_EXPORT RESTYPE PointerBarrierType; + +struct PointerBarrier { + INT16 x1, x2, y1, y2; + CARD32 directions; +}; + +int +barrier_get_direction(int, int, int, int); +BOOL +barrier_is_blocking(const struct PointerBarrier *, int, int, int, int, + double *); +BOOL +barrier_is_blocking_direction(const struct PointerBarrier *, int); +void +barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x, + int *y); + +#include + +int +XICreatePointerBarrier(ClientPtr client, + xXFixesCreatePointerBarrierReq * stuff); + +int +XIDestroyPointerBarrier(ClientPtr client, + xXFixesDestroyPointerBarrierReq * stuff); + +Bool +XIBarrierInit(void); + +int SProcXIBarrierReleasePointer(ClientPtr client); +int ProcXIBarrierReleasePointer(ClientPtr client); + +void XIBarrierNewMasterDevice(ClientPtr client, int deviceid); +void XIBarrierRemoveMasterDevice(ClientPtr client, int deviceid); + +#endif /* _XIBARRIERS_H_ */ diff --git a/xorg-server/Xi/xichangehierarchy.c b/xorg-server/Xi/xichangehierarchy.c index 89f16d8be..e2f4b8a0a 100644 --- a/xorg-server/Xi/xichangehierarchy.c +++ b/xorg-server/Xi/xichangehierarchy.c @@ -52,6 +52,7 @@ #include "xkbsrv.h" #include "xichangehierarchy.h" +#include "xibarriers.h" /** * Send the current state of the device hierarchy to all clients. @@ -79,7 +80,7 @@ XISendDeviceHierarchyEvent(int flags[MAXDEVICES]) ev->flags = 0; ev->num_info = inputInfo.numDevices; - info = (xXIHierarchyInfo *) & ev[1]; + info = (xXIHierarchyInfo *) &ev[1]; for (dev = inputInfo.devices; dev; dev = dev->next) { info->deviceid = dev->id; info->enabled = dev->enabled; @@ -189,6 +190,8 @@ add_master(ClientPtr client, xXIAddMasterInfo * c, int flags[MAXDEVICES]) flags[XTestptr->id] |= XISlaveAttached; flags[XTestkeybd->id] |= XISlaveAttached; + XIBarrierNewMasterDevice(client, ptr->id); + unwind: free(name); return rc; @@ -293,6 +296,8 @@ remove_master(ClientPtr client, xXIRemoveMasterInfo * r, int flags[MAXDEVICES]) } } + XIBarrierRemoveMasterDevice(client, ptr->id); + /* disable the remove the devices, XTest devices must be done first else the sprites they rely on will be destroyed */ DisableDevice(XTestptr, FALSE); @@ -304,15 +309,16 @@ remove_master(ClientPtr client, xXIRemoveMasterInfo * r, int flags[MAXDEVICES]) flags[keybd->id] |= XIDeviceDisabled; flags[ptr->id] |= XIDeviceDisabled; - RemoveDevice(XTestptr, FALSE); - RemoveDevice(XTestkeybd, FALSE); - RemoveDevice(keybd, FALSE); - RemoveDevice(ptr, FALSE); flags[XTestptr->id] |= XISlaveRemoved; flags[XTestkeybd->id] |= XISlaveRemoved; flags[keybd->id] |= XIMasterRemoved; flags[ptr->id] |= XIMasterRemoved; + RemoveDevice(XTestptr, FALSE); + RemoveDevice(XTestkeybd, FALSE); + RemoveDevice(keybd, FALSE); + RemoveDevice(ptr, FALSE); + unwind: return rc; } diff --git a/xorg-server/Xi/xiquerydevice.c b/xorg-server/Xi/xiquerydevice.c index 85c1dd81d..4e544f0f5 100644 --- a/xorg-server/Xi/xiquerydevice.c +++ b/xorg-server/Xi/xiquerydevice.c @@ -304,7 +304,7 @@ ListKeyInfo(DeviceIntPtr dev, xXIKeyInfo * info) info->length = sizeof(xXIKeyInfo) / 4 + info->num_keycodes; info->sourceid = dev->key->sourceid; - kc = (uint32_t *) & info[1]; + kc = (uint32_t *) &info[1]; for (i = xkb->min_key_code; i <= xkb->max_key_code; i++, kc++) *kc = i; @@ -321,7 +321,7 @@ SwapKeyInfo(DeviceIntPtr dev, xXIKeyInfo * info) swaps(&info->length); swaps(&info->sourceid); - for (i = 0, key = (uint32_t *) & info[1]; i < info->num_keycodes; + for (i = 0, key = (uint32_t *) &info[1]; i < info->num_keycodes; i++, key++) swapl(key); diff --git a/xorg-server/configure.ac b/xorg-server/configure.ac index 38ac240df..435a38f15 100644 --- a/xorg-server/configure.ac +++ b/xorg-server/configure.ac @@ -26,9 +26,9 @@ dnl dnl Process this file with autoconf to create configure. AC_PREREQ(2.60) -AC_INIT([xorg-server], 1.13.99.0, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server) -RELEASE_DATE="2012-10-04" -RELEASE_NAME="Horchata" +AC_INIT([xorg-server], 1.13.99.901, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server) +RELEASE_DATE="2012-12-19" +RELEASE_NAME="Egg Nog" AC_CONFIG_SRCDIR([Makefile.am]) AM_INIT_AUTOMAKE([foreign dist-bzip2]) @@ -788,7 +788,7 @@ XPROTO="xproto >= 7.0.22" RANDRPROTO="randrproto >= 1.4.0" RENDERPROTO="renderproto >= 0.11" XEXTPROTO="xextproto >= 7.1.99" -INPUTPROTO="inputproto >= 2.1.99.6" +INPUTPROTO="inputproto >= 2.2.99.1" KBPROTO="kbproto >= 1.0.3" FONTSPROTO="fontsproto" FIXESPROTO="fixesproto >= 5.0" diff --git a/xorg-server/dix/colormap.c b/xorg-server/dix/colormap.c index a43e2791b..39fddc9b1 100644 --- a/xorg-server/dix/colormap.c +++ b/xorg-server/dix/colormap.c @@ -658,15 +658,15 @@ FreeCell(ColormapPtr pmap, Pixel i, int channel) default: /* so compiler can see that everything gets initialized */ case PSEUDOMAP: case REDMAP: - pent = (EntryPtr) & pmap->red[i]; + pent = (EntryPtr) &pmap->red[i]; pCount = &pmap->freeRed; break; case GREENMAP: - pent = (EntryPtr) & pmap->green[i]; + pent = (EntryPtr) &pmap->green[i]; pCount = &pmap->freeGreen; break; case BLUEMAP: - pent = (EntryPtr) & pmap->blue[i]; + pent = (EntryPtr) &pmap->blue[i]; pCount = &pmap->freeBlue; break; } @@ -1400,7 +1400,7 @@ QueryColors(ColormapPtr pmap, int count, Pixel * ppixIn, xrgb * prgbList, errVal = BadValue; } else { - pent = (EntryPtr) & pmap->red[pixel]; + pent = (EntryPtr) &pmap->red[pixel]; if (pent->fShared) { prgb->red = pent->co.shco.red->color; prgb->green = pent->co.shco.green->color; diff --git a/xorg-server/dix/devices.c b/xorg-server/dix/devices.c index 613323fa2..3c7d480c6 100644 --- a/xorg-server/dix/devices.c +++ b/xorg-server/dix/devices.c @@ -283,7 +283,7 @@ AddInputDevice(ClientPtr client, DeviceProc deviceProc, Bool autoStart) dev->coreEvents = TRUE; /* sprite defaults */ - dev->spriteInfo = (SpriteInfoPtr) & dev[1]; + dev->spriteInfo = (SpriteInfoPtr) &dev[1]; /* security creation/labeling check */ @@ -944,7 +944,7 @@ CloseDevice(DeviceIntPtr dev) free(dev->name); - classes = (ClassesPtr) & dev->key; + classes = (ClassesPtr) &dev->key; FreeAllDeviceClasses(classes); if (IsMaster(dev)) { diff --git a/xorg-server/dix/dispatch.c b/xorg-server/dix/dispatch.c index 99ba277fb..8d6173525 100644 --- a/xorg-server/dix/dispatch.c +++ b/xorg-server/dix/dispatch.c @@ -2454,7 +2454,7 @@ ProcListInstalledColormaps(ClientPtr client) preply->type = X_Reply; preply->sequenceNumber = client->sequence; nummaps = (*pWin->drawable.pScreen->ListInstalledColormaps) - (pWin->drawable.pScreen, (Colormap *) & preply[1]); + (pWin->drawable.pScreen, (Colormap *) &preply[1]); preply->nColormaps = nummaps; preply->length = nummaps; WriteReplyToClient(client, sizeof(xListInstalledColormapsReply), preply); diff --git a/xorg-server/dix/eventconvert.c b/xorg-server/dix/eventconvert.c index 2e422d7a1..2c411cf40 100644 --- a/xorg-server/dix/eventconvert.c +++ b/xorg-server/dix/eventconvert.c @@ -57,6 +57,7 @@ static int eventToKeyButtonPointer(DeviceEvent *ev, xEvent **xi, int *count); static int eventToDeviceChanged(DeviceChangedEvent *ev, xEvent **dcce); static int eventToDeviceEvent(DeviceEvent *ev, xEvent **xi); static int eventToRawEvent(RawDeviceEvent *ev, xEvent **xi); +static int eventToBarrierEvent(BarrierEvent *ev, xEvent **xi); static int eventToTouchOwnershipEvent(TouchOwnershipEvent *ev, xEvent **xi); /* Do not use, read comments below */ @@ -160,6 +161,8 @@ EventToCore(InternalEvent *event, xEvent **core_out, int *count_out) case ET_TouchUpdate: case ET_TouchEnd: case ET_TouchOwnership: + case ET_BarrierHit: + case ET_BarrierLeave: ret = BadMatch; break; default: @@ -216,6 +219,8 @@ EventToXI(InternalEvent *ev, xEvent **xi, int *count) case ET_TouchUpdate: case ET_TouchEnd: case ET_TouchOwnership: + case ET_BarrierHit: + case ET_BarrierLeave: *count = 0; *xi = NULL; return BadMatch; @@ -277,6 +282,9 @@ EventToXI2(InternalEvent *ev, xEvent **xi) case ET_RawTouchUpdate: case ET_RawTouchEnd: return eventToRawEvent(&ev->raw_event, xi); + case ET_BarrierHit: + case ET_BarrierLeave: + return eventToBarrierEvent(&ev->barrier_event, xi); default: break; } @@ -451,7 +459,7 @@ appendKeyInfo(DeviceChangedEvent *dce, xXIKeyInfo * info) info->length = sizeof(xXIKeyInfo) / 4 + info->num_keycodes; info->sourceid = dce->sourceid; - kc = (uint32_t *) & info[1]; + kc = (uint32_t *) &info[1]; for (i = 0; i < info->num_keycodes; i++) *kc++ = i + dce->keys.min_keycode; @@ -782,6 +790,35 @@ eventToRawEvent(RawDeviceEvent *ev, xEvent **xi) return Success; } +static int +eventToBarrierEvent(BarrierEvent *ev, xEvent **xi) +{ + xXIBarrierEvent *barrier; + int len = sizeof(xXIBarrierEvent); + + *xi = calloc(1, len); + barrier = (xXIBarrierEvent*) *xi; + barrier->type = GenericEvent; + barrier->extension = IReqCode; + barrier->evtype = GetXI2Type(ev->type); + barrier->length = bytes_to_int32(len - sizeof(xEvent)); + barrier->deviceid = ev->deviceid; + barrier->sourceid = ev->sourceid; + barrier->time = ev->time; + barrier->event = ev->window; + barrier->root = ev->root; + barrier->dx = double_to_fp3232(ev->dx); + barrier->dy = double_to_fp3232(ev->dy); + barrier->dtime = ev->dt; + barrier->flags = ev->flags; + barrier->eventid = ev->event_id; + barrier->barrier = ev->barrierid; + barrier->root_x = double_to_fp1616(ev->root_x); + barrier->root_y = double_to_fp1616(ev->root_y); + + return Success; +} + /** * Return the corresponding core type for the given event or 0 if no core * equivalent exists. @@ -929,6 +966,12 @@ GetXI2Type(enum EventType type) case ET_TouchOwnership: xi2type = XI_TouchOwnership; break; + case ET_BarrierHit: + xi2type = XI_BarrierHit; + break; + case ET_BarrierLeave: + xi2type = XI_BarrierLeave; + break; default: break; } diff --git a/xorg-server/dix/events.c b/xorg-server/dix/events.c index 31f8d8700..73593626e 100644 --- a/xorg-server/dix/events.c +++ b/xorg-server/dix/events.c @@ -219,6 +219,9 @@ static void CheckVirtualMotion(DeviceIntPtr pDev, QdEventPtr qe, static void CheckPhysLimits(DeviceIntPtr pDev, CursorPtr cursor, Bool generateEvents, Bool confineToScreen, ScreenPtr pScreen); +static Bool IsWrongPointerBarrierClient(ClientPtr client, + DeviceIntPtr dev, + xEvent *event); /** Key repeat hack. Do not use but in TryClientEvents */ extern BOOL EventIsKeyRepeat(xEvent *event); @@ -2092,6 +2095,9 @@ DeliverEventToInputClients(DeviceIntPtr dev, InputClients * inputclients, if (IsInterferingGrab(client, dev, events)) continue; + if (IsWrongPointerBarrierClient(client, dev, events)) + continue; + mask = GetEventMask(dev, events, inputclients); if (XaceHook(XACE_RECEIVE_ACCESS, client, win, events, count)) @@ -2446,6 +2452,8 @@ FixUpEventFromWindow(SpritePtr pSprite, case XI_DeviceChanged: case XI_HierarchyChanged: case XI_PropertyEvent: + case XI_BarrierHit: + case XI_BarrierLeave: return; default: break; @@ -5043,7 +5051,7 @@ GrabDevice(ClientPtr client, DeviceIntPtr dev, grab = grabInfo->grab; if (grab && grab->grabtype != grabtype) *status = AlreadyGrabbed; - if (grab && !SameClient(grab, client)) + else if (grab && !SameClient(grab, client)) *status = AlreadyGrabbed; else if ((!pWin->realized) || (confineTo && @@ -6080,3 +6088,19 @@ IsInterferingGrab(ClientPtr client, DeviceIntPtr dev, xEvent *event) return FALSE; } + +/* PointerBarrier events are only delivered to the client that created that + * barrier */ +static Bool +IsWrongPointerBarrierClient(ClientPtr client, DeviceIntPtr dev, xEvent *event) +{ + xXIBarrierEvent *ev = (xXIBarrierEvent*)event; + + if (ev->type != GenericEvent || ev->extension != IReqCode) + return FALSE; + + if (ev->evtype != XI_BarrierHit && ev->evtype != XI_BarrierLeave) + return FALSE; + + return client->index != CLIENT_ID(ev->barrier); +} diff --git a/xorg-server/dix/getevents.c b/xorg-server/dix/getevents.c index fa538d9f4..3d41e1e5a 100644 --- a/xorg-server/dix/getevents.c +++ b/xorg-server/dix/getevents.c @@ -916,10 +916,13 @@ scale_to_desktop(DeviceIntPtr dev, ValuatorMask *mask, * @param[in,out] devy y desktop-wide coordinate in device coordinate system * @param[in,out] screenx x coordinate in desktop coordinate system * @param[in,out] screeny y coordinate in desktop coordinate system + * @param[out] nevents Number of barrier events added to events + * @param[in,out] events List of events barrier events are added to */ static ScreenPtr positionSprite(DeviceIntPtr dev, int mode, ValuatorMask *mask, - double *devx, double *devy, double *screenx, double *screeny) + double *devx, double *devy, double *screenx, double *screeny, + int *nevents, InternalEvent* events) { ScreenPtr scr = miPointerGetScreen(dev); double tmpx, tmpy; @@ -933,7 +936,7 @@ positionSprite(DeviceIntPtr dev, int mode, ValuatorMask *mask, /* miPointerSetPosition takes care of crossing screens for us, as well as * clipping to the current screen. Coordinates returned are in desktop * coord system */ - scr = miPointerSetPosition(dev, mode, screenx, screeny); + scr = miPointerSetPosition(dev, mode, screenx, screeny, nevents, events); /* If we were constrained, rescale x/y from the screen coordinates so * the device valuators reflect the correct position. For screen @@ -1319,6 +1322,7 @@ fill_pointer_events(InternalEvent *events, DeviceIntPtr pDev, int type, int sx, sy; /* for POINTER_SCREEN */ ValuatorMask mask; ScreenPtr scr; + int num_barrier_events = 0; switch (type) { case MotionNotify: @@ -1395,7 +1399,10 @@ fill_pointer_events(InternalEvent *events, DeviceIntPtr pDev, int type, } scr = positionSprite(pDev, (flags & POINTER_ABSOLUTE) ? Absolute : Relative, - &mask, &devx, &devy, &screenx, &screeny); + &mask, &devx, &devy, &screenx, &screeny, + &num_barrier_events, events); + num_events += num_barrier_events; + events += num_barrier_events; /* screenx, screeny are in desktop coordinates, mask is in device coordinates per-screen (the event data) @@ -1945,7 +1952,7 @@ GetTouchEvents(InternalEvent *events, DeviceIntPtr dev, uint32_t ddx_touchid, scr = scale_to_desktop(dev, &mask, &devx, &devy, &screenx, &screeny); if (emulate_pointer) scr = positionSprite(dev, Absolute, &mask, - &devx, &devy, &screenx, &screeny); + &devx, &devy, &screenx, &screeny, NULL, NULL); /* see fill_pointer_events for coordinate systems */ if (emulate_pointer) diff --git a/xorg-server/dix/grabs.c b/xorg-server/dix/grabs.c index fe7967415..3b02352df 100644 --- a/xorg-server/dix/grabs.c +++ b/xorg-server/dix/grabs.c @@ -219,7 +219,10 @@ CreateGrab(int client, DeviceIntPtr device, DeviceIntPtr modDevice, grab->resource = FakeClientID(client); grab->device = device; grab->window = window; - grab->eventMask = mask->core; /* same for XI */ + if (grabtype == CORE || grabtype == XI) + grab->eventMask = mask->core; /* same for XI */ + else + grab->eventMask = 0; grab->deviceMask = 0; grab->ownerEvents = param->ownerEvents; grab->keyboardMode = param->this_device_mode; diff --git a/xorg-server/dix/window.c b/xorg-server/dix/window.c index 99b3e0a13..a5b28a630 100644 --- a/xorg-server/dix/window.c +++ b/xorg-server/dix/window.c @@ -680,7 +680,7 @@ CreateWindow(Window wid, WindowPtr pParent, int x, int y, unsigned w, if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth)) { fOK = FALSE; for (idepth = 0; idepth < pScreen->numDepths; idepth++) { - pDepth = (DepthPtr) & pScreen->allowedDepths[idepth]; + pDepth = (DepthPtr) &pScreen->allowedDepths[idepth]; if ((depth == pDepth->depth) || (depth == 0)) { for (ivisual = 0; ivisual < pDepth->numVids; ivisual++) { if (visual == pDepth->vids[ivisual]) { diff --git a/xorg-server/exa/exa.c b/xorg-server/exa/exa.c index d12344f79..f8e499c2b 100644 --- a/xorg-server/exa/exa.c +++ b/xorg-server/exa/exa.c @@ -620,8 +620,8 @@ exaCreateGC(GCPtr pGC) swap(pExaScr, pScreen, CreateGC); if ((ret = (*pScreen->CreateGC) (pGC))) { - wrap(pExaGC, pGC, funcs, (GCFuncs *) & exaGCFuncs); - wrap(pExaGC, pGC, ops, (GCOps *) & exaOps); + wrap(pExaGC, pGC, funcs, (GCFuncs *) &exaGCFuncs); + wrap(pExaGC, pGC, ops, (GCOps *) &exaOps); } swap(pExaScr, pScreen, CreateGC); diff --git a/xorg-server/fb/fbgc.c b/xorg-server/fb/fbgc.c index e6f8279b3..f4d7f3a99 100644 --- a/xorg-server/fb/fbgc.c +++ b/xorg-server/fb/fbgc.c @@ -64,8 +64,8 @@ const GCOps fbGCOps = { Bool fbCreateGC(GCPtr pGC) { - pGC->ops = (GCOps *) & fbGCOps; - pGC->funcs = (GCFuncs *) & fbGCFuncs; + pGC->ops = (GCOps *) &fbGCOps; + pGC->funcs = (GCFuncs *) &fbGCFuncs; /* fb wants to translate before scan conversion */ pGC->miTranslate = 1; diff --git a/xorg-server/glx/glapi.c b/xorg-server/glx/glapi.c index 02e06ac1e..ad7329eff 100644 --- a/xorg-server/glx/glapi.c +++ b/xorg-server/glx/glapi.c @@ -490,7 +490,7 @@ init_glapi_relocs(void) char run_time_patch[] = { 0x65, 0xa1, 0, 0, 0, 0 /* movl %gs:0,%eax */ }; - GLuint *offset = (GLuint *) & run_time_patch[2]; /* 32-bits for x86/32 */ + GLuint *offset = (GLuint *) &run_time_patch[2]; /* 32-bits for x86/32 */ const GLubyte *const get_disp = (const GLubyte *) run_time_patch; GLubyte *curr_func = (GLubyte *) gl_dispatch_functions_start; diff --git a/xorg-server/glx/glxdri.c b/xorg-server/glx/glxdri.c index a5d87ecac..da4646845 100644 --- a/xorg-server/glx/glxdri.c +++ b/xorg-server/glx/glxdri.c @@ -1069,7 +1069,7 @@ __glXDRIscreenProbe(ScreenPtr pScreen) /* Map the framebuffer region. */ status = drmMap(fd, hFB, framebuffer.size, - (drmAddressPtr) & framebuffer.base); + (drmAddressPtr) &framebuffer.base); if (status != 0) { LogMessage(X_ERROR, "AIGLX error: drmMap of framebuffer failed (%s)\n", strerror(-status)); diff --git a/xorg-server/glx/indirect_program.c b/xorg-server/glx/indirect_program.c index 3b50ecd53..0114d7347 100644 --- a/xorg-server/glx/indirect_program.c +++ b/xorg-server/glx/indirect_program.c @@ -109,7 +109,7 @@ DoGetProgramString(struct __GLXclientStateRec *cl, GLbyte * pc, } else { __GLX_BEGIN_REPLY(compsize); - ((xGLXGetTexImageReply *) & __glXReply)->width = compsize; + ((xGLXGetTexImageReply *) &__glXReply)->width = compsize; __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize); } diff --git a/xorg-server/glx/indirect_texture_compression.c b/xorg-server/glx/indirect_texture_compression.c index 49d6db57f..5c2d06b42 100644 --- a/xorg-server/glx/indirect_texture_compression.c +++ b/xorg-server/glx/indirect_texture_compression.c @@ -72,7 +72,7 @@ __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *cl, GLbyte * pc) } else { __GLX_BEGIN_REPLY(compsize); - ((xGLXGetTexImageReply *) & __glXReply)->width = compsize; + ((xGLXGetTexImageReply *) &__glXReply)->width = compsize; __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize); } @@ -118,7 +118,7 @@ __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *cl, } else { __GLX_BEGIN_REPLY(compsize); - ((xGLXGetTexImageReply *) & __glXReply)->width = compsize; + ((xGLXGetTexImageReply *) &__glXReply)->width = compsize; __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize); } diff --git a/xorg-server/glx/renderpixswap.c b/xorg-server/glx/renderpixswap.c index 0655b74f2..24423cdef 100644 --- a/xorg-server/glx/renderpixswap.c +++ b/xorg-server/glx/renderpixswap.c @@ -51,17 +51,17 @@ __glXDispSwap_SeparableFilter2D(GLbyte * pc) hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE); - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->internalformat); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->internalformat); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap diff --git a/xorg-server/glx/singlepix.c b/xorg-server/glx/singlepix.c index 55cd4437f..fb6868d2d 100644 --- a/xorg-server/glx/singlepix.c +++ b/xorg-server/glx/singlepix.c @@ -150,9 +150,9 @@ __glXDisp_GetTexImage(__GLXclientState * cl, GLbyte * pc) } else { __GLX_BEGIN_REPLY(compsize); - ((xGLXGetTexImageReply *) & __glXReply)->width = width; - ((xGLXGetTexImageReply *) & __glXReply)->height = height; - ((xGLXGetTexImageReply *) & __glXReply)->depth = depth; + ((xGLXGetTexImageReply *) &__glXReply)->width = width; + ((xGLXGetTexImageReply *) &__glXReply)->height = height; + ((xGLXGetTexImageReply *) &__glXReply)->depth = depth; __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize); } @@ -252,8 +252,8 @@ GetSeparableFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) } else { __GLX_BEGIN_REPLY(compsize + compsize2); - ((xGLXGetSeparableFilterReply *) & __glXReply)->width = width; - ((xGLXGetSeparableFilterReply *) & __glXReply)->height = height; + ((xGLXGetSeparableFilterReply *) &__glXReply)->width = width; + ((xGLXGetSeparableFilterReply *) &__glXReply)->height = height; __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize + compsize2); } @@ -330,8 +330,8 @@ GetConvolutionFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) } else { __GLX_BEGIN_REPLY(compsize); - ((xGLXGetConvolutionFilterReply *) & __glXReply)->width = width; - ((xGLXGetConvolutionFilterReply *) & __glXReply)->height = height; + ((xGLXGetConvolutionFilterReply *) &__glXReply)->width = width; + ((xGLXGetConvolutionFilterReply *) &__glXReply)->height = height; __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize); } @@ -399,7 +399,7 @@ GetHistogram(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) } else { __GLX_BEGIN_REPLY(compsize); - ((xGLXGetHistogramReply *) & __glXReply)->width = width; + ((xGLXGetHistogramReply *) &__glXReply)->width = width; __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize); } @@ -528,7 +528,7 @@ GetColorTable(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) } else { __GLX_BEGIN_REPLY(compsize); - ((xGLXGetColorTableReply *) & __glXReply)->width = width; + ((xGLXGetColorTableReply *) &__glXReply)->width = width; __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize); } diff --git a/xorg-server/glx/singlepixswap.c b/xorg-server/glx/singlepixswap.c index b6d628303..c777cea00 100644 --- a/xorg-server/glx/singlepixswap.c +++ b/xorg-server/glx/singlepixswap.c @@ -176,9 +176,9 @@ __glXDispSwap_GetTexImage(__GLXclientState * cl, GLbyte * pc) __GLX_SWAP_INT(&width); __GLX_SWAP_INT(&height); __GLX_SWAP_INT(&depth); - ((xGLXGetTexImageReply *) & __glXReply)->width = width; - ((xGLXGetTexImageReply *) & __glXReply)->height = height; - ((xGLXGetTexImageReply *) & __glXReply)->depth = depth; + ((xGLXGetTexImageReply *) &__glXReply)->width = width; + ((xGLXGetTexImageReply *) &__glXReply)->height = height; + ((xGLXGetTexImageReply *) &__glXReply)->depth = depth; __GLX_SEND_HEADER(); __GLX_SEND_VOID_ARRAY(compsize); } @@ -290,8 +290,8 @@ GetSeparableFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) __GLX_SWAP_REPLY_HEADER(); __GLX_SWAP_INT(&width); __GLX_SWAP_INT(&height); - ((xGLXGetSeparableFilterReply *) & __glXReply)->width = width; - ((xGLXGetSeparableFilterReply *) & __glXReply)->height = height; + ((xGLXGetSeparableFilterReply *) &__glXReply)->width = width; + ((xGLXGetSeparableFilterReply *) &__glXReply)->height = height; __GLX_SEND_VOID_ARRAY(compsize + compsize2); } @@ -376,8 +376,8 @@ GetConvolutionFilter(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) __GLX_SWAP_REPLY_HEADER(); __GLX_SWAP_INT(&width); __GLX_SWAP_INT(&height); - ((xGLXGetConvolutionFilterReply *) & __glXReply)->width = width; - ((xGLXGetConvolutionFilterReply *) & __glXReply)->height = height; + ((xGLXGetConvolutionFilterReply *) &__glXReply)->width = width; + ((xGLXGetConvolutionFilterReply *) &__glXReply)->height = height; __GLX_SEND_VOID_ARRAY(compsize); } @@ -452,7 +452,7 @@ GetHistogram(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) __GLX_BEGIN_REPLY(compsize); __GLX_SWAP_REPLY_HEADER(); __GLX_SWAP_INT(&width); - ((xGLXGetHistogramReply *) & __glXReply)->width = width; + ((xGLXGetHistogramReply *) &__glXReply)->width = width; __GLX_SEND_VOID_ARRAY(compsize); } @@ -594,7 +594,7 @@ GetColorTable(__GLXclientState * cl, GLbyte * pc, GLXContextTag tag) __GLX_BEGIN_REPLY(compsize); __GLX_SWAP_REPLY_HEADER(); __GLX_SWAP_INT(&width); - ((xGLXGetColorTableReply *) & __glXReply)->width = width; + ((xGLXGetColorTableReply *) &__glXReply)->width = width; __GLX_SEND_VOID_ARRAY(compsize); } diff --git a/xorg-server/glx/xfont.c b/xorg-server/glx/xfont.c index 037ed9e4c..b203866d9 100644 --- a/xorg-server/glx/xfont.c +++ b/xorg-server/glx/xfont.c @@ -168,7 +168,7 @@ __glXDisp_UseXFont(__GLXclientState * cl, GLbyte * pc) } CALL_GetIntegerv(GET_DISPATCH(), - (GL_LIST_INDEX, (GLint *) & currentListIndex)); + (GL_LIST_INDEX, (GLint *) ¤tListIndex)); if (currentListIndex != 0) { /* ** A display list is currently being made. It is an error diff --git a/xorg-server/hw/dmx/config/Canvas.c b/xorg-server/hw/dmx/config/Canvas.c index 34a47a2bf..f0586e509 100644 --- a/xorg-server/hw/dmx/config/Canvas.c +++ b/xorg-server/hw/dmx/config/Canvas.c @@ -76,7 +76,7 @@ CanvasExpose(Widget w, XEvent * event, Region region) if (!XtIsRealized(w)) return; - XtCallCallbacks(w, XtNcanvasExposeCallback, (XtPointer) & data); + XtCallCallbacks(w, XtNcanvasExposeCallback, (XtPointer) &data); } static void @@ -162,4 +162,4 @@ CanvasClassRec canvasClassRec = { } }; -WidgetClass canvasWidgetClass = (WidgetClass) & canvasClassRec; +WidgetClass canvasWidgetClass = (WidgetClass) &canvasClassRec; diff --git a/xorg-server/hw/dmx/dmx_glxvisuals.c b/xorg-server/hw/dmx/dmx_glxvisuals.c index 9fcc0e58d..f903b7491 100644 --- a/xorg-server/hw/dmx/dmx_glxvisuals.c +++ b/xorg-server/hw/dmx/dmx_glxvisuals.c @@ -61,7 +61,7 @@ GetGLXVisualConfigs(Display * dpy, int screen, int *nconfigs) req->reqType = majorOpcode; req->glxCode = X_GLXGetVisualConfigs; req->screen = screen; - if (!_XReply(dpy, (xReply *) & reply, 0, False)) { + if (!_XReply(dpy, (xReply *) &reply, 0, False)) { /* Something is busted. Punt. */ UnlockDisplay(dpy); SyncHandle(); @@ -252,7 +252,7 @@ GetGLXFBConfigs(Display * dpy, int glxMajorOpcode, int *nconfigs) *nconfigs = 0; - if (!_XReply(dpy, (xReply *) & reply, 0, False)) { + if (!_XReply(dpy, (xReply *) &reply, 0, False)) { /* Something is busted. Punt. */ UnlockDisplay(dpy); SyncHandle(); diff --git a/xorg-server/hw/dmx/dmxinit.c b/xorg-server/hw/dmx/dmxinit.c index 7a50aebc3..7de402b06 100644 --- a/xorg-server/hw/dmx/dmxinit.c +++ b/xorg-server/hw/dmx/dmxinit.c @@ -740,10 +740,10 @@ InitOutput(ScreenInfo * pScreenInfo, int argc, char *argv[]) /* Check if GLX extension exists on all back-end servers */ for (i = 0; i < dmxNumScreens; i++) glxSupported &= (dmxScreens[i].glxMajorOpcode > 0); -#endif if (serverGeneration == 1) dmxAddExtensions(glxSupported); +#endif /* Tell dix layer about the backend displays */ for (i = 0; i < dmxNumScreens; i++) { diff --git a/xorg-server/hw/dmx/dmxwindow.c b/xorg-server/hw/dmx/dmxwindow.c index 855e56b9d..9b8a3840e 100644 --- a/xorg-server/hw/dmx/dmxwindow.c +++ b/xorg-server/hw/dmx/dmxwindow.c @@ -786,7 +786,7 @@ dmxWindowExposures(WindowPtr pWindow, RegionPtr prgn, RegionPtr other_exposed) if (pWinPriv->window) { while (XCheckIfEvent(dmxScreen->beDisplay, &ev, dmxWindowExposurePredicate, - (XPointer) & pWinPriv->window)) { + (XPointer) &pWinPriv->window)) { /* Handle expose events -- this should not be necessary since the base window in which the root window was created is guaranteed to be on top (override_redirect), diff --git a/xorg-server/hw/dmx/examples/xinput.c b/xorg-server/hw/dmx/examples/xinput.c index db6601030..6eddc6a67 100644 --- a/xorg-server/hw/dmx/examples/xinput.c +++ b/xorg-server/hw/dmx/examples/xinput.c @@ -303,8 +303,8 @@ main(int argc, char **argv) XNextEvent(display, &event); for (i = 0; i < cnt; i++) { - XDeviceMotionEvent *e = (XDeviceMotionEvent *) & event; - XDeviceButtonEvent *b = (XDeviceButtonEvent *) & event; + XDeviceMotionEvent *e = (XDeviceMotionEvent *) &event; + XDeviceButtonEvent *b = (XDeviceButtonEvent *) &event; if (event.type == event_type[i]) { printf("%s id=%lu (%d @ %d,%d; s=0x%04x, d=%d, t=%lu)" diff --git a/xorg-server/hw/dmx/glxProxy/glxcmds.c b/xorg-server/hw/dmx/glxProxy/glxcmds.c index 91011d109..45382748f 100644 --- a/xorg-server/hw/dmx/glxProxy/glxcmds.c +++ b/xorg-server/hw/dmx/glxProxy/glxcmds.c @@ -1276,7 +1276,7 @@ MakeCurrent(__GLXclientState * cl, be_req->context = (unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0); be_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s); - if (!_XReply(dpy, (xReply *) & be_reply, 0, False)) { + if (!_XReply(dpy, (xReply *) &be_reply, 0, False)) { /* The make current failed */ UnlockDisplay(dpy); @@ -1331,7 +1331,7 @@ MakeCurrent(__GLXclientState * cl, be_new_req->context = (unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0); be_new_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s); - if (!_XReply(dpy, (xReply *) & be_new_reply, 0, False)) { + if (!_XReply(dpy, (xReply *) &be_new_reply, 0, False)) { /* The make current failed */ UnlockDisplay(dpy); @@ -1362,7 +1362,7 @@ MakeCurrent(__GLXclientState * cl, ext_req->context = (unsigned int) (glxc ? glxc->real_ids[s - from_screen] : 0); ext_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s); - if (!_XReply(dpy, (xReply *) & ext_reply, 0, False)) { + if (!_XReply(dpy, (xReply *) &ext_reply, 0, False)) { /* The make current failed */ UnlockDisplay(dpy); @@ -2177,7 +2177,7 @@ __glXDoSwapBuffers(__GLXclientState * cl, XID drawId, GLXContextTag tag) finishReq->glxCode = X_GLsop_Finish; finishReq->contextTag = (tag ? GetCurrentBackEndTag(cl, tag, s) : 0); - (void) _XReply(dpy, (xReply *) & reply, 0, False); + (void) _XReply(dpy, (xReply *) &reply, 0, False); UnlockDisplay(dpy); SyncHandle(); } @@ -2605,7 +2605,7 @@ __glXQueryExtensionsString(__GLXclientState * cl, GLbyte * pc) be_req->reqType = dmxScreen->glxMajorOpcode; be_req->glxCode = X_GLXQueryServerString; be_req->screen = DefaultScreen(dpy); - _XReply(dpy, (xReply *) & be_reply, 0, False); + _XReply(dpy, (xReply *) &be_reply, 0, False); len = (int) be_reply.length; numbytes = (int) be_reply.n; slop = numbytes * __GLX_SIZE_INT8 & 3; @@ -2690,7 +2690,7 @@ __glXQueryServerString(__GLXclientState * cl, GLbyte * pc) be_req->glxCode = X_GLXQueryServerString; be_req->screen = DefaultScreen(dpy); be_req->name = name; - _XReply(dpy, (xReply *) & be_reply, 0, False); + _XReply(dpy, (xReply *) &be_reply, 0, False); len = (int) be_reply.length; numbytes = (int) be_reply.n; slop = numbytes * __GLX_SIZE_INT8 & 3; @@ -3045,7 +3045,7 @@ __glXGetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc) new_req.length = req->length; new_req.screen = req->screen; - return (__glXGetFBConfigs(cl, (GLbyte *) & new_req)); + return (__glXGetFBConfigs(cl, (GLbyte *) &new_req)); } int @@ -3591,7 +3591,7 @@ __glXGetDrawableAttributes(__GLXclientState * cl, GLbyte * pc) be_req->glxCode = X_GLXGetDrawableAttributes; be_req->drawable = be_drawable; be_req->length = req->length; - if (!_XReply(dpy, (xReply *) & reply, 0, False)) { + if (!_XReply(dpy, (xReply *) &reply, 0, False)) { UnlockDisplay(dpy); SyncHandle(); return (BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code)); diff --git a/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c b/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c index ac79cda22..ab3e7edc1 100644 --- a/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c +++ b/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c @@ -1051,7 +1051,7 @@ __glXSwapGetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc) new_req.length = req->length; new_req.screen = req->screen; - return (__glXSwapGetFBConfigs(cl, (GLbyte *) & new_req)); + return (__glXSwapGetFBConfigs(cl, (GLbyte *) &new_req)); } int diff --git a/xorg-server/hw/dmx/glxProxy/glxscreens.c b/xorg-server/hw/dmx/glxProxy/glxscreens.c index f725bd138..2a1909244 100644 --- a/xorg-server/hw/dmx/glxProxy/glxscreens.c +++ b/xorg-server/hw/dmx/glxProxy/glxscreens.c @@ -88,7 +88,7 @@ CalcServerVersionAndExtensions(void) req->glxCode = X_GLXQueryVersion; req->majorVersion = GLX_SERVER_MAJOR_VERSION; req->minorVersion = GLX_SERVER_MINOR_VERSION; - _XReply(dpy, (xReply *) & reply, 0, False); + _XReply(dpy, (xReply *) &reply, 0, False); UnlockDisplay(dpy); SyncHandle(); @@ -147,7 +147,7 @@ CalcServerVersionAndExtensions(void) req->glxCode = X_GLXQueryServerString; req->screen = DefaultScreen(dpy); req->name = GLX_EXTENSIONS; - _XReply(dpy, (xReply *) & reply, 0, False); + _XReply(dpy, (xReply *) &reply, 0, False); length = (int) reply.length; numbytes = (int) reply.n; diff --git a/xorg-server/hw/dmx/glxProxy/glxsingle.c b/xorg-server/hw/dmx/glxProxy/glxsingle.c index 87842001f..e60cfeb70 100644 --- a/xorg-server/hw/dmx/glxProxy/glxsingle.c +++ b/xorg-server/hw/dmx/glxProxy/glxsingle.c @@ -249,7 +249,7 @@ __glXForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc) /* * get the reply from the back-end server */ - _XReply(dpy, (xReply *) & be_reply, 0, False); + _XReply(dpy, (xReply *) &be_reply, 0, False); be_buf_size = be_reply.length << 2; if (be_buf_size > 0) { be_buf = (char *) malloc(be_buf_size); @@ -348,7 +348,7 @@ __glXForwardAllWithReply(__GLXclientState * cl, GLbyte * pc) /* * get the reply from the back-end server */ - _XReply(dpy, (xReply *) & be_reply, 0, False); + _XReply(dpy, (xReply *) &be_reply, 0, False); be_buf_size = be_reply.length << 2; if (be_buf_size > 0) { be_buf = (char *) malloc(be_buf_size); @@ -919,7 +919,7 @@ __glXDisp_ReadPixels(__GLXclientState * cl, GLbyte * pc) *(GLboolean *) (be_pc + 24) = swapBytes; *(GLboolean *) (be_pc + 25) = lsbFirst; - _XReply(dpy, (xReply *) & be_reply, 0, False); + _XReply(dpy, (xReply *) &be_reply, 0, False); if (be_reply.length > 0) { char *be_buf; diff --git a/xorg-server/hw/dmx/glxProxy/glxvendor.c b/xorg-server/hw/dmx/glxProxy/glxvendor.c index e5c8da144..5777c6acc 100644 --- a/xorg-server/hw/dmx/glxProxy/glxvendor.c +++ b/xorg-server/hw/dmx/glxProxy/glxvendor.c @@ -237,7 +237,7 @@ __glXVForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc) /* * get the reply from the back-end server */ - _XReply(dpy, (xReply *) & be_reply, 0, False); + _XReply(dpy, (xReply *) &be_reply, 0, False); be_buf_size = be_reply.length << 2; if (be_buf_size > 0) { be_buf = (char *) malloc(be_buf_size); @@ -331,7 +331,7 @@ __glXVForwardAllWithReply(__GLXclientState * cl, GLbyte * pc) /* * get the reply from the back-end server */ - _XReply(dpy, (xReply *) & be_reply, 0, False); + _XReply(dpy, (xReply *) &be_reply, 0, False); be_buf_size = be_reply.length << 2; if (be_buf_size > 0) { be_buf = (char *) malloc(be_buf_size); diff --git a/xorg-server/hw/dmx/glxProxy/renderpixswap.c b/xorg-server/hw/dmx/glxProxy/renderpixswap.c index 3458e611c..32df0d5a8 100644 --- a/xorg-server/hw/dmx/glxProxy/renderpixswap.c +++ b/xorg-server/hw/dmx/glxProxy/renderpixswap.c @@ -39,10 +39,10 @@ __glXDispSwap_PolygonStipple(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); hdr->swapBytes = !hdr->swapBytes; } @@ -54,17 +54,17 @@ __glXDispSwap_Bitmap(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_FLOAT((GLbyte *) & hdr->xorig); - __GLX_SWAP_FLOAT((GLbyte *) & hdr->yorig); - __GLX_SWAP_FLOAT((GLbyte *) & hdr->xmove); - __GLX_SWAP_FLOAT((GLbyte *) & hdr->ymove); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_FLOAT((GLbyte *) &hdr->xorig); + __GLX_SWAP_FLOAT((GLbyte *) &hdr->yorig); + __GLX_SWAP_FLOAT((GLbyte *) &hdr->xmove); + __GLX_SWAP_FLOAT((GLbyte *) &hdr->ymove); hdr->swapBytes = !hdr->swapBytes; @@ -77,19 +77,19 @@ __glXDispSwap_TexImage1D(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->level); - __GLX_SWAP_INT((GLbyte *) & hdr->components); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_INT((GLbyte *) & hdr->border); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->level); + __GLX_SWAP_INT((GLbyte *) &hdr->components); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_INT((GLbyte *) &hdr->border); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -105,19 +105,19 @@ __glXDispSwap_TexImage2D(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->level); - __GLX_SWAP_INT((GLbyte *) & hdr->components); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_INT((GLbyte *) & hdr->border); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->level); + __GLX_SWAP_INT((GLbyte *) &hdr->components); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_INT((GLbyte *) &hdr->border); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -133,25 +133,25 @@ __glXDispSwap_TexImage3D(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->imageHeight); - __GLX_SWAP_INT((GLbyte *) & hdr->imageDepth); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipImages); - __GLX_SWAP_INT((GLbyte *) & hdr->skipVolumes); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); - - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->level); - __GLX_SWAP_INT((GLbyte *) & hdr->internalformat); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_INT((GLbyte *) & hdr->depth); - __GLX_SWAP_INT((GLbyte *) & hdr->size4d); - __GLX_SWAP_INT((GLbyte *) & hdr->border); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->imageHeight); + __GLX_SWAP_INT((GLbyte *) &hdr->imageDepth); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipImages); + __GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); + + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->level); + __GLX_SWAP_INT((GLbyte *) &hdr->internalformat); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_INT((GLbyte *) &hdr->depth); + __GLX_SWAP_INT((GLbyte *) &hdr->size4d); + __GLX_SWAP_INT((GLbyte *) &hdr->border); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -167,15 +167,15 @@ __glXDispSwap_DrawPixels(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -191,17 +191,17 @@ __glXDispSwap_TexSubImage1D(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->level); - __GLX_SWAP_INT((GLbyte *) & hdr->xoffset); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->level); + __GLX_SWAP_INT((GLbyte *) &hdr->xoffset); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -217,19 +217,19 @@ __glXDispSwap_TexSubImage2D(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->level); - __GLX_SWAP_INT((GLbyte *) & hdr->xoffset); - __GLX_SWAP_INT((GLbyte *) & hdr->yoffset); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->level); + __GLX_SWAP_INT((GLbyte *) &hdr->xoffset); + __GLX_SWAP_INT((GLbyte *) &hdr->yoffset); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -246,26 +246,26 @@ __glXDispSwap_TexSubImage3D(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->imageHeight); - __GLX_SWAP_INT((GLbyte *) & hdr->imageDepth); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipImages); - __GLX_SWAP_INT((GLbyte *) & hdr->skipVolumes); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); - - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->level); - __GLX_SWAP_INT((GLbyte *) & hdr->xoffset); - __GLX_SWAP_INT((GLbyte *) & hdr->yoffset); - __GLX_SWAP_INT((GLbyte *) & hdr->zoffset); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_INT((GLbyte *) & hdr->depth); - __GLX_SWAP_INT((GLbyte *) & hdr->size4d); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->imageHeight); + __GLX_SWAP_INT((GLbyte *) &hdr->imageDepth); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipImages); + __GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); + + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->level); + __GLX_SWAP_INT((GLbyte *) &hdr->xoffset); + __GLX_SWAP_INT((GLbyte *) &hdr->yoffset); + __GLX_SWAP_INT((GLbyte *) &hdr->zoffset); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_INT((GLbyte *) &hdr->depth); + __GLX_SWAP_INT((GLbyte *) &hdr->size4d); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -281,16 +281,16 @@ __glXDispSwap_ColorTable(GLbyte * pc) __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->internalformat); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->internalformat); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -306,16 +306,16 @@ __glXDispSwap_ColorSubTable(GLbyte * pc) (__GLXdispatchColorSubTableHeader *) pc; __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->start); - __GLX_SWAP_INT((GLbyte *) & hdr->count); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->start); + __GLX_SWAP_INT((GLbyte *) &hdr->count); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -331,16 +331,16 @@ __glXDispSwap_ConvolutionFilter1D(GLbyte * pc) (__GLXdispatchConvolutionFilterHeader *) pc; __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->internalformat); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->internalformat); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -356,17 +356,17 @@ __glXDispSwap_ConvolutionFilter2D(GLbyte * pc) (__GLXdispatchConvolutionFilterHeader *) pc; __GLX_DECLARE_SWAP_VARIABLES; - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->internalformat); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->internalformat); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap @@ -386,17 +386,17 @@ __glXDispSwap_SeparableFilter2D(GLbyte * pc) hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE); - __GLX_SWAP_INT((GLbyte *) & hdr->rowLength); - __GLX_SWAP_INT((GLbyte *) & hdr->skipRows); - __GLX_SWAP_INT((GLbyte *) & hdr->skipPixels); - __GLX_SWAP_INT((GLbyte *) & hdr->alignment); - - __GLX_SWAP_INT((GLbyte *) & hdr->target); - __GLX_SWAP_INT((GLbyte *) & hdr->internalformat); - __GLX_SWAP_INT((GLbyte *) & hdr->width); - __GLX_SWAP_INT((GLbyte *) & hdr->height); - __GLX_SWAP_INT((GLbyte *) & hdr->format); - __GLX_SWAP_INT((GLbyte *) & hdr->type); + __GLX_SWAP_INT((GLbyte *) &hdr->rowLength); + __GLX_SWAP_INT((GLbyte *) &hdr->skipRows); + __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels); + __GLX_SWAP_INT((GLbyte *) &hdr->alignment); + + __GLX_SWAP_INT((GLbyte *) &hdr->target); + __GLX_SWAP_INT((GLbyte *) &hdr->internalformat); + __GLX_SWAP_INT((GLbyte *) &hdr->width); + __GLX_SWAP_INT((GLbyte *) &hdr->height); + __GLX_SWAP_INT((GLbyte *) &hdr->format); + __GLX_SWAP_INT((GLbyte *) &hdr->type); /* ** Just invert swapBytes flag; the GL will figure out if it needs to swap diff --git a/xorg-server/hw/kdrive/ephyr/XF86dri.c b/xorg-server/hw/kdrive/ephyr/XF86dri.c index 74bf67678..9d742f394 100644 --- a/xorg-server/hw/kdrive/ephyr/XF86dri.c +++ b/xorg-server/hw/kdrive/ephyr/XF86dri.c @@ -151,7 +151,7 @@ XF86DRIQueryVersion(Display * dpy, int *majorVersion, int *minorVersion, GetReq(XF86DRIQueryVersion, req); req->reqType = info->codes->major_opcode; req->driReqType = X_XF86DRIQueryVersion; - if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { + if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) { UnlockDisplay(dpy); SyncHandle(); TRACE("QueryVersion... return False"); @@ -181,7 +181,7 @@ XF86DRIQueryDirectRenderingCapable(Display * dpy, int screen, Bool *isCapable) req->reqType = info->codes->major_opcode; req->driReqType = X_XF86DRIQueryDirectRenderingCapable; req->screen = screen; - if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { + if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) { UnlockDisplay(dpy); SyncHandle(); TRACE("QueryDirectRenderingCapable... return False"); @@ -210,7 +210,7 @@ XF86DRIOpenConnection(Display * dpy, int screen, req->reqType = info->codes->major_opcode; req->driReqType = X_XF86DRIOpenConnection; req->screen = screen; - if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { + if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) { UnlockDisplay(dpy); SyncHandle(); TRACE("OpenConnection... return False"); @@ -260,7 +260,7 @@ XF86DRIAuthConnection(Display * dpy, int screen, drm_magic_t magic) req->screen = screen; req->magic = magic; rep.authenticated = 0; - if (!_XReply(dpy, (xReply *) & rep, 0, xFalse) || !rep.authenticated) { + if (!_XReply(dpy, (xReply *) &rep, 0, xFalse) || !rep.authenticated) { UnlockDisplay(dpy); SyncHandle(); TRACE("AuthConnection... return False"); @@ -311,7 +311,7 @@ XF86DRIGetClientDriverName(Display * dpy, int screen, req->reqType = info->codes->major_opcode; req->driReqType = X_XF86DRIGetClientDriverName; req->screen = screen; - if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { + if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) { UnlockDisplay(dpy); SyncHandle(); TRACE("GetClientDriverName... return False"); @@ -362,7 +362,7 @@ XF86DRICreateContextWithConfig(Display * dpy, int screen, int configID, req->screen = screen; *context = XAllocID(dpy); req->context = *context; - if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { + if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) { UnlockDisplay(dpy); SyncHandle(); TRACE("CreateContext... return False"); @@ -421,7 +421,7 @@ XF86DRICreateDrawable(Display * dpy, int screen, req->driReqType = X_XF86DRICreateDrawable; req->screen = screen; req->drawable = drawable; - if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { + if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) { UnlockDisplay(dpy); SyncHandle(); TRACE("CreateDrawable... return False"); @@ -503,7 +503,7 @@ XF86DRIGetDrawableInfo(Display * dpy, int screen, Drawable drawable, req->screen = screen; req->drawable = drawable; - if (!_XReply(dpy, (xReply *) & rep, 1, xFalse)) { + if (!_XReply(dpy, (xReply *) &rep, 1, xFalse)) { UnlockDisplay(dpy); SyncHandle(); TRACE("GetDrawableInfo... return False"); @@ -585,7 +585,7 @@ XF86DRIGetDeviceInfo(Display * dpy, int screen, drm_handle_t * hFrameBuffer, req->reqType = info->codes->major_opcode; req->driReqType = X_XF86DRIGetDeviceInfo; req->screen = screen; - if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { + if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) { UnlockDisplay(dpy); SyncHandle(); TRACE("GetDeviceInfo... return False"); diff --git a/xorg-server/hw/kdrive/ephyr/ephyrdriext.c b/xorg-server/hw/kdrive/ephyr/ephyrdriext.c index 1a98a2dff..144c6e1ac 100644 --- a/xorg-server/hw/kdrive/ephyr/ephyrdriext.c +++ b/xorg-server/hw/kdrive/ephyr/ephyrdriext.c @@ -754,7 +754,7 @@ ProcXF86DRICreateContext(register ClientPtr client) if (!ephyrDRICreateContext(stuff->screen, stuff->visual, &context_id, - (drm_context_t *) & rep.hHWContext)) { + (drm_context_t *) &rep.hHWContext)) { return BadValue; } @@ -964,7 +964,7 @@ ProcXF86DRICreateDrawable(ClientPtr client) if (!ephyrDRICreateDrawable(stuff->screen, remote_win, - (drm_drawable_t *) & rep.hHWDrawable)) { + (drm_drawable_t *) &rep.hHWDrawable)) { EPHYR_LOG_ERROR("failed to create dri drawable\n"); return BadValue; } diff --git a/xorg-server/hw/kdrive/ephyr/ephyrhostglx.c b/xorg-server/hw/kdrive/ephyr/ephyrhostglx.c index 392489a00..5c6c40f0b 100644 --- a/xorg-server/hw/kdrive/ephyr/ephyrhostglx.c +++ b/xorg-server/hw/kdrive/ephyr/ephyrhostglx.c @@ -121,7 +121,7 @@ ephyrHostGLXQueryVersion(int *a_major, int *a_minor) req->glxCode = X_GLXQueryVersion; req->majorVersion = 2; req->minorVersion = 1; - _XReply(dpy, (xReply *) & reply, 0, False); + _XReply(dpy, (xReply *) &reply, 0, False); UnlockDisplay(dpy); SyncHandle(); @@ -207,7 +207,7 @@ ephyrHostGLXGetStringFromServer(int a_screen_number, req->for_whom = default_screen; req->name = a_string_name; - _XReply(dpy, (xReply *) & reply, 0, False); + _XReply(dpy, (xReply *) &reply, 0, False); length = reply.length * 4; if (!length) { @@ -303,7 +303,7 @@ ephyrHostGLXGetVisualConfigsInternal(enum VisualConfRequestType a_type, break; } - if (!_XReply(dpy, (xReply *) & reply, 0, False)) { + if (!_XReply(dpy, (xReply *) &reply, 0, False)) { EPHYR_LOG_ERROR("unknown error\n"); UnlockDisplay(dpy); goto out; @@ -615,7 +615,7 @@ ephyrHostGLXMakeCurrent(int a_drawable, int a_readable, } memset(&reply, 0, sizeof(reply)); - if (!_XReply(dpy, (xReply *) & reply, 0, False)) { + if (!_XReply(dpy, (xReply *) &reply, 0, False)) { EPHYR_LOG_ERROR("failed to get reply from host\n"); UnlockDisplay(dpy); SyncHandle(); @@ -735,7 +735,7 @@ ephyrHostIsContextDirect(int a_ctxt_id, int *a_is_direct) req->reqType = major_opcode; req->glxCode = X_GLXIsDirect; req->context = remote_glx_ctxt_id; - if (!_XReply(dpy, (xReply *) & reply, 0, False)) { + if (!_XReply(dpy, (xReply *) &reply, 0, False)) { EPHYR_LOG_ERROR("fail in reading reply from host\n"); UnlockDisplay(dpy); SyncHandle(); diff --git a/xorg-server/hw/kdrive/ephyr/ephyrhostproxy.c b/xorg-server/hw/kdrive/ephyr/ephyrhostproxy.c index 410e6b6e4..a4f25c159 100644 --- a/xorg-server/hw/kdrive/ephyr/ephyrhostproxy.c +++ b/xorg-server/hw/kdrive/ephyr/ephyrhostproxy.c @@ -73,7 +73,7 @@ ephyrHostProxyDoForward(pointer a_request_buffer, GetXReq(forward_req); memmove(forward_req, in_req, 4); - if (!_XReply(dpy, (xReply *) & reply, 0, FALSE)) { + if (!_XReply(dpy, (xReply *) &reply, 0, FALSE)) { EPHYR_LOG_ERROR("failed to get reply\n"); goto out; } diff --git a/xorg-server/hw/kdrive/ephyr/ephyrhostvideo.c b/xorg-server/hw/kdrive/ephyr/ephyrhostvideo.c index 05a821b39..362aa055e 100644 --- a/xorg-server/hw/kdrive/ephyr/ephyrhostvideo.c +++ b/xorg-server/hw/kdrive/ephyr/ephyrhostvideo.c @@ -304,7 +304,7 @@ ephyrHostXVAdaptorArrayAt(const EphyrHostXVAdaptorArray * a_this, int a_index) if (a_index >= a_this->nb_adaptors) return NULL; - return (EphyrHostXVAdaptor *) & a_this->adaptors[a_index]; + return (EphyrHostXVAdaptor *) &a_this->adaptors[a_index]; } char @@ -668,7 +668,7 @@ ephyrHostXVQueryImageAttributes(int a_port_id, /* * read the reply */ - if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) { + if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) { EPHYR_LOG_ERROR("QeryImageAttribute req failed\n"); goto out; } diff --git a/xorg-server/hw/kdrive/ephyr/ephyrvideo.c b/xorg-server/hw/kdrive/ephyr/ephyrvideo.c index 67eadd121..55dbd2e3a 100644 --- a/xorg-server/hw/kdrive/ephyr/ephyrvideo.c +++ b/xorg-server/hw/kdrive/ephyr/ephyrvideo.c @@ -495,7 +495,7 @@ ephyrXVPrivQueryHostAdaptors(EphyrXVPriv * a_this) port_priv_offset = a_this->adaptors[i].nPorts; for (j = 0; j < a_this->adaptors[i].nPorts; j++) { EphyrPortPriv *port_privs_base = - (EphyrPortPriv *) & a_this->adaptors[i]. + (EphyrPortPriv *) &a_this->adaptors[i]. pPortPrivates[port_priv_offset]; EphyrPortPriv *port_priv = &port_privs_base[j]; diff --git a/xorg-server/hw/xfree86/common/xf86cmap.c b/xorg-server/hw/xfree86/common/xf86cmap.c index 25f84e579..85f35f8db 100644 --- a/xorg-server/hw/xfree86/common/xf86cmap.c +++ b/xorg-server/hw/xfree86/common/xf86cmap.c @@ -608,7 +608,7 @@ CMapRefreshColors(ColormapPtr pmap, int defs, int *indices) case GrayScale: for (i = 0; i < defs; i++) { index = indices[i]; - entry = (EntryPtr) & pmap->red[index]; + entry = (EntryPtr) &pmap->red[index]; if (entry->fShared) { colors[index].red = diff --git a/xorg-server/hw/xfree86/dri/xf86dri.c b/xorg-server/hw/xfree86/dri/xf86dri.c index 0b2e8fa1b..086e833ed 100644 --- a/xorg-server/hw/xfree86/dri/xf86dri.c +++ b/xorg-server/hw/xfree86/dri/xf86dri.c @@ -280,7 +280,7 @@ ProcXF86DRICreateContext(register ClientPtr client) if (!DRICreateContext(pScreen, NULL, - stuff->context, (drm_context_t *) & rep.hHWContext)) { + stuff->context, (drm_context_t *) &rep.hHWContext)) { return BadValue; } @@ -329,7 +329,7 @@ ProcXF86DRICreateDrawable(ClientPtr client) return rc; if (!DRICreateDrawable(screenInfo.screens[stuff->screen], client, - pDrawable, (drm_drawable_t *) & rep.hHWDrawable)) { + pDrawable, (drm_drawable_t *) &rep.hHWDrawable)) { return BadValue; } diff --git a/xorg-server/hw/xfree86/i2c/fi1236.c b/xorg-server/hw/xfree86/i2c/fi1236.c index 282fe7e34..2eb27ba6d 100644 --- a/xorg-server/hw/xfree86/i2c/fi1236.c +++ b/xorg-server/hw/xfree86/i2c/fi1236.c @@ -91,7 +91,7 @@ MT2032_getid(FI1236Ptr f) CARD8 in; in = 0x11; - I2C_WriteRead(&(f->d), (I2CByte *) & in, 1, out, 4); + I2C_WriteRead(&(f->d), (I2CByte *) &in, 1, out, 4); xf86DrvMsg(f->d.pI2CBus->scrnIndex, X_INFO, "MT2032: Company code 0x%02x%02x, part code 0x%02x, revision code 0x%02x\n", out[0], out[1], out[2], out[3]); @@ -432,7 +432,7 @@ MT2032_get_afc_hint(FI1236Ptr f) CARD8 AFC; in = 0x0e; - I2C_WriteRead(&(f->d), (I2CByte *) & in, 1, out, 2); + I2C_WriteRead(&(f->d), (I2CByte *) &in, 1, out, 2); AFC = (out[0] >> 4) & 0x7; #if 0 xf86DrvMsg(f->d.pI2CBus->scrnIndex, X_INFO, "AFC=%d TAD1=%d TAD2=%d\n", @@ -467,7 +467,7 @@ MT2032_dump_status(FI1236Ptr f) CARD8 TAD2, TAD1; in = 0x0e; - I2C_WriteRead(&(f->d), (I2CByte *) & in, 1, out, 2); + I2C_WriteRead(&(f->d), (I2CByte *) &in, 1, out, 2); XOK = out[0] & 1; LO1LK = (out[0] >> 2) & 1; LO2LK = (out[0] >> 1) & 1; @@ -589,12 +589,12 @@ FI1236_tune(FI1236Ptr f, CARD32 frequency) if ((f->type == TUNER_TYPE_FM1216ME) || (f->type == TUNER_TYPE_FI1236W)) { f->tuner_data.aux = 0x20; - I2C_WriteRead(&(f->d), (I2CByte *) & (f->tuner_data), 5, NULL, 0); + I2C_WriteRead(&(f->d), (I2CByte *) &(f->tuner_data), 5, NULL, 0); I2C_WriteRead(&(f->d), NULL, 0, &data, 1); xf86DrvMsg(f->d.pI2CBus->scrnIndex, X_INFO, "Tuner status %x\n", data); } else - I2C_WriteRead(&(f->d), (I2CByte *) & (f->tuner_data), 4, NULL, 0); + I2C_WriteRead(&(f->d), (I2CByte *) &(f->tuner_data), 4, NULL, 0); } void diff --git a/xorg-server/hw/xfree86/i2c/tda9850.c b/xorg-server/hw/xfree86/i2c/tda9850.c index c2ce6971f..d258bda05 100644 --- a/xorg-server/hw/xfree86/i2c/tda9850.c +++ b/xorg-server/hw/xfree86/i2c/tda9850.c @@ -131,6 +131,6 @@ tda9850_getstatus(TDA9850Ptr t) { CARD16 status; - I2C_WriteRead(&(t->d), NULL, 0, (I2CByte *) & status, 2); + I2C_WriteRead(&(t->d), NULL, 0, (I2CByte *) &status, 2); return status; } diff --git a/xorg-server/hw/xquartz/GL/visualConfigs.c b/xorg-server/hw/xquartz/GL/visualConfigs.c index e37eefbe4..03486cd66 100644 --- a/xorg-server/hw/xquartz/GL/visualConfigs.c +++ b/xorg-server/hw/xquartz/GL/visualConfigs.c @@ -58,40 +58,38 @@ #include "darwinfb.h" /* Based originally on code from indirect.c which was based on code from i830_dri.c. */ -__GLXconfig * -__glXAquaCreateVisualConfigs(int *numConfigsPtr, int screenNumber) -{ +__GLXconfig *__glXAquaCreateVisualConfigs(int *numConfigsPtr, int screenNumber) { int numConfigs = 0; __GLXconfig *visualConfigs, *c; struct glCapabilities caps; struct glCapabilitiesConfig *conf; int stereo, depth, aux, buffers, stencil, accum, color, msample; - if (getGlCapabilities(&caps)) { + if(getGlCapabilities(&caps)) { ErrorF("error from getGlCapabilities()!\n"); return NULL; } /* - conf->stereo is 0 or 1, but we need at least 1 iteration of the loop, - so we treat a true conf->stereo as 2. + conf->stereo is 0 or 1, but we need at least 1 iteration of the loop, + so we treat a true conf->stereo as 2. - The depth size is 0 or 24. Thus we do 2 iterations for that. + The depth size is 0 or 24. Thus we do 2 iterations for that. - conf->aux_buffers (when available/non-zero) result in 2 iterations instead of 1. + conf->aux_buffers (when available/non-zero) result in 2 iterations instead of 1. - conf->buffers indicates whether we have single or double buffering. + conf->buffers indicates whether we have single or double buffering. - conf->total_stencil_bit_depths + conf->total_stencil_bit_depths - conf->total_color_buffers indicates the RGB/RGBA color depths. + conf->total_color_buffers indicates the RGB/RGBA color depths. - conf->total_accum_buffers iterations for accum (with at least 1 if equal to 0) + conf->total_accum_buffers iterations for accum (with at least 1 if equal to 0) - conf->total_depth_buffer_depths + conf->total_depth_buffer_depths - conf->multisample_buffers iterations (with at least 1 if equal to 0). We add 1 - for the 0 multisampling config. + conf->multisample_buffers iterations (with at least 1 if equal to 0). We add 1 + for the 0 multisampling config. */ @@ -99,57 +97,43 @@ __glXAquaCreateVisualConfigs(int *numConfigsPtr, int screenNumber) numConfigs = 0; - for (conf = caps.configurations; conf; conf = conf->next) { - if (conf->total_color_buffers <= 0) + for(conf = caps.configurations; conf; conf = conf->next) { + if(conf->total_color_buffers <= 0) continue; numConfigs += (conf->stereo ? 2 : 1) - * (conf->aux_buffers ? 2 : 1) - * conf->buffers - * ((conf->total_stencil_bit_depths > - 0) ? conf->total_stencil_bit_depths : 1) - * conf->total_color_buffers - * ((conf->total_accum_buffers > - 0) ? conf->total_accum_buffers : 1) - * conf->total_depth_buffer_depths - * (conf->multisample_buffers + 1); + * (conf->aux_buffers ? 2 : 1) + * conf->buffers + * ((conf->total_stencil_bit_depths > 0) ? conf->total_stencil_bit_depths : 1) + * conf->total_color_buffers + * ((conf->total_accum_buffers > 0) ? conf->total_accum_buffers : 1) + * conf->total_depth_buffer_depths + * (conf->multisample_buffers + 1); } - if (numConfigsPtr) + if(numConfigsPtr) *numConfigsPtr = numConfigs; visualConfigs = calloc(sizeof(*visualConfigs), numConfigs); - if (NULL == visualConfigs) { + if(NULL == visualConfigs) { ErrorF("xcalloc failure when allocating visualConfigs\n"); freeGlCapabilities(&caps); return NULL; } c = visualConfigs; /* current buffer */ - for (conf = caps.configurations; conf; conf = conf->next) { - for (stereo = 0; stereo < (conf->stereo ? 2 : 1); ++stereo) { - for (aux = 0; aux < (conf->aux_buffers ? 2 : 1); ++aux) { - for (buffers = 0; buffers < conf->buffers; ++buffers) { - for (stencil = 0; - stencil < ((conf->total_stencil_bit_depths > 0) ? - conf-> - total_stencil_bit_depths : 1); - ++stencil) { - for (color = 0; color < conf->total_color_buffers; - ++color) { - for (accum = 0; - accum < ((conf->total_accum_buffers > 0) ? - conf-> - total_accum_buffers : 1); - ++accum) { - for (depth = 0; - depth < conf->total_depth_buffer_depths; - ++depth) { - for (msample = 0; - msample < - (conf->multisample_buffers + 1); - ++msample) { + for(conf = caps.configurations; conf; conf = conf->next) { + for(stereo = 0; stereo < (conf->stereo ? 2 : 1); ++stereo) { + for(aux = 0; aux < (conf->aux_buffers ? 2 : 1); ++aux) { + for(buffers = 0; buffers < conf->buffers; ++buffers) { + for(stencil = 0; stencil < ((conf->total_stencil_bit_depths > 0) ? + conf->total_stencil_bit_depths : 1); ++stencil) { + for(color = 0; color < conf->total_color_buffers; ++color) { + for(accum = 0; accum < ((conf->total_accum_buffers > 0) ? + conf->total_accum_buffers : 1); ++accum) { + for(depth = 0; depth < conf->total_depth_buffer_depths; ++depth) { + for(msample = 0; msample < (conf->multisample_buffers + 1); ++msample) { // Global c->visualID = -1; @@ -162,12 +146,10 @@ __glXAquaCreateVisualConfigs(int *numConfigsPtr, int screenNumber) c->indexBits = 0; c->pixmapMode = 0; // TODO: What should this be? - if (conf->accelerated) { + if(conf->accelerated) { c->visualRating = GLX_NONE; - } - else { - c->visualRating = - GLX_SLOW_VISUAL_EXT; + } else { + c->visualRating = GLX_SLOW_VISUAL_EXT; } c->transparentPixel = GLX_NONE; @@ -179,91 +161,52 @@ __glXAquaCreateVisualConfigs(int *numConfigsPtr, int screenNumber) c->visualSelectGroup = 0; - c->swapMethod = - GLX_SWAP_UNDEFINED_OML; + c->swapMethod = GLX_SWAP_UNDEFINED_OML; // Stereo c->stereoMode = stereo ? TRUE : FALSE; // Aux buffers - c->numAuxBuffers = - aux ? conf->aux_buffers : 0; + c->numAuxBuffers = aux ? conf->aux_buffers : 0; // Double Buffered - c->doubleBufferMode = - buffers ? TRUE : FALSE; + c->doubleBufferMode = buffers ? TRUE : FALSE; // Stencil Buffer - if (conf->total_stencil_bit_depths > - 0) { - c->stencilBits = - conf->stencil_bit_depths[ - stencil]; - } - else { + if(conf->total_stencil_bit_depths > 0) { + c->stencilBits = conf->stencil_bit_depths[stencil]; + } else { c->stencilBits = 0; } // Color - if (GLCAPS_COLOR_BUF_INVALID_VALUE != - conf->color_buffers[color].a) { - c->alphaBits = - conf->color_buffers[color].a; - } - else { + if(GLCAPS_COLOR_BUF_INVALID_VALUE != conf->color_buffers[color].a) { + c->alphaBits = conf->color_buffers[color].a; + } else { c->alphaBits = 0; } - c->redBits = - conf->color_buffers[color].r; - c->greenBits = - conf->color_buffers[color].g; - c->blueBits = - conf->color_buffers[color].b; - - c->rgbBits = c->alphaBits + - c->redBits + - c->greenBits + - c->blueBits; - - c->alphaMask = - AM_ARGB(c->alphaBits, c->redBits, - c->greenBits, - c->blueBits); - c->redMask = - RM_ARGB(c->alphaBits, c->redBits, - c->greenBits, - c->blueBits); - c->greenMask = - GM_ARGB(c->alphaBits, c->redBits, - c->greenBits, - c->blueBits); - c->blueMask = - BM_ARGB(c->alphaBits, c->redBits, - c->greenBits, - c->blueBits); + c->redBits = conf->color_buffers[color].r; + c->greenBits = conf->color_buffers[color].g; + c->blueBits = conf->color_buffers[color].b; + + c->rgbBits = c->alphaBits + c->redBits + c->greenBits + c->blueBits; + + c->alphaMask = AM_ARGB(c->alphaBits, c->redBits, c->greenBits, c->blueBits); + c->redMask = RM_ARGB(c->alphaBits, c->redBits, c->greenBits, c->blueBits); + c->greenMask = GM_ARGB(c->alphaBits, c->redBits, c->greenBits, c->blueBits); + c->blueMask = BM_ARGB(c->alphaBits, c->redBits, c->greenBits, c->blueBits); // Accumulation Buffers - if (conf->total_accum_buffers > 0) { - c->accumRedBits = - conf->accum_buffers[accum].r; - c->accumGreenBits = - conf->accum_buffers[accum].g; - c->accumBlueBits = - conf->accum_buffers[accum].b; - if ( - GLCAPS_COLOR_BUF_INVALID_VALUE - != - conf->accum_buffers[accum].a) - { - c->accumAlphaBits = - conf->accum_buffers[accum - ].a; - } - else { + if(conf->total_accum_buffers > 0) { + c->accumRedBits = conf->accum_buffers[accum].r; + c->accumGreenBits = conf->accum_buffers[accum].g; + c->accumBlueBits = conf->accum_buffers[accum].b; + if(GLCAPS_COLOR_BUF_INVALID_VALUE != conf->accum_buffers[accum].a) { + c->accumAlphaBits = conf->accum_buffers[accum].a; + } else { c->accumAlphaBits = 0; } - } - else { + } else { c->accumRedBits = 0; c->accumGreenBits = 0; c->accumBlueBits = 0; @@ -271,17 +214,13 @@ __glXAquaCreateVisualConfigs(int *numConfigsPtr, int screenNumber) } // Depth - c->depthBits = - conf->depth_buffers[depth]; + c->depthBits = conf->depth_buffers[depth]; // MultiSample - if (msample > 0) { - c->samples = - conf->multisample_samples; - c->sampleBuffers = - conf->multisample_buffers; - } - else { + if(msample > 0) { + c->samples = conf->multisample_samples; + c->sampleBuffers = conf->multisample_buffers; + } else { c->samples = 0; c->sampleBuffers = 0; } @@ -291,9 +230,7 @@ __glXAquaCreateVisualConfigs(int *numConfigsPtr, int screenNumber) * GLXPbuffers in direct mode. */ /* SGIX_fbconfig / GLX 1.3 */ - c->drawableType = GLX_WINDOW_BIT | - GLX_PIXMAP_BIT | - GLX_PBUFFER_BIT; + c->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT; c->renderType = GLX_RGBA_BIT; c->xRenderable = GL_TRUE; c->fbconfigID = -1; @@ -310,8 +247,7 @@ __glXAquaCreateVisualConfigs(int *numConfigsPtr, int screenNumber) */ c->maxPbufferWidth = 8192; c->maxPbufferHeight = 8192; - c->maxPbufferPixels = - /*Do we need this?*/ 0; + c->maxPbufferPixels = /*Do we need this?*/ 0; /* * There is no introspection for this sort of thing * with CGL. What should we do realistically? @@ -337,12 +273,10 @@ __glXAquaCreateVisualConfigs(int *numConfigsPtr, int screenNumber) } } - (c - 1)->next = NULL; + (c-1)->next = NULL; if (c - visualConfigs != numConfigs) { - FatalError( - "numConfigs calculation error in setVisualConfigs! numConfigs is %d i is %d\n", - numConfigs, (int)(c - visualConfigs)); + FatalError("numConfigs calculation error in setVisualConfigs! numConfigs is %d i is %d\n", numConfigs, (int)(c - visualConfigs)); } freeGlCapabilities(&caps); diff --git a/xorg-server/hw/xquartz/darwin.c b/xorg-server/hw/xquartz/darwin.c index bf511801d..e0983d6ef 100644 --- a/xorg-server/hw/xquartz/darwin.c +++ b/xorg-server/hw/xquartz/darwin.c @@ -230,13 +230,15 @@ DarwinScreenInit(ScreenPtr pScreen, int argc, char **argv) } // TODO: Make PseudoColor visuals not suck in TrueColor mode - // if(dfb->depth > 8) - // miSetVisualTypesAndMasks(8, PseudoColorMask, 8, PseudoColor, 0, 0, 0); - if (dfb->depth > 15) - miSetVisualTypesAndMasks(15, TrueColorMask, 5, TrueColor, - RM_ARGB(0, 5, 5, 5), GM_ARGB(0, 5, 5, - 5), - BM_ARGB(0, 5, 5, 5)); + // if(dfb->depth > 8) + // miSetVisualTypesAndMasks(8, PseudoColorMask, 8, PseudoColor, 0, 0, 0); + // + // TODO: Re-add support for 15bit + // if (dfb->depth > 15) + // miSetVisualTypesAndMasks(15, TrueColorMask, 5, TrueColor, + // RM_ARGB(0, 5, 5, 5), GM_ARGB(0, 5, 5, + // 5), + // BM_ARGB(0, 5, 5, 5)); if (dfb->depth > 24) miSetVisualTypesAndMasks(24, TrueColorMask, 8, TrueColor, RM_ARGB(0, 8, 8, 8), GM_ARGB(0, 8, 8, diff --git a/xorg-server/hw/xquartz/xpr/xprScreen.c b/xorg-server/hw/xquartz/xpr/xprScreen.c index efe2aa882..e37601995 100644 --- a/xorg-server/hw/xquartz/xpr/xprScreen.c +++ b/xorg-server/hw/xquartz/xpr/xprScreen.c @@ -359,6 +359,10 @@ have_depth: dfb->blueMask = 0; break; +#if 0 + // Removed because Mountain Lion removed support for + // 15bit backing stores. We can possibly re-add + // this once libXplugin is updated to work around it. case 15: dfb->visuals = TrueColorMask; //LARGE_VISUALS; dfb->preferredCVC = TrueColor; @@ -369,6 +373,7 @@ have_depth: dfb->greenMask = GM_ARGB(0, 5, 5, 5); dfb->blueMask = BM_ARGB(0, 5, 5, 5); break; +#endif // case 24: default: diff --git a/xorg-server/hw/xwin/InitOutput.c b/xorg-server/hw/xwin/InitOutput.c index 78ff74fc5..04c17b702 100644 --- a/xorg-server/hw/xwin/InitOutput.c +++ b/xorg-server/hw/xwin/InitOutput.c @@ -1042,7 +1042,7 @@ winCheckDisplayNumber(void) NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPTSTR) & lpMsgBuf, 0, NULL); + (LPTSTR) &lpMsgBuf, 0, NULL); ErrorF("winCheckDisplayNumber - CreateMutex failed: %s\n", (LPSTR) lpMsgBuf); LocalFree(lpMsgBuf); diff --git a/xorg-server/hw/xwin/glx/indirect.c b/xorg-server/hw/xwin/glx/indirect.c index 22c5abc14..00cef3673 100644 --- a/xorg-server/hw/xwin/glx/indirect.c +++ b/xorg-server/hw/xwin/glx/indirect.c @@ -224,7 +224,7 @@ glxWinErrorMessage(void) if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_MAX_WIDTH_MASK, NULL, last_error, 0, - (LPTSTR) & errorbuffer, sizeof(errorbuffer), NULL)) { + (LPTSTR) &errorbuffer, sizeof(errorbuffer), NULL)) { snprintf(errorbuffer, sizeof(errorbuffer), "Unknown error"); } @@ -1370,7 +1370,7 @@ glxWinDeferredCreateContext(__GLXWinContext * gc, __GLXWinDrawable * draw) } draw->hDIB = - CreateDIBSection(draw->dibDC, (BITMAPINFO *) & bmpHeader, + CreateDIBSection(draw->dibDC, (BITMAPINFO *) &bmpHeader, DIB_RGB_COLORS, &pBits, 0, 0); if (draw->dibDC == NULL) { ErrorF("CreateDIBSection error: %s\n", glxWinErrorMessage()); diff --git a/xorg-server/hw/xwin/winclipboardxevents.c b/xorg-server/hw/xwin/winclipboardxevents.c index 5cae98caa..226c3f055 100644 --- a/xorg-server/hw/xwin/winclipboardxevents.c +++ b/xorg-server/hw/xwin/winclipboardxevents.c @@ -157,7 +157,7 @@ winClipboardFlushXEvents(HWND hwnd, */ iReturn = XSendEvent(pDisplay, eventSelection.requestor, - False, 0L, (XEvent *) & eventSelection); + False, 0L, (XEvent *) &eventSelection); if (iReturn == BadValue || iReturn == BadWindow) { ErrorF("winClipboardFlushXEvents - SelectionRequest - " "XSendEvent () failed\n"); @@ -341,7 +341,7 @@ winClipboardFlushXEvents(HWND hwnd, /* Notify the requesting window that the operation has completed */ iReturn = XSendEvent(pDisplay, eventSelection.requestor, - False, 0L, (XEvent *) & eventSelection); + False, 0L, (XEvent *) &eventSelection); if (iReturn == BadValue || iReturn == BadWindow) { ErrorF("winClipboardFlushXEvents - SelectionRequest - " "XSendEvent () failed\n"); @@ -380,7 +380,7 @@ winClipboardFlushXEvents(HWND hwnd, /* Notify the requesting window that the operation is complete */ iReturn = XSendEvent(pDisplay, eventSelection.requestor, - False, 0L, (XEvent *) & eventSelection); + False, 0L, (XEvent *) &eventSelection); if (iReturn == BadValue || iReturn == BadWindow) { /* * Should not be a problem if XSendEvent fails because diff --git a/xorg-server/hw/xwin/wincursor.c b/xorg-server/hw/xwin/wincursor.c index b5ea0db1b..2962d06ad 100644 --- a/xorg-server/hw/xwin/wincursor.c +++ b/xorg-server/hw/xwin/wincursor.c @@ -104,7 +104,7 @@ winPointerWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y) /* Translate the client area coords to screen coords */ MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & rcClient, 2); + HWND_DESKTOP, (LPPOINT) &rcClient, 2); /* * Update the Windows cursor position so that we don't @@ -275,7 +275,7 @@ winLoadCursor(ScreenPtr pScreen, CursorPtr pCursor, int screen) if (!lpBits) { /* Bicolor, use a palettized DIB */ WIN_DEBUG_MSG("winLoadCursor: Trying two color cursor\n"); - pbmi = (BITMAPINFO *) & bi; + pbmi = (BITMAPINFO *) &bi; memset(pbmi, 0, sizeof(BITMAPINFOHEADER)); pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); pbmi->bmiHeader.biWidth = pScreenPriv->cursor.sm_cx; @@ -358,7 +358,7 @@ winLoadCursor(ScreenPtr pScreen, CursorPtr pCursor, int screen) CreateCompatibleBitmap(hDC, pScreenPriv->cursor.sm_cx, pScreenPriv->cursor.sm_cy); SetDIBits(hDC, hXor, 0, pScreenPriv->cursor.sm_cy, lpBits, - (BITMAPINFO *) & bi, DIB_RGB_COLORS); + (BITMAPINFO *) &bi, DIB_RGB_COLORS); ReleaseDC(NULL, hDC); } free(lpBits); diff --git a/xorg-server/hw/xwin/winengine.c b/xorg-server/hw/xwin/winengine.c index b2007d751..1f55ada58 100644 --- a/xorg-server/hw/xwin/winengine.c +++ b/xorg-server/hw/xwin/winengine.c @@ -108,7 +108,7 @@ winDetectSupportedEngines(void) /* Try to query for DirectDraw4 interface */ ddrval = IDirectDraw_QueryInterface(lpdd, &IID_IDirectDraw4, - (LPVOID *) & lpdd4); + (LPVOID *) &lpdd4); if (SUCCEEDED(ddrval)) { /* We have DirectDraw4 */ winErrorFVerb(2, diff --git a/xorg-server/hw/xwin/wingc.c b/xorg-server/hw/xwin/wingc.c index 7ac305d06..814d53113 100644 --- a/xorg-server/hw/xwin/wingc.c +++ b/xorg-server/hw/xwin/wingc.c @@ -130,8 +130,8 @@ winCreateGCNativeGDI(GCPtr pGC) ErrorF("winCreateGCNativeGDI - depth: %d\n", pGC->depth); #endif - pGC->ops = (GCOps *) & winGCOps; - pGC->funcs = (GCFuncs *) & winGCFuncs; + pGC->ops = (GCOps *) &winGCOps; + pGC->funcs = (GCFuncs *) &winGCFuncs; /* We want all coordinates passed to spans functions to be screen relative */ pGC->miTranslate = TRUE; diff --git a/xorg-server/hw/xwin/winmsg.c b/xorg-server/hw/xwin/winmsg.c index 57c1d1888..56e7a097c 100644 --- a/xorg-server/hw/xwin/winmsg.c +++ b/xorg-server/hw/xwin/winmsg.c @@ -137,7 +137,7 @@ winW32ErrorEx(int verb, const char *msg, DWORD errorcode) NULL, errorcode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPTSTR) & buffer, 0, NULL)) { + (LPTSTR) &buffer, 0, NULL)) { winErrorFVerb(verb, "Unknown error in FormatMessage!\n"); } else { diff --git a/xorg-server/hw/xwin/winmultiwindowicons.c b/xorg-server/hw/xwin/winmultiwindowicons.c index b8357e72d..0322d9816 100644 --- a/xorg-server/hw/xwin/winmultiwindowicons.c +++ b/xorg-server/hw/xwin/winmultiwindowicons.c @@ -253,7 +253,7 @@ NetWMToWinIconAlpha(uint32_t * icon) ii.fIcon = TRUE; ii.xHotspot = 0; /* ignored */ ii.yHotspot = 0; /* ignored */ - ii.hbmColor = CreateDIBSection(hdc, (BITMAPINFO *) & bmh, + ii.hbmColor = CreateDIBSection(hdc, (BITMAPINFO *) &bmh, DIB_RGB_COLORS, (void **) &DIB_pixels, NULL, 0); ReleaseDC(NULL, hdc); diff --git a/xorg-server/hw/xwin/winmultiwindowshape.c b/xorg-server/hw/xwin/winmultiwindowshape.c index d5200cdb6..cb0f38950 100644 --- a/xorg-server/hw/xwin/winmultiwindowshape.c +++ b/xorg-server/hw/xwin/winmultiwindowshape.c @@ -137,7 +137,7 @@ winReshapeMultiWindow(WindowPtr pWin) /* Translate client rectangle coords to screen coords */ /* NOTE: Only transforms top and left members */ - ClientToScreen(pWinPriv->hWnd, (LPPOINT) & rcClient); + ClientToScreen(pWinPriv->hWnd, (LPPOINT) &rcClient); /* Get window rectangle */ if (!GetWindowRect(pWinPriv->hWnd, &rcWindow)) { diff --git a/xorg-server/hw/xwin/winmultiwindowwndproc.c b/xorg-server/hw/xwin/winmultiwindowwndproc.c index 4180a3aa3..c2292c661 100644 --- a/xorg-server/hw/xwin/winmultiwindowwndproc.c +++ b/xorg-server/hw/xwin/winmultiwindowwndproc.c @@ -498,7 +498,7 @@ winTopLevelWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPTSTR) & lpMsgBuf, 0, NULL); + (LPTSTR) &lpMsgBuf, 0, NULL); ErrorF("winTopLevelWindowProc - BitBlt failed: %s\n", (LPSTR) lpMsgBuf); diff --git a/xorg-server/hw/xwin/winpfbdd.c b/xorg-server/hw/xwin/winpfbdd.c index 0fd0efe56..ee6ea7290 100644 --- a/xorg-server/hw/xwin/winpfbdd.c +++ b/xorg-server/hw/xwin/winpfbdd.c @@ -78,7 +78,7 @@ winAllocateFBPrimaryDD(ScreenPtr pScreen) /* Get client area location in screen coords */ GetClientRect(pScreenPriv->hwndScreen, &rcClient); MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & rcClient, 2); + HWND_DESKTOP, (LPPOINT) &rcClient, 2); /* Create a DirectDraw object, store the address at lpdd */ ddrval = (*g_fpDirectDrawCreate) (NULL, &pScreenPriv->pdd, NULL); @@ -88,7 +88,7 @@ winAllocateFBPrimaryDD(ScreenPtr pScreen) /* Get a DirectDraw2 interface pointer */ ddrval = IDirectDraw_QueryInterface(pScreenPriv->pdd, &IID_IDirectDraw2, - (LPVOID *) & pScreenPriv->pdd2); + (LPVOID *) &pScreenPriv->pdd2); if (FAILED(ddrval)) { ErrorF("winAllocateFBShadowDD - Failed DD2 query: %08x\n", (unsigned int) ddrval); @@ -465,7 +465,7 @@ winActivateAppPrimaryDD(ScreenPtr pScreen) /* Get client area in screen coords */ GetClientRect(pScreenPriv->hwndScreen, &rcClient); MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & rcClient, 2); + HWND_DESKTOP, (LPPOINT) &rcClient, 2); /* Setup a source rectangle */ rcSrc.left = 0; @@ -530,7 +530,7 @@ winHotKeyAltTabPrimaryDD(ScreenPtr pScreen) /* Get client area in screen coords */ GetClientRect(pScreenPriv->hwndScreen, &rcClient); MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & rcClient, 2); + HWND_DESKTOP, (LPPOINT) &rcClient, 2); /* Did we loose the primary surface? */ ddrval = IDirectDrawSurface2_IsLost(pScreenPriv->pddsPrimary); diff --git a/xorg-server/hw/xwin/winpixmap.c b/xorg-server/hw/xwin/winpixmap.c index cb8ba9103..d8a12d58e 100644 --- a/xorg-server/hw/xwin/winpixmap.c +++ b/xorg-server/hw/xwin/winpixmap.c @@ -109,7 +109,7 @@ winCreatePixmapNativeGDI(ScreenPtr pScreen, /* Create a DIB for the pixmap */ pPixmapPriv->hBitmap = winCreateDIBNativeGDI(iWidth, iHeight, iDepth, &pPixmapPriv->pbBits, - (BITMAPINFO **) & pPixmapPriv-> + (BITMAPINFO **) &pPixmapPriv-> pbmih); #if CYGDEBUG diff --git a/xorg-server/hw/xwin/winscrinit.c b/xorg-server/hw/xwin/winscrinit.c index 639a99ca3..e776bdba6 100644 --- a/xorg-server/hw/xwin/winscrinit.c +++ b/xorg-server/hw/xwin/winscrinit.c @@ -550,7 +550,7 @@ winFinishScreenInitFB(int i, ScreenPtr pScreen, int argc, char **argv) &pScreenPriv->ptWMProc, &pScreenPriv->ptXMsgProc, &pScreenPriv->pmServerStarted, - pScreenInfo->dwScreen, (HWND) & pScreenPriv->hwndScreen, + pScreenInfo->dwScreen, (HWND) &pScreenPriv->hwndScreen, #ifdef XWIN_MULTIWINDOWEXTWM pScreenInfo->fInternalWM || #endif diff --git a/xorg-server/hw/xwin/winsetsp.c b/xorg-server/hw/xwin/winsetsp.c index 8f75991ff..f102f9ff5 100644 --- a/xorg-server/hw/xwin/winsetsp.c +++ b/xorg-server/hw/xwin/winsetsp.c @@ -107,7 +107,7 @@ winSetSpansNativeGDI(DrawablePtr pDrawable, 0, 0, *piWidths, 1, pSrcs, - (BITMAPINFO *) & bmi, + (BITMAPINFO *) &bmi, DIB_RGB_COLORS, g_copyROP[pGC->alu]); pSrcs += PixmapBytePad(*piWidths, pDrawable->depth); @@ -150,7 +150,7 @@ winSetSpansNativeGDI(DrawablePtr pDrawable, 0, 0, *piWidths, 1, pSrcs, - (BITMAPINFO *) & bmi, + (BITMAPINFO *) &bmi, DIB_RGB_COLORS, g_copyROP[pGC->alu]); pSrcs += PixmapBytePad(*piWidths, pDrawable->depth); diff --git a/xorg-server/hw/xwin/winshaddd.c b/xorg-server/hw/xwin/winshaddd.c index aad3a02a0..2e7060838 100644 --- a/xorg-server/hw/xwin/winshaddd.c +++ b/xorg-server/hw/xwin/winshaddd.c @@ -232,7 +232,7 @@ winAllocateFBShadowDD(ScreenPtr pScreen) /* Get a DirectDraw2 interface pointer */ ddrval = IDirectDraw_QueryInterface(pScreenPriv->pdd, &IID_IDirectDraw2, - (LPVOID *) & pScreenPriv->pdd2); + (LPVOID *) &pScreenPriv->pdd2); if (FAILED(ddrval)) { ErrorF("winAllocateFBShadowDD - Failed DD2 query: %08x\n", (unsigned int) ddrval); @@ -507,7 +507,7 @@ winShadowUpdateDD(ScreenPtr pScreen, shadowBufPtr pBuf) ptOrigin.x = pScreenInfo->dwXOffset; ptOrigin.y = pScreenInfo->dwYOffset; MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); + HWND_DESKTOP, (LPPOINT) &ptOrigin, 1); /* Unlock the shadow surface, so we can blit */ ddrval = IDirectDrawSurface2_Unlock(pScreenPriv->pddsShadow, NULL); @@ -853,7 +853,7 @@ winBltExposedRegionsShadowDD(ScreenPtr pScreen) ptOrigin.y = pScreenInfo->dwYOffset; MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); + HWND_DESKTOP, (LPPOINT) &ptOrigin, 1); rcDest.left = ptOrigin.x; rcDest.right = ptOrigin.x + pScreenInfo->dwWidth; rcDest.top = ptOrigin.y; @@ -996,7 +996,7 @@ winRedrawScreenShadowDD(ScreenPtr pScreen) ptOrigin.x = pScreenInfo->dwXOffset; ptOrigin.y = pScreenInfo->dwYOffset; MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); + HWND_DESKTOP, (LPPOINT) &ptOrigin, 1); rcDest.left = ptOrigin.x; rcDest.right = ptOrigin.x + pScreenInfo->dwWidth; rcDest.top = ptOrigin.y; diff --git a/xorg-server/hw/xwin/winshadddnl.c b/xorg-server/hw/xwin/winshadddnl.c index 7668bd1c0..01097f295 100644 --- a/xorg-server/hw/xwin/winshadddnl.c +++ b/xorg-server/hw/xwin/winshadddnl.c @@ -249,7 +249,7 @@ winAllocateFBShadowDDNL(ScreenPtr pScreen) /* Create a DirectDraw object, store the address at lpdd */ ddrval = (*g_fpDirectDrawCreate) (NULL, - (LPDIRECTDRAW *) & pScreenPriv->pdd, + (LPDIRECTDRAW *) &pScreenPriv->pdd, NULL); if (FAILED(ddrval)) { ErrorF("winAllocateFBShadowDDNL - Could not start " @@ -264,7 +264,7 @@ winAllocateFBShadowDDNL(ScreenPtr pScreen) /* Get a DirectDraw4 interface pointer */ ddrval = IDirectDraw_QueryInterface(pScreenPriv->pdd, &IID_IDirectDraw4, - (LPVOID *) & pScreenPriv->pdd4); + (LPVOID *) &pScreenPriv->pdd4); if (FAILED(ddrval)) { ErrorF("winAllocateFBShadowDDNL - Failed DD4 query: %08x\n", (unsigned int) ddrval); @@ -541,7 +541,7 @@ winShadowUpdateDDNL(ScreenPtr pScreen, shadowBufPtr pBuf) ptOrigin.x = pScreenInfo->dwXOffset; ptOrigin.y = pScreenInfo->dwYOffset; MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); + HWND_DESKTOP, (LPPOINT) &ptOrigin, 1); /* * Handle small regions with multiple blits, @@ -880,7 +880,7 @@ winBltExposedRegionsShadowDDNL(ScreenPtr pScreen) ptOrigin.y = pScreenInfo->dwYOffset; MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); + HWND_DESKTOP, (LPPOINT) &ptOrigin, 1); rcDest.left = ptOrigin.x; rcDest.right = ptOrigin.x + pScreenInfo->dwWidth; rcDest.top = ptOrigin.y; @@ -990,7 +990,7 @@ winRedrawScreenShadowDDNL(ScreenPtr pScreen) ptOrigin.x = pScreenInfo->dwXOffset; ptOrigin.y = pScreenInfo->dwYOffset; MapWindowPoints(pScreenPriv->hwndScreen, - HWND_DESKTOP, (LPPOINT) & ptOrigin, 1); + HWND_DESKTOP, (LPPOINT) &ptOrigin, 1); rcDest.left = ptOrigin.x; rcDest.right = ptOrigin.x + pScreenInfo->dwWidth; rcDest.top = ptOrigin.y; diff --git a/xorg-server/hw/xwin/winshadgdi.c b/xorg-server/hw/xwin/winshadgdi.c index 912f7e41f..ebc233924 100644 --- a/xorg-server/hw/xwin/winshadgdi.c +++ b/xorg-server/hw/xwin/winshadgdi.c @@ -337,7 +337,7 @@ winAllocateFBShadowGDI(ScreenPtr pScreen) pScreenPriv->hbmpShadow = CreateDIBSection(pScreenPriv->hdcScreen, (BITMAPINFO *) pScreenPriv-> pbmih, DIB_RGB_COLORS, - (VOID **) & pScreenInfo->pfb, + (VOID **) &pScreenInfo->pfb, NULL, 0); if (pScreenPriv->hbmpShadow == NULL || pScreenInfo->pfb == NULL) { winW32Error(2, "winAllocateFBShadowGDI - CreateDIBSection failed:"); diff --git a/xorg-server/hw/xwin/winwin32rootless.c b/xorg-server/hw/xwin/winwin32rootless.c index 974309248..210fea3fa 100644 --- a/xorg-server/hw/xwin/winwin32rootless.c +++ b/xorg-server/hw/xwin/winwin32rootless.c @@ -634,7 +634,7 @@ winMWExtWMReshapeFrame(RootlessFrameID wid, RegionPtr pShape) /* Create region for non-client area */ GetWindowRect(pRLWinPriv->hWnd, &rcWindow); GetClientRect(pRLWinPriv->hWnd, &rcClient); - MapWindowPoints(pRLWinPriv->hWnd, HWND_DESKTOP, (LPPOINT) & rcClient, 2); + MapWindowPoints(pRLWinPriv->hWnd, HWND_DESKTOP, (LPPOINT) &rcClient, 2); OffsetRgn(hRgn, rcClient.left - rcWindow.left, rcClient.top - rcWindow.top); OffsetRect(&rcClient, -rcWindow.left, -rcWindow.top); OffsetRect(&rcWindow, -rcWindow.left, -rcWindow.top); @@ -725,7 +725,7 @@ winMWExtWMStartDrawing(RootlessFrameID wid, char **pixelData, int *bytesPerRow) hbmpNew = CreateDIBSection(pRLWinPriv->hdcScreen, (BITMAPINFO *) pRLWinPriv->pbmihShadow, DIB_RGB_COLORS, - (VOID **) & pRLWinPriv->pfb, NULL, 0); + (VOID **) &pRLWinPriv->pfb, NULL, 0); if (hbmpNew == NULL || pRLWinPriv->pfb == NULL) { ErrorF("winMWExtWMStartDrawing - CreateDIBSection failed\n"); //return FALSE; @@ -883,7 +883,7 @@ winMWExtWMUpdateRegion(RootlessFrameID wid, RegionPtr pDamage) NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPTSTR) & lpMsgBuf, 0, NULL); + (LPTSTR) &lpMsgBuf, 0, NULL); ErrorF("winMWExtWMUpdateRegion - UpdateLayeredWindow failed: %s\n", (LPSTR) lpMsgBuf); diff --git a/xorg-server/hw/xwin/winwin32rootlesswndproc.c b/xorg-server/hw/xwin/winwin32rootlesswndproc.c index 436f9edd6..13df18677 100644 --- a/xorg-server/hw/xwin/winwin32rootlesswndproc.c +++ b/xorg-server/hw/xwin/winwin32rootlesswndproc.c @@ -780,7 +780,7 @@ winMWExtWMWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPTSTR) & lpMsgBuf, 0, NULL); + (LPTSTR) &lpMsgBuf, 0, NULL); ErrorF("winMWExtWMWindowProc - BitBlt failed: %s\n", (LPSTR) lpMsgBuf); @@ -1058,7 +1058,7 @@ winMWExtWMWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) if (!pRLWinPriv->fMovingOrSizing /*&& (pWinPos->flags & SWP_SHOWWINDOW) */ ) { GetClientRect(hwnd, &rcClient); - MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) & rcClient, 2); + MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) &rcClient, 2); if (!(pWinPos->flags & SWP_NOMOVE) && !(pWinPos->flags & SWP_NOSIZE)) { @@ -1263,7 +1263,7 @@ winMWExtWMWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) GetClientRect(hwnd, &rcClient); - MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) & rcClient, 2); + MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT) &rcClient, 2); if (winIsInternalWMRunning(pScreenInfo)) winAdjustXWindow(pWin, hwnd); diff --git a/xorg-server/include/dix-config.h.in b/xorg-server/include/dix-config.h.in index b270a3238..e1cb9eb51 100644 --- a/xorg-server/include/dix-config.h.in +++ b/xorg-server/include/dix-config.h.in @@ -429,6 +429,9 @@ /* Define to 1 if typeof works with your compiler. */ #undef HAVE_TYPEOF +/* Define to __typeof__ if your compiler spells it that way. */ +#undef typeof + /* The compiler supported TLS storage class, prefering initial-exec if tls_model is supported */ #undef TLS diff --git a/xorg-server/include/events.h b/xorg-server/include/events.h index 222bf328b..c0ef45d5f 100644 --- a/xorg-server/include/events.h +++ b/xorg-server/include/events.h @@ -27,6 +27,7 @@ typedef struct _DeviceEvent DeviceEvent; typedef struct _DeviceChangedEvent DeviceChangedEvent; typedef struct _TouchOwnershipEvent TouchOwnershipEvent; +typedef struct _BarrierEvent BarrierEvent; #if XFreeXDGA typedef struct _DGAEvent DGAEvent; diff --git a/xorg-server/include/eventstr.h b/xorg-server/include/eventstr.h index dd6fbeffb..38fab4f3c 100644 --- a/xorg-server/include/eventstr.h +++ b/xorg-server/include/eventstr.h @@ -72,6 +72,8 @@ enum EventType { ET_RawTouchUpdate, ET_RawTouchEnd, ET_XQuartz, + ET_BarrierHit, + ET_BarrierLeave, ET_Internal = 0xFF /* First byte */ }; @@ -130,7 +132,7 @@ struct _DeviceEvent { */ struct _TouchOwnershipEvent { unsigned char header; /**< Always ET_Internal */ - enum EventType type; /**< One of EventType */ + enum EventType type; /**< ET_TouchOwnership */ int length; /**< Length in bytes */ Time time; /**< Time in ms */ int deviceid; /**< Device to post this event for */ @@ -227,6 +229,25 @@ struct _RawDeviceEvent { uint32_t flags; /**< Flags to be copied into the generated event */ }; +struct _BarrierEvent { + unsigned char header; /**< Always ET_Internal */ + enum EventType type; /**< ET_BarrierHit, ET_BarrierLeave */ + int length; /**< Length in bytes */ + Time time; /**< Time in ms */ + int deviceid; /**< Device to post this event for */ + int sourceid; /**< The physical source device */ + int barrierid; + Window window; + Window root; + double dx; + double dy; + double root_x; + double root_y; + int16_t dt; + int32_t event_id; + uint32_t flags; +}; + #ifdef XQUARTZ #define XQUARTZ_EVENT_MAXARGS 5 struct _XQuartzEvent { @@ -253,6 +274,7 @@ union _InternalEvent { DeviceEvent device_event; DeviceChangedEvent changed_event; TouchOwnershipEvent touch_ownership_event; + BarrierEvent barrier_event; #if XFreeXDGA DGAEvent dga_event; #endif diff --git a/xorg-server/include/input.h b/xorg-server/include/input.h index 2387dbf4a..23a20b59d 100644 --- a/xorg-server/include/input.h +++ b/xorg-server/include/input.h @@ -678,4 +678,10 @@ extern _X_EXPORT void input_option_set_value(InputOption *opt, extern _X_HIDDEN Bool point_on_screen(ScreenPtr pScreen, int x, int y); extern _X_HIDDEN void update_desktop_dimensions(void); +extern _X_HIDDEN void input_constrain_cursor(DeviceIntPtr pDev, ScreenPtr screen, + int current_x, int current_y, + int dest_x, int dest_y, + int *out_x, int *out_y, + int *nevents, InternalEvent* events); + #endif /* INPUT_H */ diff --git a/xorg-server/include/inputstr.h b/xorg-server/include/inputstr.h index bb0a77963..17cee9854 100644 --- a/xorg-server/include/inputstr.h +++ b/xorg-server/include/inputstr.h @@ -71,7 +71,7 @@ extern _X_EXPORT int CountBits(const uint8_t * mask, int len); * events to the protocol, the server will not support these events until * this number here is bumped. */ -#define XI2LASTEVENT XI_RawTouchEnd +#define XI2LASTEVENT XI_BarrierLeave #define XI2MASKSIZE ((XI2LASTEVENT >> 3) + 1) /* no of bytes for masks */ /** diff --git a/xorg-server/mi/mieq.c b/xorg-server/mi/mieq.c index b2c7769ec..22f8c91bb 100644 --- a/xorg-server/mi/mieq.c +++ b/xorg-server/mi/mieq.c @@ -407,6 +407,10 @@ ChangeDeviceID(DeviceIntPtr dev, InternalEvent *event) case ET_RawTouchUpdate: event->raw_event.deviceid = dev->id; break; + case ET_BarrierHit: + case ET_BarrierLeave: + event->barrier_event.deviceid = dev->id; + break; default: ErrorF("[mi] Unknown event type (%d), cannot change id.\n", event->any.type); diff --git a/xorg-server/mi/miinitext.c b/xorg-server/mi/miinitext.c index 369da5ede..81c663abe 100644 --- a/xorg-server/mi/miinitext.c +++ b/xorg-server/mi/miinitext.c @@ -212,10 +212,12 @@ EnableDisableExtension(const char *name, Bool enable) void EnableDisableExtensionError(const char *name, Bool enable) { - ExtensionToggle *ext = &ExtensionToggleList[0]; + ExtensionToggle *ext; + int i; Bool found = FALSE; - for (ext = &ExtensionToggleList[0]; ext->name != NULL; ext++) { + for (i = 0; i < ARRAY_SIZE(ExtensionToggleList); i++) { + ext = &ExtensionToggleList[i]; if ((strcmp(name, ext->name) == 0) && (ext->disablePtr == NULL)) { ErrorF("[mi] Extension \"%s\" can not be disabled\n", name); found = TRUE; @@ -226,7 +228,8 @@ EnableDisableExtensionError(const char *name, Bool enable) ErrorF("[mi] Extension \"%s\" is not recognized\n", name); ErrorF("[mi] Only the following extensions can be run-time %s:\n", enable ? "enabled" : "disabled"); - for (ext = &ExtensionToggleList[0]; ext->name != NULL; ext++) { + for (i = 0; i < ARRAY_SIZE(ExtensionToggleList); i++) { + ext = &ExtensionToggleList[i]; if (ext->disablePtr != NULL) { ErrorF("[mi] %s\n", ext->name); } diff --git a/xorg-server/mi/mipointer.c b/xorg-server/mi/mipointer.c index f34506326..b8503f450 100644 --- a/xorg-server/mi/mipointer.c +++ b/xorg-server/mi/mipointer.c @@ -98,7 +98,7 @@ static void miPointerDeviceCleanup(DeviceIntPtr pDev, ScreenPtr pScreen); static void miPointerMoveNoEvent(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y); -static InternalEvent *events; /* for WarpPointer MotionNotifies */ +static InternalEvent *mipointermove_events; /* for WarpPointer MotionNotifies */ Bool miPointerInitialize(ScreenPtr pScreen, @@ -143,7 +143,7 @@ miPointerInitialize(ScreenPtr pScreen, pScreen->DeviceCursorInitialize = miPointerDeviceInitialize; pScreen->DeviceCursorCleanup = miPointerDeviceCleanup; - events = NULL; + mipointermove_events = NULL; return TRUE; } @@ -160,8 +160,8 @@ miPointerCloseScreen(ScreenPtr pScreen) pScreen->CloseScreen = pScreenPriv->CloseScreen; free((pointer) pScreenPriv); - FreeEventList(events, GetMaximumEventsNum()); - events = NULL; + FreeEventList(mipointermove_events, GetMaximumEventsNum()); + mipointermove_events = NULL; return (*pScreen->CloseScreen) (pScreen); } @@ -565,13 +565,16 @@ miPointerMoveNoEvent(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y) */ ScreenPtr miPointerSetPosition(DeviceIntPtr pDev, int mode, double *screenx, - double *screeny) + double *screeny, + int *nevents, InternalEvent* events) { miPointerScreenPtr pScreenPriv; ScreenPtr pScreen; ScreenPtr newScreen; int x, y; Bool switch_screen = FALSE; + Bool should_constrain_barriers = FALSE; + int i; miPointerPtr pPointer; @@ -588,6 +591,25 @@ miPointerSetPosition(DeviceIntPtr pDev, int mode, double *screenx, x -= pScreen->x; y -= pScreen->y; + should_constrain_barriers = (mode == Relative); + + if (should_constrain_barriers) { + /* coordinates after clamped to a barrier */ + int constrained_x, constrained_y; + int current_x, current_y; /* current position in per-screen coord */ + + current_x = MIPOINTER(pDev)->x - pScreen->y; + current_y = MIPOINTER(pDev)->y - pScreen->x; + + input_constrain_cursor(pDev, pScreen, + current_x, current_y, x, y, + &constrained_x, &constrained_y, + nevents, events); + + x = constrained_x; + y = constrained_y; + } + if (switch_screen) { pScreenPriv = GetScreenPrivate(pScreen); if (!pPointer->confined) { @@ -619,6 +641,18 @@ miPointerSetPosition(DeviceIntPtr pDev, int mode, double *screenx, if (pPointer->x != x || pPointer->y != y || pPointer->pScreen != pScreen) miPointerMoveNoEvent(pDev, pScreen, x, y); + /* check if we generated any barrier events and if so, update root x/y + * to the fully constrained coords */ + if (should_constrain_barriers) { + for (i = 0; i < *nevents; i++) { + if (events[i].any.type == ET_BarrierHit || + events[i].any.type == ET_BarrierLeave) { + events[i].barrier_event.root_x = x; + events[i].barrier_event.root_y = y; + } + } + } + /* Convert to desktop coordinates again */ x += pScreen->x; y += pScreen->y; @@ -676,17 +710,17 @@ miPointerMove(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y) valuators[0] = x; valuators[1] = y; - if (!events) { - events = InitEventList(GetMaximumEventsNum()); + if (!mipointermove_events) { + mipointermove_events = InitEventList(GetMaximumEventsNum()); - if (!events) { + if (!mipointermove_events) { FatalError("Could not allocate event store.\n"); return; } } valuator_mask_set_range(&mask, 0, 2, valuators); - nevents = GetPointerEvents(events, pDev, MotionNotify, 0, + nevents = GetPointerEvents(mipointermove_events, pDev, MotionNotify, 0, POINTER_SCREEN | POINTER_ABSOLUTE | POINTER_NORAW, &mask); @@ -695,7 +729,7 @@ miPointerMove(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y) darwinEvents_lock(); #endif for (i = 0; i < nevents; i++) - mieqEnqueue(pDev, &events[i]); + mieqEnqueue(pDev, &mipointermove_events[i]); #ifdef XQUARTZ darwinEvents_unlock(); #endif diff --git a/xorg-server/mi/mipointer.h b/xorg-server/mi/mipointer.h index 1500e216a..f89dff31e 100644 --- a/xorg-server/mi/mipointer.h +++ b/xorg-server/mi/mipointer.h @@ -115,7 +115,8 @@ miPointerGetPosition(DeviceIntPtr pDev, int *x, int *y); /* Moves the cursor to the specified position. May clip the co-ordinates: * x and y are modified in-place. */ extern _X_EXPORT ScreenPtr -miPointerSetPosition(DeviceIntPtr pDev, int mode, double *x, double *y); +miPointerSetPosition(DeviceIntPtr pDev, int mode, double *x, double *y, + int *nevents, InternalEvent *events); extern _X_EXPORT void miPointerUpdateSprite(DeviceIntPtr pDev); diff --git a/xorg-server/os/access.c b/xorg-server/os/access.c index 104b6a713..88a44d9e5 100644 --- a/xorg-server/os/access.c +++ b/xorg-server/os/access.c @@ -471,7 +471,7 @@ in6_fillscopeid(struct sockaddr_in6 *sin6) #if defined(__KAME__) if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) { sin6->sin6_scope_id = - ntohs(*(u_int16_t *) & sin6->sin6_addr.s6_addr[2]); + ntohs(*(u_int16_t *) &sin6->sin6_addr.s6_addr[2]); sin6->sin6_addr.s6_addr[2] = sin6->sin6_addr.s6_addr[3] = 0; } #endif diff --git a/xorg-server/os/utils.c b/xorg-server/os/utils.c index 6f75c1704..e396ba4b5 100644 --- a/xorg-server/os/utils.c +++ b/xorg-server/os/utils.c @@ -1639,7 +1639,7 @@ System(const char *cmdline) NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPTSTR) & buffer, 0, NULL)) { + (LPTSTR) &buffer, 0, NULL)) { ErrorF("[xkb] Starting '%s' failed!\n", cmdline); } else { diff --git a/xorg-server/os/xdmcp.c b/xorg-server/os/xdmcp.c index 87f04b455..0538ac53e 100644 --- a/xorg-server/os/xdmcp.c +++ b/xorg-server/os/xdmcp.c @@ -751,7 +751,7 @@ receive_packet(int socketfd) XdmcpHeader header; /* read message off socket */ - if (!XdmcpFill(socketfd, &buffer, (XdmcpNetaddr) & from, &fromlen)) + if (!XdmcpFill(socketfd, &buffer, (XdmcpNetaddr) &from, &fromlen)) return; /* reset retransmission backoff */ @@ -1059,7 +1059,7 @@ send_query_msg(void) for (i = 0; i < NumBroadcastAddresses; i++) XdmcpFlush(xdmcpSocket, &buffer, - (XdmcpNetaddr) & BroadcastAddresses[i], + (XdmcpNetaddr) &BroadcastAddresses[i], sizeof(struct sockaddr_in)); } #if defined(IPv6) && defined(AF_INET6) @@ -1098,7 +1098,7 @@ send_query_msg(void) if (SOCKADDR_FAMILY(ManagerAddress) == AF_INET6) socketfd = xdmcpSocket6; #endif - XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) & ManagerAddress, + XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) &ManagerAddress, ManagerAddressLen); } } @@ -1223,7 +1223,7 @@ send_request_msg(void) socketfd = xdmcpSocket6; #endif if (XdmcpFlush(socketfd, &buffer, - (XdmcpNetaddr) & req_sockaddr, req_socklen)) + (XdmcpNetaddr) &req_sockaddr, req_socklen)) state = XDM_AWAIT_REQUEST_RESPONSE; } @@ -1316,7 +1316,7 @@ send_manage_msg(void) if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6) socketfd = xdmcpSocket6; #endif - XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) & req_sockaddr, req_socklen); + XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen); } static void @@ -1373,7 +1373,7 @@ send_keepalive_msg(void) if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6) socketfd = xdmcpSocket6; #endif - XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) & req_sockaddr, req_socklen); + XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen); } static void diff --git a/xorg-server/test/fixes.c b/xorg-server/test/fixes.c index 7807c73ce..4ac6750e4 100644 --- a/xorg-server/test/fixes.c +++ b/xorg-server/test/fixes.c @@ -265,6 +265,32 @@ fixes_pointer_barriers_test(void) x2 = x + 100; assert(!barrier_is_blocking(&barrier, x1, y1, x2, y2, &distance)); + /* ray vert barrier */ + barrier.x1 = x; + barrier.x2 = x; + barrier.y1 = -1; + barrier.y2 = y + 100; + + /* ray barrier simple case */ + y1 = y; + y2 = y; + x1 = x + 50; + x2 = x - 50; + assert(barrier_is_blocking(&barrier, x1, y1, x2, y2, &distance)); + + /* endpoint outside y range; should be blocked */ + y1 = y - 1000; + y2 = y - 1000; + x1 = x + 50; + x2 = x - 50; + assert(barrier_is_blocking(&barrier, x1, y1, x2, y2, &distance)); + + /* endpoint outside y range */ + y1 = y + 150; + y2 = y + 150; + x1 = x + 50; + x2 = x - 50; + assert(!barrier_is_blocking(&barrier, x1, y1, x2, y2, &distance)); } static void diff --git a/xorg-server/test/input.c b/xorg-server/test/input.c index 191c81789..be988a4a3 100644 --- a/xorg-server/test/input.c +++ b/xorg-server/test/input.c @@ -406,7 +406,7 @@ _dix_test_xi_convert(DeviceEvent *ev, int expected_rc, int expected_count) assert(kbp->same_screen == FALSE); while (--count > 0) { - deviceValuator *v = (deviceValuator *) & xi[count]; + deviceValuator *v = (deviceValuator *) &xi[count]; assert(v->type == DeviceValuator); assert(v->num_valuators <= 6); diff --git a/xorg-server/test/xi2/protocol-eventconvert.c b/xorg-server/test/xi2/protocol-eventconvert.c index bb3177cc1..aea380ed5 100644 --- a/xorg-server/test/xi2/protocol-eventconvert.c +++ b/xorg-server/test/xi2/protocol-eventconvert.c @@ -694,7 +694,7 @@ test_values_XIDeviceChangedEvent(DeviceChangedEvent *in, assert(k->num_keycodes == in->keys.max_keycode - in->keys.min_keycode + 1); - kc = (uint32_t *) & k[1]; + kc = (uint32_t *) &k[1]; for (j = 0; j < k->num_keycodes; j++) { if (swap) { swapl(&kc[j]); @@ -984,6 +984,221 @@ test_convert_XITouchOwnershipEvent(void) } } +static void +test_XIBarrierEvent(BarrierEvent *in) +{ + xXIBarrierEvent *out, *swapped; + int count; + int rc; + int eventlen; + FP3232 value; + + rc = EventToXI((InternalEvent*)in, (xEvent**)&out, &count); + assert(rc == BadMatch); + + rc = EventToCore((InternalEvent*)in, (xEvent**)&out, &count); + assert(rc == BadMatch); + + rc = EventToXI2((InternalEvent*)in, (xEvent**)&out); + + assert(out->type == GenericEvent); + assert(out->extension == 0); /* IReqCode defaults to 0 */ + assert(out->evtype == GetXI2Type(in->type)); + assert(out->time == in->time); + assert(out->deviceid == in->deviceid); + assert(out->sourceid == in->sourceid); + assert(out->barrier == in->barrierid); + assert(out->flags == in->flags); + assert(out->event == in->window); + assert(out->root == in->root); + assert(out->dtime == in->dt); + assert(out->eventid == in->event_id); + assert(out->root_x == double_to_fp1616(in->root_x)); + assert(out->root_y == double_to_fp1616(in->root_y)); + + value = double_to_fp3232(in->dx); + assert(out->dx.integral == value.integral); + assert(out->dx.frac == value.frac); + value = double_to_fp3232(in->dy); + assert(out->dy.integral == value.integral); + assert(out->dy.frac == value.frac); + + eventlen = sizeof(xEvent) + out->length * 4; + swapped = calloc(1, eventlen); + XI2EventSwap((xGenericEvent *) out, (xGenericEvent *) swapped); + + swaps(&swapped->sequenceNumber); + swapl(&swapped->length); + swaps(&swapped->evtype); + swaps(&swapped->deviceid); + swapl(&swapped->time); + swapl(&swapped->eventid); + swapl(&swapped->root); + swapl(&swapped->event); + swapl(&swapped->barrier); + swapl(&swapped->dtime); + swaps(&swapped->sourceid); + swapl(&swapped->root_x); + swapl(&swapped->root_y); + swapl(&swapped->dx.integral); + swapl(&swapped->dx.frac); + swapl(&swapped->dy.integral); + swapl(&swapped->dy.frac); + + assert(memcmp(swapped, out, eventlen) == 0); + + free(swapped); + free(out); +} + +static void +test_convert_XIBarrierEvent(void) +{ + BarrierEvent in; + + memset(&in, 0, sizeof(in)); + in.header = ET_Internal; + in.type = ET_BarrierHit; + in.length = sizeof(in); + in.time = 0; + in.deviceid = 1; + in.sourceid = 2; + + test_XIBarrierEvent(&in); + + in.deviceid = 1; + while(in.deviceid & 0xFFFF) { + test_XIBarrierEvent(&in); + in.deviceid <<= 1; + } + in.deviceid = 0; + + in.sourceid = 1; + while(in.sourceid & 0xFFFF) { + test_XIBarrierEvent(&in); + in.sourceid <<= 1; + } + in.sourceid = 0; + + in.flags = 1; + while(in.flags) { + test_XIBarrierEvent(&in); + in.flags <<= 1; + } + + in.barrierid = 1; + while(in.barrierid) { + test_XIBarrierEvent(&in); + in.barrierid <<= 1; + } + + in.dt = 1; + while(in.dt) { + test_XIBarrierEvent(&in); + in.dt <<= 1; + } + + in.event_id = 1; + while(in.event_id) { + test_XIBarrierEvent(&in); + in.event_id <<= 1; + } + + in.window = 1; + while(in.window) { + test_XIBarrierEvent(&in); + in.window <<= 1; + } + + in.root = 1; + while(in.root) { + test_XIBarrierEvent(&in); + in.root <<= 1; + } + + /* pseudo-random 16 bit numbers */ + in.root_x = 1; + test_XIBarrierEvent(&in); + in.root_x = 1.3; + test_XIBarrierEvent(&in); + in.root_x = 264.908; + test_XIBarrierEvent(&in); + in.root_x = 35638.292; + test_XIBarrierEvent(&in); + + in.root_x = -1; + test_XIBarrierEvent(&in); + in.root_x = -1.3; + test_XIBarrierEvent(&in); + in.root_x = -264.908; + test_XIBarrierEvent(&in); + in.root_x = -35638.292; + test_XIBarrierEvent(&in); + + in.root_y = 1; + test_XIBarrierEvent(&in); + in.root_y = 1.3; + test_XIBarrierEvent(&in); + in.root_y = 264.908; + test_XIBarrierEvent(&in); + in.root_y = 35638.292; + test_XIBarrierEvent(&in); + + in.root_y = -1; + test_XIBarrierEvent(&in); + in.root_y = -1.3; + test_XIBarrierEvent(&in); + in.root_y = -264.908; + test_XIBarrierEvent(&in); + in.root_y = -35638.292; + test_XIBarrierEvent(&in); + + /* equally pseudo-random 32 bit numbers */ + in.dx = 1; + test_XIBarrierEvent(&in); + in.dx = 1.3; + test_XIBarrierEvent(&in); + in.dx = 264.908; + test_XIBarrierEvent(&in); + in.dx = 35638.292; + test_XIBarrierEvent(&in); + in.dx = 2947813871.2342; + test_XIBarrierEvent(&in); + + in.dx = -1; + test_XIBarrierEvent(&in); + in.dx = -1.3; + test_XIBarrierEvent(&in); + in.dx = -264.908; + test_XIBarrierEvent(&in); + in.dx = -35638.292; + test_XIBarrierEvent(&in); + in.dx = -2947813871.2342; + test_XIBarrierEvent(&in); + + in.dy = 1; + test_XIBarrierEvent(&in); + in.dy = 1.3; + test_XIBarrierEvent(&in); + in.dy = 264.908; + test_XIBarrierEvent(&in); + in.dy = 35638.292; + test_XIBarrierEvent(&in); + in.dy = 2947813871.2342; + test_XIBarrierEvent(&in); + + in.dy = -1; + test_XIBarrierEvent(&in); + in.dy = -1.3; + test_XIBarrierEvent(&in); + in.dy = -264.908; + test_XIBarrierEvent(&in); + in.dy = -35638.292; + test_XIBarrierEvent(&in); + in.dy = -2947813871.2342; + test_XIBarrierEvent(&in); +} + int main(int argc, char **argv) { @@ -992,6 +1207,7 @@ main(int argc, char **argv) test_convert_XIDeviceEvent(); test_convert_XIDeviceChangedEvent(); test_convert_XITouchOwnershipEvent(); + test_convert_XIBarrierEvent(); return 0; } diff --git a/xorg-server/test/xi2/protocol-xiquerydevice.c b/xorg-server/test/xi2/protocol-xiquerydevice.c index 9d13bbb6f..c066daa35 100644 --- a/xorg-server/test/xi2/protocol-xiquerydevice.c +++ b/xorg-server/test/xi2/protocol-xiquerydevice.c @@ -171,7 +171,7 @@ reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void *closure) (xkb->max_key_code - xkb->min_key_code + 1)); assert(any->length == (2 + ki->num_keycodes)); - kc = (uint32_t *) & ki[1]; + kc = (uint32_t *) &ki[1]; for (k = 0; k < ki->num_keycodes; k++, kc++) { if (client->swapped) swapl(kc); diff --git a/xorg-server/test/xi2/protocol-xiselectevents.c b/xorg-server/test/xi2/protocol-xiselectevents.c index 8f6b947d4..183746f98 100644 --- a/xorg-server/test/xi2/protocol-xiselectevents.c +++ b/xorg-server/test/xi2/protocol-xiselectevents.c @@ -98,7 +98,7 @@ request_XISelectEvent(xXISelectEventsReq * req, int error) xXIEventMask *mask, *next; req->length = (sz_xXISelectEventsReq / 4); - mask = (xXIEventMask *) & req[1]; + mask = (xXIEventMask *) &req[1]; for (i = 0; i < req->num_masks; i++) { req->length += sizeof(xXIEventMask) / 4 + mask->mask_len; mask = (xXIEventMask *) ((char *) &mask[1] + mask->mask_len * 4); @@ -111,7 +111,7 @@ request_XISelectEvent(xXISelectEventsReq * req, int error) client.swapped = TRUE; - mask = (xXIEventMask *) & req[1]; + mask = (xXIEventMask *) &req[1]; for (i = 0; i < req->num_masks; i++) { next = (xXIEventMask *) ((char *) &mask[1] + mask->mask_len * 4); swaps(&mask->deviceid); @@ -156,7 +156,7 @@ request_XISelectEvents_masks(xXISelectEventsReq * req) int nmasks = (XI2LASTEVENT + 7) / 8; unsigned char *bits; - mask = (xXIEventMask *) & req[1]; + mask = (xXIEventMask *) &req[1]; req->win = ROOT_WINDOW_ID; /* if a clients submits more than 100 masks, consider it insane and untested */ @@ -312,7 +312,7 @@ test_XISelectEvents(void) req->num_masks = 1; printf("Triggering bogus mask length error\n"); - mask = (xXIEventMask *) & req[1]; + mask = (xXIEventMask *) &req[1]; mask->deviceid = 0; mask->mask_len = 0xFFFF; request_XISelectEvent(req, BadLength); @@ -320,7 +320,7 @@ test_XISelectEvents(void) /* testing various device ids */ printf("Testing existing device ids.\n"); for (i = 0; i < 6; i++) { - mask = (xXIEventMask *) & req[1]; + mask = (xXIEventMask *) &req[1]; mask->deviceid = i; mask->mask_len = 1; req->win = ROOT_WINDOW_ID; @@ -332,7 +332,7 @@ test_XISelectEvents(void) for (i = 6; i <= 0xFFFF; i++) { req->win = ROOT_WINDOW_ID; req->num_masks = 1; - mask = (xXIEventMask *) & req[1]; + mask = (xXIEventMask *) &req[1]; mask->deviceid = i; mask->mask_len = 1; request_XISelectEvent(req, BadDevice); diff --git a/xorg-server/xfixes/cursor.c b/xorg-server/xfixes/cursor.c index ffee4d6ab..568e717fa 100644 --- a/xorg-server/xfixes/cursor.c +++ b/xorg-server/xfixes/cursor.c @@ -56,12 +56,11 @@ #include "windowstr.h" #include "xace.h" #include "list.h" -#include "exglobals.h" +#include "xibarriers.h" static RESTYPE CursorClientType; static RESTYPE CursorHideCountType; static RESTYPE CursorWindowType; -RESTYPE PointerBarrierType; static CursorPtr CursorCurrent[MAXDEVICES]; static DevPrivateKeyRec CursorScreenPrivateKeyRec; @@ -113,16 +112,6 @@ typedef struct _CursorHideCountRec { XID resource; } CursorHideCountRec; -typedef struct PointerBarrierClient *PointerBarrierClientPtr; - -struct PointerBarrierClient { - ScreenPtr screen; - struct PointerBarrier barrier; - struct xorg_list entry; - int num_devices; - int *device_ids; /* num_devices */ -}; - /* * Wrap DisplayCursor to catch cursor change events */ @@ -130,9 +119,7 @@ struct PointerBarrierClient { typedef struct _CursorScreen { DisplayCursorProcPtr DisplayCursor; CloseScreenProcPtr CloseScreen; - ConstrainCursorHarderProcPtr ConstrainCursorHarder; CursorHideCountPtr pCursorHideCounts; - struct xorg_list barriers; } CursorScreenRec, *CursorScreenPtr; #define GetCursorScreen(s) ((CursorScreenPtr)dixLookupPrivate(&(s)->devPrivates, CursorScreenPrivateKey)) @@ -199,11 +186,9 @@ CursorCloseScreen(ScreenPtr pScreen) Bool ret; _X_UNUSED CloseScreenProcPtr close_proc; _X_UNUSED DisplayCursorProcPtr display_proc; - _X_UNUSED ConstrainCursorHarderProcPtr constrain_proc; Unwrap(cs, pScreen, CloseScreen, close_proc); Unwrap(cs, pScreen, DisplayCursor, display_proc); - Unwrap(cs, pScreen, ConstrainCursorHarder, constrain_proc); deleteCursorHideCountsForScreen(pScreen); ret = (*pScreen->CloseScreen) (pScreen); free(cs); @@ -1013,384 +998,15 @@ CursorFreeWindow(pointer data, XID id) return 1; } -static BOOL -barrier_is_horizontal(const struct PointerBarrier *barrier) -{ - return barrier->y1 == barrier->y2; -} - -static BOOL -barrier_is_vertical(const struct PointerBarrier *barrier) -{ - return barrier->x1 == barrier->x2; -} - -/** - * @return The set of barrier movement directions the movement vector - * x1/y1 → x2/y2 represents. - */ -int -barrier_get_direction(int x1, int y1, int x2, int y2) -{ - int direction = 0; - - /* which way are we trying to go */ - if (x2 > x1) - direction |= BarrierPositiveX; - if (x2 < x1) - direction |= BarrierNegativeX; - if (y2 > y1) - direction |= BarrierPositiveY; - if (y2 < y1) - direction |= BarrierNegativeY; - - return direction; -} - -/** - * Test if the barrier may block movement in the direction defined by - * x1/y1 → x2/y2. This function only tests whether the directions could be - * blocked, it does not test if the barrier actually blocks the movement. - * - * @return TRUE if the barrier blocks the direction of movement or FALSE - * otherwise. - */ -BOOL -barrier_is_blocking_direction(const struct PointerBarrier * barrier, - int direction) -{ - /* Barriers define which way is ok, not which way is blocking */ - return (barrier->directions & direction) != direction; -} - -/** - * Test if the movement vector x1/y1 → x2/y2 is intersecting with the - * barrier. A movement vector with the startpoint or endpoint adjacent to - * the barrier itself counts as intersecting. - * - * @param x1 X start coordinate of movement vector - * @param y1 Y start coordinate of movement vector - * @param x2 X end coordinate of movement vector - * @param y2 Y end coordinate of movement vector - * @param[out] distance The distance between the start point and the - * intersection with the barrier (if applicable). - * @return TRUE if the barrier intersects with the given vector - */ -BOOL -barrier_is_blocking(const struct PointerBarrier * barrier, - int x1, int y1, int x2, int y2, double *distance) -{ - BOOL rc = FALSE; - float ua, ub, ud; - int dir = barrier_get_direction(x1, y1, x2, y2); - - /* Algorithm below doesn't handle edge cases well, hence the extra - * checks. */ - if (barrier_is_vertical(barrier)) { - /* handle immediate barrier adjacency, moving away */ - if (dir & BarrierPositiveX && x1 == barrier->x1) - return FALSE; - if (dir & BarrierNegativeX && x1 == (barrier->x1 - 1)) - return FALSE; - /* startpoint adjacent to barrier, moving towards -> block */ - if (dir & BarrierPositiveX && x1 == (barrier->x1 - 1) && y1 >= barrier->y1 && y1 <= barrier->y2) { - *distance = 0; - return TRUE; - } - if (dir & BarrierNegativeX && x1 == barrier->x1 && y1 >= barrier->y1 && y1 <= barrier->y2) { - *distance = 0; - return TRUE; - } - } - else { - /* handle immediate barrier adjacency, moving away */ - if (dir & BarrierPositiveY && y1 == barrier->y1) - return FALSE; - if (dir & BarrierNegativeY && y1 == (barrier->y1 - 1)) - return FALSE; - /* startpoint adjacent to barrier, moving towards -> block */ - if (dir & BarrierPositiveY && y1 == (barrier->y1 - 1) && x1 >= barrier->x1 && x1 <= barrier->x2) { - *distance = 0; - return TRUE; - } - if (dir & BarrierNegativeY && y1 == barrier->y1 && x1 >= barrier->x1 && x1 <= barrier->x2) { - *distance = 0; - return TRUE; - } - } - - /* not an edge case, compute distance */ - ua = 0; - ud = (barrier->y2 - barrier->y1) * (x2 - x1) - (barrier->x2 - - barrier->x1) * (y2 - y1); - if (ud != 0) { - ua = ((barrier->x2 - barrier->x1) * (y1 - barrier->y1) - - (barrier->y2 - barrier->y1) * (x1 - barrier->x1)) / ud; - ub = ((x2 - x1) * (y1 - barrier->y1) - - (y2 - y1) * (x1 - barrier->x1)) / ud; - if (ua < 0 || ua > 1 || ub < 0 || ub > 1) - ua = 0; - } - - if (ua > 0 && ua <= 1) { - double ix = barrier->x1 + ua * (barrier->x2 - barrier->x1); - double iy = barrier->y1 + ua * (barrier->y2 - barrier->y1); - - *distance = sqrt(pow(x1 - ix, 2) + pow(y1 - iy, 2)); - rc = TRUE; - } - - return rc; -} - -static BOOL -barrier_blocks_device(struct PointerBarrierClient *client, - DeviceIntPtr dev) -{ - int i; - int master_id; - - /* Clients with no devices are treated as - * if they specified XIAllDevices. */ - if (client->num_devices == 0) - return TRUE; - - master_id = GetMaster(dev, POINTER_OR_FLOAT)->id; - - for (i = 0; i < client->num_devices; i++) { - int device_id = client->device_ids[i]; - if (device_id == XIAllDevices || - device_id == XIAllMasterDevices || - device_id == master_id) - return TRUE; - } - - return FALSE; -} - -/** - * Find the nearest barrier that is blocking movement from x1/y1 to x2/y2. - * - * @param dir Only barriers blocking movement in direction dir are checked - * @param x1 X start coordinate of movement vector - * @param y1 Y start coordinate of movement vector - * @param x2 X end coordinate of movement vector - * @param y2 Y end coordinate of movement vector - * @return The barrier nearest to the movement origin that blocks this movement. - */ -static struct PointerBarrier * -barrier_find_nearest(CursorScreenPtr cs, DeviceIntPtr dev, - int dir, - int x1, int y1, int x2, int y2) -{ - struct PointerBarrierClient *c; - struct PointerBarrier *nearest = NULL; - double min_distance = INT_MAX; /* can't get higher than that in X anyway */ - - xorg_list_for_each_entry(c, &cs->barriers, entry) { - struct PointerBarrier *b = &c->barrier; - double distance; - - if (!barrier_is_blocking_direction(b, dir)) - continue; - - if (!barrier_blocks_device(c, dev)) - continue; - - if (barrier_is_blocking(b, x1, y1, x2, y2, &distance)) { - if (min_distance > distance) { - min_distance = distance; - nearest = b; - } - } - } - - return nearest; -} - -/** - * Clamp to the given barrier given the movement direction specified in dir. - * - * @param barrier The barrier to clamp to - * @param dir The movement direction - * @param[out] x The clamped x coordinate. - * @param[out] y The clamped x coordinate. - */ -void -barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x, - int *y) -{ - if (barrier_is_vertical(barrier)) { - if ((dir & BarrierNegativeX) & ~barrier->directions) - *x = barrier->x1; - if ((dir & BarrierPositiveX) & ~barrier->directions) - *x = barrier->x1 - 1; - } - if (barrier_is_horizontal(barrier)) { - if ((dir & BarrierNegativeY) & ~barrier->directions) - *y = barrier->y1; - if ((dir & BarrierPositiveY) & ~barrier->directions) - *y = barrier->y1 - 1; - } -} - -static void -CursorConstrainCursorHarder(DeviceIntPtr dev, ScreenPtr screen, int mode, - int *x, int *y) -{ - CursorScreenPtr cs = GetCursorScreen(screen); - - if (!xorg_list_is_empty(&cs->barriers) && !IsFloating(dev) && - mode == Relative) { - int ox, oy; - int dir; - int i; - struct PointerBarrier *nearest = NULL; - - /* where are we coming from */ - miPointerGetPosition(dev, &ox, &oy); - - /* How this works: - * Given the origin and the movement vector, get the nearest barrier - * to the origin that is blocking the movement. - * Clamp to that barrier. - * Then, check from the clamped intersection to the original - * destination, again finding the nearest barrier and clamping. - */ - dir = barrier_get_direction(ox, oy, *x, *y); - -#define MAX_BARRIERS 2 - for (i = 0; i < MAX_BARRIERS; i++) { - nearest = barrier_find_nearest(cs, dev, dir, ox, oy, *x, *y); - if (!nearest) - break; - - barrier_clamp_to_barrier(nearest, dir, x, y); - - if (barrier_is_vertical(nearest)) { - dir &= ~(BarrierNegativeX | BarrierPositiveX); - ox = *x; - } - else if (barrier_is_horizontal(nearest)) { - dir &= ~(BarrierNegativeY | BarrierPositiveY); - oy = *y; - } - } - } - - if (cs->ConstrainCursorHarder) { - screen->ConstrainCursorHarder = cs->ConstrainCursorHarder; - screen->ConstrainCursorHarder(dev, screen, mode, x, y); - screen->ConstrainCursorHarder = CursorConstrainCursorHarder; - } -} - -static int -CreatePointerBarrierClient(ScreenPtr screen, ClientPtr client, - xXFixesCreatePointerBarrierReq * stuff, - PointerBarrierClientPtr *client_out) -{ - CursorScreenPtr cs = GetCursorScreen(screen); - int err; - int size; - int i; - CARD16 *in_devices; - struct PointerBarrierClient *ret; - - size = sizeof(*ret) + sizeof(int) * stuff->num_devices; - ret = malloc(size); - - *client_out = NULL; - - if (!ret) { - return BadAlloc; - } - - ret->screen = screen; - ret->num_devices = stuff->num_devices; - if (ret->num_devices > 0) - ret->device_ids = (int*)&ret[1]; - else - ret->device_ids = NULL; - - in_devices = (CARD16 *) &stuff[1]; - for (i = 0; i < stuff->num_devices; i++) { - int device_id = in_devices[i]; - DeviceIntPtr device; - - if ((err = dixLookupDevice (&device, device_id, - client, DixReadAccess))) { - client->errorValue = device_id; - goto error; - } - - if (!IsMaster (device)) { - client->errorValue = device_id; - err = BadDevice; - goto error; - } - - ret->device_ids[i] = device_id; - } - - ret->barrier.x1 = min(stuff->x1, stuff->x2); - ret->barrier.x2 = max(stuff->x1, stuff->x2); - ret->barrier.y1 = min(stuff->y1, stuff->y2); - ret->barrier.y2 = max(stuff->y1, stuff->y2); - ret->barrier.directions = stuff->directions & 0x0f; - if (barrier_is_horizontal(&ret->barrier)) - ret->barrier.directions &= ~(BarrierPositiveX | BarrierNegativeX); - if (barrier_is_vertical(&ret->barrier)) - ret->barrier.directions &= ~(BarrierPositiveY | BarrierNegativeY); - xorg_list_add(&ret->entry, &cs->barriers); - - *client_out = ret; - return Success; - - error: - free(ret); - return err; -} - int ProcXFixesCreatePointerBarrier(ClientPtr client) { - int err; - WindowPtr pWin; - struct PointerBarrierClient *barrier; - struct PointerBarrier b; - REQUEST(xXFixesCreatePointerBarrierReq); REQUEST_FIXED_SIZE(xXFixesCreatePointerBarrierReq, pad_to_int32(stuff->num_devices)); LEGAL_NEW_RESOURCE(stuff->barrier, client); - err = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess); - if (err != Success) { - client->errorValue = stuff->window; - return err; - } - - b.x1 = stuff->x1; - b.x2 = stuff->x2; - b.y1 = stuff->y1; - b.y2 = stuff->y2; - - if (!barrier_is_horizontal(&b) && !barrier_is_vertical(&b)) - return BadValue; - - /* no 0-sized barriers */ - if (barrier_is_horizontal(&b) && barrier_is_vertical(&b)) - return BadValue; - - if ((err = CreatePointerBarrierClient(pWin->drawable.pScreen, - client, stuff, &barrier))) - return err; - - if (!AddResource(stuff->barrier, PointerBarrierType, &barrier->barrier)) - return BadAlloc; - - return Success; + return XICreatePointerBarrier(client, stuff); } int @@ -1418,49 +1034,14 @@ SProcXFixesCreatePointerBarrier(ClientPtr client) return ProcXFixesVector[stuff->xfixesReqType] (client); } -static int -CursorFreeBarrier(void *data, XID id) -{ - struct PointerBarrierClient *b = NULL, *barrier; - ScreenPtr screen; - CursorScreenPtr cs; - - barrier = container_of(data, struct PointerBarrierClient, barrier); - - screen = barrier->screen; - cs = GetCursorScreen(screen); - - /* find and unlink from the screen private */ - xorg_list_for_each_entry(b, &cs->barriers, entry) { - if (b == barrier) { - xorg_list_del(&b->entry); - break; - } - } - - free(barrier); - return Success; -} - int ProcXFixesDestroyPointerBarrier(ClientPtr client) { - int err; - void *barrier; - REQUEST(xXFixesDestroyPointerBarrierReq); REQUEST_SIZE_MATCH(xXFixesDestroyPointerBarrierReq); - err = dixLookupResourceByType((void **) &barrier, stuff->barrier, - PointerBarrierType, client, DixDestroyAccess); - if (err != Success) { - client->errorValue = stuff->barrier; - return err; - } - - FreeResource(stuff->barrier, RT_NONE); - return Success; + return XIDestroyPointerBarrier(client, stuff); } int @@ -1492,10 +1073,8 @@ XFixesCursorInit(void) cs = (CursorScreenPtr) calloc(1, sizeof(CursorScreenRec)); if (!cs) return FALSE; - xorg_list_init(&cs->barriers); Wrap(cs, pScreen, CloseScreen, CursorCloseScreen); Wrap(cs, pScreen, DisplayCursor, CursorDisplayCursor); - Wrap(cs, pScreen, ConstrainCursorHarder, CursorConstrainCursorHarder); cs->pCursorHideCounts = NULL; SetCursorScreen(pScreen, cs); } @@ -1505,9 +1084,6 @@ XFixesCursorInit(void) "XFixesCursorHideCount"); CursorWindowType = CreateNewResourceType(CursorFreeWindow, "XFixesCursorWindow"); - PointerBarrierType = CreateNewResourceType(CursorFreeBarrier, - "XFixesPointerBarrier"); - return CursorClientType && CursorHideCountType && CursorWindowType && - PointerBarrierType; + return CursorClientType && CursorHideCountType && CursorWindowType; } diff --git a/xorg-server/xfixes/xfixes.h b/xorg-server/xfixes/xfixes.h index 19af09f7d..98828710f 100644 --- a/xorg-server/xfixes/xfixes.h +++ b/xorg-server/xfixes/xfixes.h @@ -30,7 +30,6 @@ #include "resource.h" extern _X_EXPORT RESTYPE RegionResType; -extern _X_EXPORT RESTYPE PointerBarrierType; extern _X_EXPORT int XFixesErrorBase; #define VERIFY_REGION(pRegion, rid, client, mode) \ @@ -52,20 +51,6 @@ extern _X_EXPORT int XFixesErrorBase; extern _X_EXPORT RegionPtr XFixesRegionCopy(RegionPtr pRegion); -struct PointerBarrier { - CARD16 x1, x2, y1, y2; - CARD32 directions; -}; - -extern int - barrier_get_direction(int, int, int, int); -extern BOOL -barrier_is_blocking(const struct PointerBarrier *, int, int, int, int, - double *); -extern BOOL barrier_is_blocking_direction(const struct PointerBarrier *, int); -extern void - -barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x, - int *y); +#include "xibarriers.h" #endif /* _XFIXES_H_ */ diff --git a/xorg-server/xkb/xkb.c b/xorg-server/xkb/xkb.c index c67896f06..7e51e4080 100644 --- a/xorg-server/xkb/xkb.c +++ b/xorg-server/xkb/xkb.c @@ -1650,8 +1650,8 @@ CheckKeyTypes(ClientPtr client, xkbKTSetMapEntryWireDesc *mapWire; xkbModsWireDesc *preWire; - mapWire = (xkbKTSetMapEntryWireDesc *) & wire[1]; - preWire = (xkbModsWireDesc *) & mapWire[wire->nMapEntries]; + mapWire = (xkbKTSetMapEntryWireDesc *) &wire[1]; + preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries]; for (n = 0; n < wire->nMapEntries; n++) { if (client->swapped) { swaps(&mapWire[n].virtualMods); @@ -1761,8 +1761,8 @@ CheckKeySyms(ClientPtr client, *errorRtrn = _XkbErrCode3(0x17, i + req->firstKeySym, wire->nSyms); return 0; } - pSyms = (KeySym *) & wire[1]; - wire = (xkbSymMapWireDesc *) & pSyms[wire->nSyms]; + pSyms = (KeySym *) &wire[1]; + wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms]; } map = &xkb->map->key_sym_map[i]; @@ -2039,7 +2039,7 @@ SetKeyTypes(XkbDescPtr xkb, unsigned tmp; mapWire = (xkbKTSetMapEntryWireDesc *) map; - preWire = (xkbModsWireDesc *) & mapWire[wire->nMapEntries]; + preWire = (xkbModsWireDesc *) &mapWire[wire->nMapEntries]; for (n = 0; n < wire->nMapEntries; n++) { pOld->map[n].active = 1; pOld->map[n].mods.mask = mapWire[n].realMods; @@ -2098,7 +2098,7 @@ SetKeySyms(ClientPtr client, oldMap = &xkb->map->key_sym_map[req->firstKeySym]; for (i = 0; i < req->nKeySyms; i++, oldMap++) { - pSyms = (KeySym *) & wire[1]; + pSyms = (KeySym *) &wire[1]; if (wire->nSyms > 0) { newSyms = XkbResizeKeySyms(xkb, i + req->firstKeySym, wire->nSyms); for (s = 0; s < wire->nSyms; s++) { @@ -2116,7 +2116,7 @@ SetKeySyms(ClientPtr client, oldMap->kt_index[3] = wire->ktIndex[3]; oldMap->group_info = wire->groupInfo; oldMap->width = wire->width; - wire = (xkbSymMapWireDesc *) & pSyms[wire->nSyms]; + wire = (xkbSymMapWireDesc *) &pSyms[wire->nSyms]; } first = req->firstKeySym; last = first + req->nKeySyms - 1; @@ -2408,7 +2408,7 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req, } if ((req->present & XkbKeyTypesMask) && - (!CheckKeyTypes(client, xkb, req, (xkbKeyTypeWireDesc **) & values, + (!CheckKeyTypes(client, xkb, req, (xkbKeyTypeWireDesc **) &values, &nTypes, mapWidths))) { client->errorValue = nTypes; return BadValue; @@ -2433,7 +2433,7 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req, if ((req->present & XkbKeySymsMask) && (!CheckKeySyms(client, xkb, req, nTypes, mapWidths, symsPerKey, - (xkbSymMapWireDesc **) & values, &error))) { + (xkbSymMapWireDesc **) &values, &error))) { client->errorValue = error; return BadValue; } @@ -2447,7 +2447,7 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req, if ((req->present & XkbKeyBehaviorsMask) && (!CheckKeyBehaviors - (xkb, req, (xkbBehaviorWireDesc **) & values, &error))) { + (xkb, req, (xkbBehaviorWireDesc **) &values, &error))) { client->errorValue = error; return BadValue; } @@ -2469,7 +2469,7 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req, } if ((req->present & XkbVirtualModMapMask) && (!CheckVirtualModMap - (xkb, req, (xkbVModMapWireDesc **) & values, &error))) { + (xkb, req, (xkbVModMapWireDesc **) &values, &error))) { client->errorValue = error; return BadValue; } @@ -5097,7 +5097,7 @@ _CheckSetOverlay(char **wire_inout, } CHK_ATOM_ONLY(olWire->name); ol = XkbAddGeomOverlay(section, olWire->name, olWire->nRows); - rWire = (xkbOverlayRowWireDesc *) & olWire[1]; + rWire = (xkbOverlayRowWireDesc *) &olWire[1]; for (r = 0; r < olWire->nRows; r++) { register int k; xkbOverlayKeyWireDesc *kWire; @@ -5109,7 +5109,7 @@ _CheckSetOverlay(char **wire_inout, return BadMatch; } row = XkbAddGeomOverlayRow(ol, rWire->rowUnder, rWire->nKeys); - kWire = (xkbOverlayKeyWireDesc *) & rWire[1]; + kWire = (xkbOverlayKeyWireDesc *) &rWire[1]; for (k = 0; k < rWire->nKeys; k++, kWire++) { if (XkbAddGeomOverlayKey(ol, row, (char *) kWire->over, @@ -5163,7 +5163,7 @@ _CheckSetSections(XkbGeometryPtr geom, section->width = sWire->width; section->height = sWire->height; section->angle = sWire->angle; - rWire = (xkbRowWireDesc *) & sWire[1]; + rWire = (xkbRowWireDesc *) &sWire[1]; for (r = 0; r < sWire->nRows; r++) { register int k; XkbRowPtr row; @@ -5179,7 +5179,7 @@ _CheckSetSections(XkbGeometryPtr geom, row->top = rWire->top; row->left = rWire->left; row->vertical = rWire->vertical; - kWire = (xkbKeyWireDesc *) & rWire[1]; + kWire = (xkbKeyWireDesc *) &rWire[1]; for (k = 0; k < rWire->nKeys; k++) { XkbKeyPtr key; @@ -5201,7 +5201,7 @@ _CheckSetSections(XkbGeometryPtr geom, return BadMatch; } } - rWire = (xkbRowWireDesc *) & kWire[rWire->nKeys]; + rWire = (xkbRowWireDesc *) &kWire[rWire->nKeys]; } wire = (char *) rWire; if (sWire->nDoodads > 0) { @@ -5265,7 +5265,7 @@ _CheckSetShapes(XkbGeometryPtr geom, if (!ol) return BadAlloc; ol->corner_radius = olWire->cornerRadius; - ptWire = (xkbPointWireDesc *) & olWire[1]; + ptWire = (xkbPointWireDesc *) &olWire[1]; for (p = 0, pt = ol->points; p < olWire->nPoints; p++, pt++) { pt->x = ptWire[p].x; pt->y = ptWire[p].y; @@ -6348,7 +6348,7 @@ ProcXkbGetDeviceInfo(ClientPtr client) xkbActionWireDesc *awire; sz = rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc); - awire = (xkbActionWireDesc *) & dev->button->xkb_acts[rep.firstBtnRtrn]; + awire = (xkbActionWireDesc *) &dev->button->xkb_acts[rep.firstBtnRtrn]; WriteToClient(client, sz, awire); length -= sz; } diff --git a/xorg-server/xkb/xkbout.c b/xorg-server/xkb/xkbout.c index cd1ae0b4e..7bb6ceafe 100644 --- a/xorg-server/xkb/xkbout.c +++ b/xorg-server/xkb/xkbout.c @@ -522,7 +522,7 @@ XkbWriteXKBSymbols(FILE * file, for (s = 0; s < XkbKeyGroupWidth(xkb, i, g); s++) { if (s != 0) fprintf(file, ", "); - WriteXKBAction(file, xkb, (XkbAnyAction *) & acts[s]); + WriteXKBAction(file, xkb, (XkbAnyAction *) &acts[s]); } fprintf(file, " ]"); acts += XkbKeyGroupsWidth(xkb, i); diff --git a/xorg-server/xkeyboard-config/rules/base.o_s.part b/xorg-server/xkeyboard-config/rules/base.o_s.part index b4772b4c6..7d880f438 100644 --- a/xorg-server/xkeyboard-config/rules/base.o_s.part +++ b/xorg-server/xkeyboard-config/rules/base.o_s.part @@ -6,7 +6,7 @@ altwin:left_meta_win = +altwin(left_meta_win) altwin:hyper_win = +altwin(hyper_win) altwin:alt_super_win = +altwin(alt_super_win) - altwin:swap_lalt_lwin = +altwin(swap_lalt_lwin) + altwin:swap_alt_win = +altwin(swap_alt_win) grp:switch = +group(switch) grp:lswitch = +group(lswitch) grp:win_switch = +group(win_switch) diff --git a/xorg-server/xkeyboard-config/rules/base.xml.in b/xorg-server/xkeyboard-config/rules/base.xml.in index 8d8075004..4b18513e9 100644 --- a/xorg-server/xkeyboard-config/rules/base.xml.in +++ b/xorg-server/xkeyboard-config/rules/base.xml.in @@ -6196,8 +6196,8 @@ diff --git a/xorg-server/xkeyboard-config/rules/compat/layoutsMapping.lst b/xorg-server/xkeyboard-config/rules/compat/layoutsMapping.lst index cecda6d8a..a1a021855 100644 --- a/xorg-server/xkeyboard-config/rules/compat/layoutsMapping.lst +++ b/xorg-server/xkeyboard-config/rules/compat/layoutsMapping.lst @@ -14,7 +14,6 @@ iu ca(ike) lo la kan in(kan) mi mao -ml in(mal) ogham ie(ogam) ori ie(ori) sapmi no(smi) diff --git a/xorg-server/xkeyboard-config/symbols/altwin b/xorg-server/xkeyboard-config/symbols/altwin index 92599128f..f7578b493 100644 --- a/xorg-server/xkeyboard-config/symbols/altwin +++ b/xorg-server/xkeyboard-config/symbols/altwin @@ -72,8 +72,21 @@ xkb_symbols "alt_super_win" { }; partial modifier_keys +xkb_symbols "swap_alt_win" { + include "altwin(swap_lalt_lwin)" + include "altwin(swap_ralt_rwin)" +}; + +partial hidden modifier_keys xkb_symbols "swap_lalt_lwin" { key { type[Group1] = "ONE_LEVEL", symbols[Group1] = [ Super_L ] }; key { [ Alt_L, Meta_L ] }; }; + +partial hidden modifier_keys +xkb_symbols "swap_ralt_rwin" { + key { type[Group1] = "ONE_LEVEL", + symbols[Group1] = [ Super_R ] }; + key { [ Alt_R, Meta_R ] }; +}; diff --git a/xorg-server/xkeyboard-config/symbols/cd b/xorg-server/xkeyboard-config/symbols/cd index 78803dbcc..5e51535cc 100644 --- a/xorg-server/xkeyboard-config/symbols/cd +++ b/xorg-server/xkeyboard-config/symbols/cd @@ -24,10 +24,10 @@ xkb_symbols "basic" { key { [ minus, underscore, percent, degree ] }; key { [ equal, plus, multiply, division ] }; - key { [ a, A, ae, AE ] }; + key { [ a, A, ae, AE ] }; key { [ z, Z ] }; key { [ e, E, oe, OE ] }; - key { [ r, R ] }; + key { [ r, R ] }; key { [ t, T ] }; key { [ y, Y ] }; key { [ u, U, 0x01000289, 0x01000244 ] }; @@ -46,16 +46,16 @@ xkb_symbols "basic" { key { [ j, J ] }; key { [ k, K ] }; key { [ l, L ] }; - key { [ m, M ] }; - key { [0x01000254, 0x01000186 ] }; - key { [ backslash, bar ] }; + key { [ m, M ] }; + key { [0x01000254, 0x01000186 ] }; + key { [ backslash, bar ] }; key { [ w, W ] }; - key { [ x, X ] }; + key { [ x, X ] }; key { [ c, C, ccedilla, Ccedilla ] }; key { [ v, V ] }; key { [ b, B ] }; - key { [ n, N ] }; + key { [ n, N, 0x01000014B, 0x0100014A ] }; key { [ comma, question, 0x01000327 ] }; key { [ semicolon, period ] }; key { [ colon, slash ] }; diff --git a/xorg-server/xkeyboard-config/symbols/gr b/xorg-server/xkeyboard-config/symbols/gr index f4364cf89..d7d126009 100644 --- a/xorg-server/xkeyboard-config/symbols/gr +++ b/xorg-server/xkeyboard-config/symbols/gr @@ -73,7 +73,7 @@ xkb_symbols "simple" { key { [ equal, plus ] }; // = + key { [ bracketleft, braceleft ] }; // [ { - key { [ bracketright, braceright ] }; // [ { + key { [ bracketright, braceright ] }; // ] } key { [ apostrophe, quotedbl ] }; // ' " @@ -180,7 +180,9 @@ xkb_symbols "polytonic" { key { [ dead_iota, VoidSymbol, dead_breve ] }; // ͺ ˘ key { [ dead_acute, dead_psili ] }; // ´ ̓ - key { [ dead_grave, dead_dasia ] }; // ` ̔ + key { type[Group1]="FOUR_LEVEL", + [ dead_grave, dead_dasia, apostrophe, quotedbl ] }; + // ` ̔ ' " }; partial alphanumeric_keys alternate_group -- cgit v1.2.3