int XSetClipRectangles ( register Display *dpy, GC gc, int clip_x_origin, int clip_y_origin, XRectangle *rectangles, int n, int ordering) { LockDisplay(dpy); _XSetClipRectangles (dpy, gc, clip_x_origin, clip_y_origin, rectangles, n, ordering); UnlockDisplay(dpy); SyncHandle(); return 1; }
void XFixesShowCursor (Display *dpy, Window win) { XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); xXFixesShowCursorReq *req; XFixesSimpleCheckExtension (dpy, info); if (info->major_version < 4) return; LockDisplay (dpy); GetReq (XFixesShowCursor, req); req->reqType = info->codes->major_opcode; req->xfixesReqType = X_XFixesShowCursor; req->window = win; UnlockDisplay (dpy); SyncHandle (); }
static GLboolean getFBConfigs(struct glx_screen *psc, struct glx_display *priv, int screen) { xGLXGetFBConfigsReq *fb_req; xGLXGetFBConfigsSGIXReq *sgi_req; xGLXVendorPrivateWithReplyReq *vpreq; xGLXGetFBConfigsReply reply; Display *dpy = priv->dpy; psc->serverGLXexts = __glXQueryServerString(dpy, priv->majorOpcode, screen, GLX_EXTENSIONS); LockDisplay(dpy); psc->configs = NULL; if (atof(priv->serverGLXversion) >= 1.3) { GetReq(GLXGetFBConfigs, fb_req); fb_req->reqType = priv->majorOpcode; fb_req->glxCode = X_GLXGetFBConfigs; fb_req->screen = screen; } else if (strstr(psc->serverGLXexts, "GLX_SGIX_fbconfig") != NULL) { GetReqExtra(GLXVendorPrivateWithReply, sz_xGLXGetFBConfigsSGIXReq - sz_xGLXVendorPrivateWithReplyReq, vpreq); sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq; sgi_req->reqType = priv->majorOpcode; sgi_req->glxCode = X_GLXVendorPrivateWithReply; sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX; sgi_req->screen = screen; } else goto out; if (!_XReply(dpy, (xReply *) & reply, 0, False)) goto out; psc->configs = createConfigsFromProperties(dpy, reply.numFBConfigs, reply.numAttribs * 2, screen, GL_TRUE); out: UnlockDisplay(dpy); return psc->configs != NULL; }
/* * XdbeDeallocateBackBufferName - * This function frees a drawable ID, buffer, that was obtained via * XdbeAllocateBackBufferName. The buffer must refer to the back buffer * of the specified window, or a protocol error results. */ Status XdbeDeallocateBackBufferName ( Display *dpy, XdbeBackBuffer buffer) { XExtDisplayInfo *info = find_display (dpy); register xDbeDeallocateBackBufferNameReq *req; DbeCheckExtension (dpy, info, (Status)0 /* failure */); LockDisplay (dpy); DbeGetReq (DbeDeallocateBackBufferName, req, info); req->buffer = buffer; UnlockDisplay (dpy); SyncHandle (); return (Status)1; /* success */ }
Bool ephyrHostGLXQueryVersion(int *a_major, int *a_minor) { Bool is_ok = FALSE; Display *dpy = hostx_get_display(); int major_opcode = 0; xGLXQueryVersionReq *req = NULL; xGLXQueryVersionReply reply; EPHYR_RETURN_VAL_IF_FAIL(a_major && a_minor, FALSE); EPHYR_LOG("enter\n"); if (glx_major) { *a_major = glx_major; *a_minor = glx_minor; return TRUE; } if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) { EPHYR_LOG_ERROR("failed to get major opcode\n"); goto out; } EPHYR_LOG("major opcode: %d\n", major_opcode); /* Send the glXQueryVersion request */ memset(&reply, 0, sizeof(reply)); LockDisplay(dpy); GetReq(GLXQueryVersion, req); req->reqType = major_opcode; req->glxCode = X_GLXQueryVersion; req->majorVersion = 2; req->minorVersion = 1; _XReply(dpy, (xReply *) &reply, 0, False); UnlockDisplay(dpy); SyncHandle(); *a_major = glx_major = reply.majorVersion; *a_minor = glx_minor = reply.minorVersion; EPHYR_LOG("major:%d, minor:%d\n", *a_major, *a_minor); is_ok = TRUE; out: EPHYR_LOG("leave\n"); return is_ok; }
Status _xvmc_destroy_context ( Display *dpy, XvMCContext *context ) { XExtDisplayInfo *info = xvmc_find_display(dpy); xvmcDestroyContextReq *req; XvMCCheckExtension (dpy, info, BadImplementation); LockDisplay (dpy); XvMCGetReq (DestroyContext, req); req->context_id = context->context_id; UnlockDisplay (dpy); SyncHandle (); return Success; }
Status _xvmc_destroy_subpicture( Display *dpy, XvMCSubpicture *subpicture ) { XExtDisplayInfo *info = xvmc_find_display(dpy); xvmcDestroySubpictureReq *req; XvMCCheckExtension (dpy, info, BadImplementation); LockDisplay (dpy); XvMCGetReq (DestroySubpicture, req); req->subpicture_id = subpicture->subpicture_id; UnlockDisplay (dpy); SyncHandle (); return Success; }
int XRaiseWindow ( register Display *dpy, Window w) { register xConfigureWindowReq *req; unsigned long val = Above; /* needed for macro below */ LockDisplay(dpy); GetReqExtra(ConfigureWindow, 4, req); req->window = w; req->mask = CWStackMode; OneDataCard32 (dpy, NEXTPTR(req,xConfigureWindowReq), val); UnlockDisplay(dpy); SyncHandle(); return 1; }
void XRRDeleteProviderProperty (Display *dpy, RRProvider provider, Atom property) { XExtDisplayInfo *info = XRRFindDisplay(dpy); xRRDeleteProviderPropertyReq *req; RRSimpleCheckExtension (dpy, info); LockDisplay(dpy); GetReq(RRDeleteProviderProperty, req); req->reqType = info->codes->major_opcode; req->randrReqType = X_RRDeleteProviderProperty; req->provider = provider; req->property = property; UnlockDisplay(dpy); SyncHandle(); }
int XEGetStatisticsRequest(XETC *tc, XETrapGetStatsRep *ret) { int status = True; Display *dpy = tc->dpy; CARD32 X_XTrap = tc->extOpcode; xXTrapReq *reqptr; xXTrapGetStatsReply rep; status = XEFlushConfig(tc); /* Flushout any pending configuration first */ if (status == True) { LockDisplay(dpy); GetReq(XTrap,reqptr); reqptr->minor_opcode = XETrap_GetStatistics; /* to support comm. w/ V3.1 extensions */ #ifndef CRAY if (tc->protocol == 31) { /* this is the way we used to do it which breaks Cray's */ #ifndef VECTORED_EVENTS int numlongs = (1060-sizeof(xReply)+sizeof(long)-1)/sizeof(long); #else int numlongs = (1544-sizeof(xReply)+sizeof(long)-1)/sizeof(long); #endif status = _XReply(dpy,(xReply *)&rep,numlongs,xTrue); if (status == True) { /* need to shift it back into the data struct */ xXTrapGetStatsReply tmp; tmp = rep; memcpy(&(rep.data),&(tmp.pad0), sizeof(rep.data)); } } else #endif /* CRAY */ { /* this is the way we do it for V3.2 */ int numbytes = SIZEOF(xXTrapGetStatsReply) - SIZEOF(xReply); status = _XReply(dpy, (xReply *)&rep, 0, xFalse); if (status == True) { status = _XRead(dpy, (char *)&rep.data, numbytes); } } SyncHandle(); UnlockDisplay(dpy); memcpy(ret,&(rep.data),sizeof(XETrapGetStatsRep)); } return(status); }
void XRenderSetPictureClipRectangles (Display *dpy, Picture picture, int xOrigin, int yOrigin, _Xconst XRectangle *rects, int n) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); RenderSimpleCheckExtension (dpy, info); LockDisplay(dpy); _XRenderSetPictureClipRectangles (dpy, info, picture, xOrigin, yOrigin, rects, n); UnlockDisplay (dpy); SyncHandle (); }
static char * __glXQueryServerString(Display * dpy, int opcode, CARD32 screen, CARD32 name) { xGLXGenericGetStringReq *req; xGLXSingleReply reply; int length; int numbytes; char *buf; CARD32 for_whom = screen; CARD32 glxCode = X_GLXQueryServerString; LockDisplay(dpy); /* All of the GLX protocol requests for getting a string from the server * look the same. The exact meaning of the for_whom field is usually * either the screen number (for glXQueryServerString) or the context tag * (for GLXSingle). */ GetReq(GLXGenericGetString, req); req->reqType = opcode; req->glxCode = glxCode; req->for_whom = for_whom; req->name = name; _XReply(dpy, (xReply *) & reply, 0, False); length = reply.length * 4; numbytes = reply.size; buf = (char *) Xmalloc(numbytes); if (buf != NULL) { _XRead(dpy, buf, numbytes); length -= numbytes; } _XEatData(dpy, length); UnlockDisplay(dpy); SyncHandle(); return buf; }
/** * Destroy a pbuffer. * * This function is used to implement \c glXDestroyPbuffer and * \c glXDestroyGLXPbufferSGIX. * * \note * This function dynamically determines whether to use the SGIX_pbuffer * version of the protocol or the GLX 1.3 version of the protocol. */ static void DestroyPbuffer(Display * dpy, GLXDrawable drawable) { struct glx_display *priv = __glXInitialize(dpy); CARD8 opcode; if ((dpy == NULL) || (drawable == 0)) { return; } opcode = __glXSetupForCommand(dpy); if (!opcode) return; LockDisplay(dpy); if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) { xGLXDestroyPbufferReq *req; GetReq(GLXDestroyPbuffer, req); req->reqType = opcode; req->glxCode = X_GLXDestroyPbuffer; req->pbuffer = (GLXPbuffer) drawable; } else { xGLXVendorPrivateWithReplyReq *vpreq; CARD32 *data; GetReqExtra(GLXVendorPrivateWithReply, 4, vpreq); data = (CARD32 *) (vpreq + 1); data[0] = (CARD32) drawable; vpreq->reqType = opcode; vpreq->glxCode = X_GLXVendorPrivateWithReply; vpreq->vendorCode = X_GLXvop_DestroyGLXPbufferSGIX; } UnlockDisplay(dpy); SyncHandle(); DestroyDRIDrawable(dpy, drawable, GL_TRUE); return; }
int XQueryColors( register Display *dpy, Colormap cmap, XColor *defs, /* RETURN */ int ncolors) { register int i; xrgb *color; xQueryColorsReply rep; long nbytes; register xQueryColorsReq *req; LockDisplay(dpy); GetReq(QueryColors, req); req->cmap = cmap; req->length += ncolors; /* each pixel is a CARD32 */ for (i = 0; i < ncolors; i++) Data32 (dpy, (long *)&defs[i].pixel, 4L); /* XXX this isn't very efficient */ if (_XReply(dpy, (xReply *) &rep, 0, xFalse) != 0) { if ((color = (xrgb *) Xmalloc((unsigned) (nbytes = (long) ncolors * SIZEOF(xrgb))))) { _XRead(dpy, (char *) color, nbytes); for (i = 0; i < ncolors; i++) { register XColor *def = &defs[i]; register xrgb *rgb = &color[i]; def->red = rgb->red; def->green = rgb->green; def->blue = rgb->blue; def->flags = DoRed | DoGreen | DoBlue; } Xfree((char *)color); } else _XEatData(dpy, (unsigned long) nbytes); } UnlockDisplay(dpy); SyncHandle(); return 1; }
XserverRegion XCompositeCreateRegionFromBorderClip (Display *dpy, Window window) { XCompositeExtDisplayInfo *info = XCompositeFindDisplay (dpy); xCompositeCreateRegionFromBorderClipReq *req; XserverRegion region; XCompositeCheckExtension (dpy, info, 0); LockDisplay (dpy); GetReq (CompositeCreateRegionFromBorderClip, req); req->reqType = info->codes->major_opcode; req->compositeReqType = X_CompositeCreateRegionFromBorderClip; req->window = window; region = req->region = XAllocID (dpy); UnlockDisplay (dpy); SyncHandle (); return region; }
int XSetInputFocus( register Display *dpy, Window focus, int revert_to, Time time) { register xSetInputFocusReq *req; LockDisplay(dpy); GetReq(SetInputFocus, req); req->focus = focus; req->revertTo = revert_to; req->time = time; UnlockDisplay(dpy); SyncHandle(); return 1; }
int XFreeGC ( register Display *dpy, GC gc) { register xResourceReq *req; register _XExtension *ext; LockDisplay(dpy); /* call out to any extensions interested */ for (ext = dpy->ext_procs; ext; ext = ext->next) if (ext->free_GC) (*ext->free_GC)(dpy, gc, &ext->codes); GetResReq (FreeGC, gc->gid, req); UnlockDisplay(dpy); SyncHandle(); _XFreeExtData(gc->ext_data); Xfree (gc); return 1; }
void XFixesDestroyPointerBarrier(Display *dpy, PointerBarrier b) { XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); xXFixesDestroyPointerBarrierReq *req; XFixesSimpleCheckExtension (dpy, info); if (info->major_version < 5) return; LockDisplay (dpy); GetReq (XFixesDestroyPointerBarrier, req); req->reqType = info->codes->major_opcode; req->xfixesReqType = X_XFixesDestroyPointerBarrier; req->barrier = b; UnlockDisplay (dpy); SyncHandle(); }
void XFixesChangeCursor (Display *dpy, Cursor source, Cursor destination) { XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); xXFixesChangeCursorReq *req; XFixesSimpleCheckExtension (dpy, info); if (info->major_version < 2) return; LockDisplay (dpy); GetReq (XFixesChangeCursor, req); req->reqType = info->codes->major_opcode; req->xfixesReqType = X_XFixesChangeCursor; req->source = source; req->destination = destination; UnlockDisplay(dpy); SyncHandle(); }
static int InitModMap( Display *dpy) { register XModifierKeymap *map; if (! (map = XGetModifierMapping(dpy))) return 0; LockDisplay(dpy); if (dpy->modifiermap) XFreeModifiermap(dpy->modifiermap); dpy->modifiermap = map; dpy->free_funcs->modifiermap = XFreeModifiermap; if (dpy->keysyms) ResetModMap(dpy); UnlockDisplay(dpy); return 1; }
void XiGMiscChangeResolution(Display *dpy, int screen, int view, int width, int height, int refresh) { xXiGMiscChangeResolutionReq *req; XExtDisplayInfo *info = XiGMiscFindDisplay(dpy); XiGMiscSimpleCheckExtension(dpy, info); LockDisplay (dpy); XiGMiscGetReq (XiGMiscChangeResolution, req, info); req->screen = screen; req->view = view; req->width = width; req->height = height; req->refresh = refresh; UnlockDisplay(dpy); SyncHandle(); }
Pixmap XCompositeNameWindowPixmap (Display *dpy, Window window) { XCompositeExtDisplayInfo *info = XCompositeFindDisplay (dpy); xCompositeNameWindowPixmapReq *req; Pixmap pixmap; XCompositeCheckExtension (dpy, info, 0); LockDisplay (dpy); GetReq (CompositeNameWindowPixmap, req); req->reqType = info->codes->major_opcode; req->compositeReqType = X_CompositeNameWindowPixmap; req->window = window; pixmap = req->pixmap = XAllocID (dpy); UnlockDisplay (dpy); SyncHandle (); return pixmap; }
GlyphSet XRenderReferenceGlyphSet (Display *dpy, GlyphSet existing) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); GlyphSet gsid; xRenderReferenceGlyphSetReq *req; RenderCheckExtension (dpy, info, 0); LockDisplay(dpy); GetReq(RenderReferenceGlyphSet, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderReferenceGlyphSet; req->gsid = gsid = XAllocID(dpy); req->existing = existing; UnlockDisplay(dpy); SyncHandle(); return gsid; }
int XSetSelectionOwner( register Display *dpy, Atom selection, Window owner, Time time) { register xSetSelectionOwnerReq *req; LockDisplay(dpy); GetReq(SetSelectionOwner,req); req->selection = selection; req->window = owner; req->time = time; UnlockDisplay(dpy); SyncHandle(); return 1; }
int XSetWindowBorderWidth( Display *dpy, Window w, unsigned int width) { unsigned long lwidth = width; /* must be CARD32 */ register xConfigureWindowReq *req; LockDisplay(dpy); GetReqExtra(ConfigureWindow, 4, req); req->window = w; req->mask = CWBorderWidth; OneDataCard32 (dpy, NEXTPTR(req,xConfigureWindowReq), lwidth); UnlockDisplay(dpy); SyncHandle(); return 1; }
void DRI2DestroyDrawable(Display * dpy, XID drawable) { XExtDisplayInfo *info = DRI2FindDisplay(dpy); xDRI2DestroyDrawableReq *req; XextSimpleCheckExtension(dpy, info, dri2ExtensionName); XSync(dpy, False); LockDisplay(dpy); GetReq(DRI2DestroyDrawable, req); req->reqType = info->codes->major_opcode; req->dri2ReqType = X_DRI2DestroyDrawable; req->drawable = drawable; UnlockDisplay(dpy); SyncHandle(); }
GlyphSet XRenderCreateGlyphSet (Display *dpy, _Xconst XRenderPictFormat *format) { XRenderExtDisplayInfo *info = XRenderFindDisplay (dpy); GlyphSet gsid; xRenderCreateGlyphSetReq *req; RenderCheckExtension (dpy, info, 0); LockDisplay(dpy); GetReq(RenderCreateGlyphSet, req); req->reqType = info->codes->major_opcode; req->renderReqType = X_RenderCreateGlyphSet; req->gsid = gsid = XAllocID(dpy); req->format = format->id; UnlockDisplay(dpy); SyncHandle(); return gsid; }
Bool XDGASetClientVersion( Display *dpy ){ XExtDisplayInfo *info = xdga_find_display (dpy); xXDGASetClientVersionReq *req; XDGACheckExtension (dpy, info, False); LockDisplay(dpy); GetReq(XDGASetClientVersion, req); req->reqType = info->codes->major_opcode; req->dgaReqType = X_XDGASetClientVersion; req->major = XDGA_MAJOR_VERSION; req->minor = XDGA_MINOR_VERSION; UnlockDisplay(dpy); SyncHandle(); return True; }
void __glXSendErrorForXcb(Display * dpy, const xcb_generic_error_t *err) { xError error; LockDisplay(dpy); error.type = X_Error; error.errorCode = err->error_code; error.sequenceNumber = err->sequence; error.resourceID = err->resource_id; error.minorCode = err->minor_code; error.majorCode = err->major_code; _XError(dpy, &error); UnlockDisplay(dpy); }
void XDamageSubtract (Display *dpy, Damage damage, XserverRegion repair, XserverRegion parts) { XDamageExtDisplayInfo *info = XDamageFindDisplay (dpy); xDamageSubtractReq *req; XDamageSimpleCheckExtension (dpy, info); LockDisplay (dpy); GetReq (DamageSubtract, req); req->reqType = info->codes->major_opcode; req->damageReqType = X_DamageSubtract; req->damage = damage; req->repair = repair; req->parts = parts; UnlockDisplay (dpy); SyncHandle (); }