/* $Xorg: pl_struct.c,v 1.4 2000/08/17 19:44:27 cpqbld Exp $ */ /****************************************************************************** Copyright 1992, 1998 The Open Group All Rights Reserved. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. Copyright 1987,1991 by Digital Equipment Corporation, Maynard, Massachusetts All Rights Reserved Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Digital not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. Digital make no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************************/ #include "PEXlib.h" #include "PEXlibint.h" #include "pl_oc_util.h" PEXStructure PEXCreateStructure (display) INPUT Display *display; { register pexCreateStructureReq *req; char *pBuf; PEXStructure sid; /* * Get a structure resource id from X. */ sid = XAllocID (display); /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (CreateStructure, pBuf); BEGIN_REQUEST_HEADER (CreateStructure, pBuf, req); PEXStoreReqHead (CreateStructure, req); req->id = sid; END_REQUEST_HEADER (CreateStructure, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); return (sid); } void PEXDestroyStructures (display, numStructures, structures) INPUT Display *display; INPUT unsigned long numStructures; INPUT PEXStructure *structures; { register pexDestroyStructuresReq *req; char *pBuf; int size; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ size = numStructures * SIZEOF (pexStructure); PEXGetReqExtra (DestroyStructures, size, pBuf); BEGIN_REQUEST_HEADER (DestroyStructures, pBuf, req); PEXStoreReqExtraHead (DestroyStructures, size, req); req->numStructures = numStructures; END_REQUEST_HEADER (DestroyStructures, pBuf, req); STORE_LISTOF_CARD32 (numStructures, structures, pBuf); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); } void PEXCopyStructure (display, srcStructure, destStructure) INPUT Display *display; INPUT PEXStructure srcStructure; INPUT PEXStructure destStructure; { register pexCopyStructureReq *req; char *pBuf; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (CopyStructure, pBuf); BEGIN_REQUEST_HEADER (CopyStructure, pBuf, req); PEXStoreReqHead (CopyStructure, req); req->src = srcStructure; req->dst = destStructure; END_REQUEST_HEADER (CopyStructure, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); } Status PEXGetStructureInfo (display, structure, float_format, value_mask, info_return) INPUT Display *display; INPUT PEXStructure structure; INPUT int float_format; INPUT unsigned long value_mask; OUTPUT PEXStructureInfo *info_return; { register pexGetStructureInfoReq *req; char *pBuf; pexGetStructureInfoReply rep; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer and get a reply. */ PEXGetReq (GetStructureInfo, pBuf); BEGIN_REQUEST_HEADER (GetStructureInfo, pBuf, req); PEXStoreReqHead (GetStructureInfo, req); req->fpFormat = float_format; req->sid = structure; req->itemMask = value_mask; END_REQUEST_HEADER (GetStructureInfo, pBuf, req); if (_XReply (display, (xReply *)&rep, 0, xTrue) == 0) { UnlockDisplay (display); PEXSyncHandle (display); return (0); /* return an error */ } if (value_mask & PEXEditMode) info_return->edit_mode = rep.editMode; if (value_mask & PEXElementPtr) info_return->element_pointer = rep.elementPtr; if (value_mask & PEXNumElements) info_return->element_count = rep.numElements; if (value_mask & PEXLengthStructure) info_return->size = rep.lengthStructure; if (value_mask & PEXHasRefs) info_return->has_refs = rep.hasRefs; /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); return (1); } Status PEXGetElementInfo (display, structure, whence1, offset1, whence2, offset2, float_format, numElementInfoReturn, infoReturn) INPUT Display *display; INPUT PEXStructure structure; INPUT int whence1; INPUT long offset1; INPUT int whence2; INPUT long offset2; INPUT int float_format; OUTPUT unsigned long *numElementInfoReturn; OUTPUT PEXElementInfo **infoReturn; { register pexGetElementInfoReq *req; char *pBuf; pexGetElementInfoReply rep; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer and get a reply. */ PEXGetReq (GetElementInfo, pBuf); BEGIN_REQUEST_HEADER (GetElementInfo, pBuf, req); PEXStoreReqHead (GetElementInfo, req); req->fpFormat = float_format; req->sid = structure; req->position1_whence = whence1; req->position1_offset = offset1; req->position2_whence = whence2; req->position2_offset = offset2; END_REQUEST_HEADER (GetElementInfo, pBuf, req); if (_XReply (display, (xReply *)&rep, 0, xFalse) == 0) { UnlockDisplay (display); PEXSyncHandle (display); *numElementInfoReturn = 0; *infoReturn = NULL; return (0); /* return an error */ } *numElementInfoReturn = rep.numInfo; /* * Allocate a buffer for the replies to pass back to the client. */ *infoReturn = (PEXElementInfo *) Xmalloc ( (unsigned) (sizeof (PEXElementInfo) * rep.numInfo)); XREAD_LISTOF_ELEMINFO (display, rep.numInfo, (*infoReturn)); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); return (1); } PEXStructure * PEXGetStructuresInNetwork (display, structure, which, numStructuresReturn) INPUT Display *display; INPUT PEXStructure structure; INPUT int which; OUTPUT unsigned long *numStructuresReturn; { register pexGetStructuresInNetworkReq *req; char *pBuf; pexGetStructuresInNetworkReply rep; PEXStructure *structsRet; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer and get a reply. */ PEXGetReq (GetStructuresInNetwork, pBuf); BEGIN_REQUEST_HEADER (GetStructuresInNetwork, pBuf, req); PEXStoreReqHead (GetStructuresInNetwork, req); req->sid = structure; req->which = which; END_REQUEST_HEADER (GetStructuresInNetwork, pBuf, req); if (_XReply (display, (xReply *)&rep, 0, xFalse) == 0) { UnlockDisplay (display); PEXSyncHandle (display); *numStructuresReturn = 0; return (NULL); /* return an error */ } *numStructuresReturn = rep.numStructures; /* * Allocate a buffer for the replies to pass back to the client. */ structsRet = (PEXStructure *) Xmalloc ( (unsigned) (sizeof (PEXStructure) * rep.numStructures)); XREAD_LISTOF_CARD32 (display, rep.numStructures, structsRet); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); return (structsRet); } PEXStructurePath * PEXGetAncestors (display, structure, pathPart, pathDepth, numPathsReturn) INPUT Display *display; INPUT PEXStructure structure; INPUT int pathPart; INPUT unsigned long pathDepth; OUTPUT unsigned long *numPathsReturn; { register pexGetAncestorsReq *req; char *pBuf, *pBufSave; pexGetAncestorsReply rep; PEXStructurePath *pStrucPath; PEXElementRef *pElemRef; int numElements; int i; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer and get a reply. */ PEXGetReq (GetAncestors, pBuf); BEGIN_REQUEST_HEADER (GetAncestors, pBuf, req); PEXStoreReqHead (GetAncestors, req); req->sid = structure; req->pathOrder = pathPart; req->pathDepth = pathDepth; END_REQUEST_HEADER (GetAncestors, pBuf, req); if (_XReply (display, (xReply *)&rep, 0, xFalse) == 0) { UnlockDisplay (display); PEXSyncHandle (display); *numPathsReturn = 0; return (NULL); /* return an error */ } *numPathsReturn = rep.numPaths; /* * Read the reply data into a scratch buffer. */ XREAD_INTO_SCRATCH (display, pBufSave, rep.length << 2); pBuf = pBufSave; /* * Allocate a buffer for the replies to pass back to the client. */ pStrucPath = (PEXStructurePath *) Xmalloc ( (unsigned) (rep.numPaths * sizeof (PEXStructurePath))); for (i = 0; i < rep.numPaths; i++) { EXTRACT_CARD32 (pBuf, numElements); pElemRef = (PEXElementRef *) Xmalloc ( (unsigned) (numElements * sizeof (PEXElementRef))); EXTRACT_LISTOF_ELEMREF (numElements, pBuf, pElemRef); pStrucPath[i].count = numElements; pStrucPath[i].elements = pElemRef; } FINISH_WITH_SCRATCH (display, pBufSave, rep.length << 2); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); return (pStrucPath); } PEXStructurePath * PEXGetDescendants (display, structure, pathPart, pathDepth, numPathsReturn) INPUT Display *display; INPUT PEXStructure structure; INPUT int pathPart; INPUT unsigned long pathDepth; OUTPUT unsigned long *numPathsReturn; { register pexGetDescendantsReq *req; char *pBuf, *pBufSave; pexGetDescendantsReply rep; PEXStructurePath *pStrucPath; PEXElementRef *pElemRef; int numElements; int i; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer and get a reply. */ PEXGetReq (GetDescendants, pBuf); BEGIN_REQUEST_HEADER (GetDescendants, pBuf, req); PEXStoreReqHead (GetDescendants, req); req->sid = structure; req->pathOrder = pathPart; req->pathDepth = pathDepth; END_REQUEST_HEADER (GetDescendants, pBuf, req); if (_XReply (display, (xReply *)&rep, 0, xFalse) == 0) { UnlockDisplay (display); PEXSyncHandle (display); *numPathsReturn = 0; return (NULL); /* return an error */ } *numPathsReturn = rep.numPaths; /* * Read the reply data into a scratch buffer. */ XREAD_INTO_SCRATCH (display, pBufSave, rep.length << 2); pBuf = pBufSave; /* * Allocate a buffer to pass the replies back to the client. */ pStrucPath = (PEXStructurePath *) Xmalloc ( (unsigned) (rep.numPaths * sizeof (PEXStructurePath))); for (i = 0; i < rep.numPaths; i++) { EXTRACT_CARD32 (pBuf, numElements); pElemRef = (PEXElementRef *) Xmalloc ( (unsigned) (numElements * sizeof (PEXElementRef))); EXTRACT_LISTOF_ELEMREF (numElements, pBuf, pElemRef); pStrucPath[i].count = numElements; pStrucPath[i].elements = pElemRef; } FINISH_WITH_SCRATCH (display, pBufSave, rep.length << 2); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); return (pStrucPath); } Status PEXFetchElements (display, structure, whence1, offset1, whence2, offset2, float_format, numElementsReturn, sizeReturn, ocsReturn) INPUT Display *display; INPUT PEXStructure structure; INPUT int whence1; INPUT long offset1; INPUT int whence2; INPUT long offset2; INPUT int float_format; OUTPUT unsigned long *numElementsReturn; OUTPUT unsigned long *sizeReturn; OUTPUT char **ocsReturn; { register pexFetchElementsReq *req; char *pBuf; pexFetchElementsReply rep; long repSize; PEXOCData *oc_data; int server_float_format; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer and get a reply. */ server_float_format = PEXGetProtocolFloatFormat (display); PEXGetReq (FetchElements, pBuf); BEGIN_REQUEST_HEADER (FetchElements, pBuf, req); PEXStoreReqHead (FetchElements, req); req->fpFormat = server_float_format; req->sid = structure; req->position1_whence = whence1; req->position1_offset = offset1; req->position2_whence = whence2; req->position2_offset = offset2; END_REQUEST_HEADER (FetchElements, pBuf, req); if (_XReply (display, (xReply *)&rep, 0, xFalse) == 0) { UnlockDisplay (display); PEXSyncHandle (display); *sizeReturn = *numElementsReturn = 0; *ocsReturn = NULL; return (0); /* return an error */ } *numElementsReturn = rep.numElements; if (server_float_format != float_format) { /* * Convert from server's float format to the float format * specified by the application. */ XREAD_INTO_SCRATCH (display, pBuf, rep.length << 2); oc_data = PEXDecodeOCs (server_float_format, rep.numElements, rep.length << 2, pBuf); FINISH_WITH_SCRATCH (display, pBuf, rep.length << 2); *ocsReturn = PEXEncodeOCs (float_format, rep.numElements, oc_data, sizeReturn); PEXFreeOCData (rep.numElements, oc_data); } else { /* * No float conversion necessary. */ *sizeReturn = repSize = rep.length << 2; if ((*ocsReturn = (char *) Xmalloc ((unsigned) repSize))) _XRead (display, *ocsReturn, (long) repSize); } /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); return (1); } Status PEXFetchElementsAndSend (display, structure, whence1, offset1, whence2, offset2, dstDisplay, resID, reqType) INPUT Display *display; INPUT PEXStructure structure; INPUT int whence1; INPUT long offset1; INPUT int whence2; INPUT long offset2; INPUT Display *dstDisplay; INPUT XID resID; INPUT PEXOCRequestType reqType; { register pexFetchElementsReq *req; char *pBuf; pexFetchElementsReply rep; PEXDisplayInfo *srcDisplayInfo; PEXDisplayInfo *dstDisplayInfo; char *ocAddr; PEXOCData *oc_data; PEXEnumTypeDesc *srcFloats; PEXEnumTypeDesc *dstFloats; long bytesLeft; int getSize; int size; unsigned long oc_size; int i, j; int fp_match; int float_format; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Determine which floating point format to use. */ PEXGetDisplayInfo (display, srcDisplayInfo); PEXGetDisplayInfo (dstDisplay, dstDisplayInfo); if (srcDisplayInfo->fpFormat == dstDisplayInfo->fpFormat) { float_format = dstDisplayInfo->fpFormat; fp_match = 1; } else { srcFloats = srcDisplayInfo->fpSupport; dstFloats = dstDisplayInfo->fpSupport; fp_match = 0; for (i = 0; i < dstDisplayInfo->fpCount && !fp_match; i++) for (j = 0; j < srcDisplayInfo->fpCount; j++) { if (dstFloats[i].index == srcFloats[j].index) { float_format = dstFloats[i].index; fp_match = 1; break; } } if (!fp_match) { /* * Will have to convert from source display float format to * destination display float format. */ float_format = srcDisplayInfo->fpFormat; } } /* * Put the request in the X request buffer and get a reply. */ PEXGetReq (FetchElements, pBuf); BEGIN_REQUEST_HEADER (FetchElements, pBuf, req); PEXStoreReqHead (FetchElements, req); req->fpFormat = float_format; req->sid = structure; req->position1_whence = whence1; req->position1_offset = offset1; req->position2_whence = whence2; req->position2_offset = offset2; END_REQUEST_HEADER (FetchElements, pBuf, req); if (_XReply (display, (xReply *)&rep, 0, xFalse) == 0) { UnlockDisplay (display); PEXSyncHandle (display); return (0); /* return an error */ } /* * If no floating point conversion has to take place, fetch the element * info directly into the destination display connection. */ if (fp_match) { if (display == dstDisplay) UnlockDisplay (display); if (PEXStartOCs (dstDisplay, resID, reqType, float_format, rep.numElements, rep.length)) { bytesLeft = rep.length << 2; getSize = PEXGetOCAddrMaxSize (dstDisplay); while (bytesLeft > 0) { size = bytesLeft < getSize ? bytesLeft : getSize; ocAddr = PEXGetOCAddr (dstDisplay, size); _XRead (display, ocAddr, (long) size); bytesLeft -= size; } PEXFinishOCs (dstDisplay); } if (display != dstDisplay) UnlockDisplay (display); } else { /* * Floating point conversion necessary. */ XREAD_INTO_SCRATCH (display, pBuf, rep.length << 2); oc_data = PEXDecodeOCs (float_format, rep.numElements, rep.length << 2, pBuf); FINISH_WITH_SCRATCH (display, pBuf, rep.length << 2); pBuf = PEXEncodeOCs (dstDisplayInfo->fpFormat, rep.numElements, oc_data, &oc_size); PEXFreeOCData (rep.numElements, oc_data); if (display == dstDisplay) UnlockDisplay (display); PEXSendOCs (dstDisplay, resID, reqType, dstDisplayInfo->fpFormat, rep.numElements, oc_size, pBuf); if (display != dstDisplay) UnlockDisplay (display); } PEXSyncHandle (dstDisplay); return (1); } void PEXSetEditingMode (display, structure, mode) INPUT Display *display; INPUT PEXStructure structure; INPUT int mode; { register pexSetEditingModeReq *req; char *pBuf; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (SetEditingMode, pBuf); BEGIN_REQUEST_HEADER (SetEditingMode, pBuf, req); PEXStoreReqHead (SetEditingMode, req); req->sid = structure; req->mode = mode; END_REQUEST_HEADER (SetEditingMode, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); } void PEXSetElementPtr (display, structure, whence, offset) INPUT Display *display; INPUT PEXStructure structure; INPUT int whence; INPUT long offset; { register pexSetElementPointerReq *req; char *pBuf; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (SetElementPointer, pBuf); BEGIN_REQUEST_HEADER (SetElementPointer, pBuf, req); PEXStoreReqHead (SetElementPointer, req); req->sid = structure; req->position_whence = whence; req->position_offset = offset; END_REQUEST_HEADER (SetElementPointer, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); } void PEXSetElementPtrAtLabel (display, structure, label, offset) INPUT Display *display; INPUT PEXStructure structure; INPUT long label; INPUT long offset; { register pexSetElementPointerAtLabelReq *req; char *pBuf; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (SetElementPointerAtLabel, pBuf); BEGIN_REQUEST_HEADER (SetElementPointerAtLabel, pBuf, req); PEXStoreReqHead (SetElementPointerAtLabel, req); req->sid = structure; req->label = label; req->offset = offset; END_REQUEST_HEADER (SetElementPointerAtLabel, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); } Status PEXElementSearch (display, structure, whence, offset, direction, numIncl, inclList, numExcl, exclList, offsetReturn) INPUT Display *display; INPUT PEXStructure structure; INPUT int whence; INPUT long offset; INPUT int direction; INPUT unsigned long numIncl; INPUT unsigned short *inclList; INPUT unsigned long numExcl; INPUT unsigned short *exclList; OUTPUT unsigned long *offsetReturn; { register pexElementSearchReq *req; char *pBuf; pexElementSearchReply rep; int size; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer and get a reply. */ size = SIZEOF (CARD16) * (numIncl + (numIncl & 1) + numExcl + (numExcl & 1)); PEXGetReqExtra (ElementSearch, size, pBuf); BEGIN_REQUEST_HEADER (ElementSearch, pBuf, req); PEXStoreReqExtraHead (ElementSearch, size, req); req->sid = structure; req->position_whence = whence; req->position_offset = offset; req->direction = direction; req->numIncls = numIncl; req->numExcls = numExcl; END_REQUEST_HEADER (ElementSearch, pBuf, req); STORE_LISTOF_CARD16 (numIncl, inclList, pBuf); pBuf += ((numIncl & 1) * SIZEOF (CARD16)); STORE_LISTOF_CARD16 (numExcl, exclList, pBuf); if (_XReply (display, (xReply *)&rep, 0, xTrue) == 0) { UnlockDisplay (display); PEXSyncHandle (display); *offsetReturn = 0; return (0); /* return an error */ } *offsetReturn = rep.foundOffset; /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); return (rep.status); } void PEXDeleteElements (display, structure, whence1, offset1, whence2, offset2) INPUT Display *display; INPUT PEXStructure structure; INPUT int whence1; INPUT long offset1; INPUT int whence2; INPUT long offset2; { register pexDeleteElementsReq *req; char *pBuf; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (DeleteElements, pBuf); BEGIN_REQUEST_HEADER (DeleteElements, pBuf, req); PEXStoreReqHead (DeleteElements, req); req->sid = structure; req->position1_whence = whence1; req->position1_offset = offset1; req->position2_whence = whence2; req->position2_offset = offset2; END_REQUEST_HEADER (DeleteElements, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); } void PEXDeleteToLabel (display, structure, whence, offset, label) INPUT Display *display; INPUT PEXStructure structure; INPUT int whence; INPUT long offset; INPUT long label; { register pexDeleteElementsToLabelReq *req; char *pBuf; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (DeleteElementsToLabel, pBuf); BEGIN_REQUEST_HEADER (DeleteElementsToLabel, pBuf, req); PEXStoreReqHead (DeleteElementsToLabel, req); req->sid = structure; req->position_whence = whence; req->position_offset = offset; req->label = label; END_REQUEST_HEADER (DeleteElementsToLabel, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); } void PEXDeleteBetweenLabels (display, structure, label1, label2) INPUT Display *display; INPUT PEXStructure structure; INPUT long label1; INPUT long label2; { register pexDeleteBetweenLabelsReq *req; char *pBuf; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (DeleteBetweenLabels, pBuf); BEGIN_REQUEST_HEADER (DeleteBetweenLabels, pBuf, req); PEXStoreReqHead (DeleteBetweenLabels, req); req->sid = structure; req->label1 = label1; req->label2 = label2; END_REQUEST_HEADER (DeleteBetweenLabels, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); } void PEXCopyElements (display, srcStructure, srcWhence1, srcOffset1, srcWhence2, srcOffset2, destStructure, destWhence, destOffset) INPUT Display *display; INPUT PEXStructure srcStructure; INPUT int srcWhence1; INPUT long srcOffset1; INPUT int srcWhence2; INPUT long srcOffset2; INPUT PEXStructure destStructure; INPUT int destWhence; INPUT long destOffset; { register pexCopyElementsReq *req; char *pBuf; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (CopyElements, pBuf); BEGIN_REQUEST_HEADER (CopyElements, pBuf, req); PEXStoreReqHead (CopyElements, req); req->src = srcStructure; req->srcPosition1_whence = srcWhence1; req->srcPosition1_offset = srcOffset1; req->srcPosition2_whence = srcWhence2; req->srcPosition2_offset = srcOffset2; req->dst = destStructure; req->dstPosition_whence = destWhence; req->dstPosition_offset = destOffset; END_REQUEST_HEADER (CopyElements, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); } void PEXChangeStructureRefs (display, oldStructure, newStructure) INPUT Display *display; INPUT PEXStructure oldStructure; INPUT PEXStructure newStructure; { register pexChangeStructureRefsReq *req; char *pBuf; /* * Lock around the critical section, for multithreading. */ LockDisplay (display); /* * Put the request in the X request buffer. */ PEXGetReq (ChangeStructureRefs, pBuf); BEGIN_REQUEST_HEADER (ChangeStructureRefs, pBuf, req); PEXStoreReqHead (ChangeStructureRefs, req); req->old_id = oldStructure; req->new_id = newStructure; END_REQUEST_HEADER (ChangeStructureRefs, pBuf, req); /* * Done, so unlock and check for synchronous-ness. */ UnlockDisplay (display); PEXSyncHandle (display); }