Fix formatting of address operators
The formatter confused address operators preceded by casts with bitwise-and expressions, placing spaces on either side of both. That syntax isn't used by ordinary address operators, however, so fix them for consistency. Signed-off-by: Yaakov Selkowitz <yselkowitz@users.sourceforge.net> Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
This commit is contained in:
parent
b51a1bd276
commit
ea1d76d1b6
|
@ -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]) {
|
||||
|
|
|
@ -646,7 +646,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 +654,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 +765,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);
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -79,7 +79,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;
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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)) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -451,7 +451,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;
|
||||
|
||||
|
|
|
@ -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]) {
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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),
|
||||
|
|
|
@ -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)"
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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->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->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->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->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->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
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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];
|
||||
|
||||
|
|
|
@ -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 =
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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());
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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)) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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:");
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 {
|
||||
|
|
12
os/xdmcp.c
12
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
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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]);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
36
xkb/xkb.c
36
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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
Loading…
Reference in New Issue