Copyright (C) 1994, Digital Equipment Corp.
Created on Thu Feb 17 18:50:39 PST 1994 by najork
*****************************************************************************
This interface contains PEX definitions, derived from C header files. The following C header files went into the translation:
PEX.h PEXproto.h PEXprotost.h MPEX.h MPEXproto.h MPEXprotostr.h PEXlib.h PEXlibprotos.h PEXocbuf.h MPEXlib.h
The translation was done by hand. Not every definition in the C header files is translated; and probably there are a few (lots of?) bugs. Send a message to najork@src.dec.com if you need any definitions that are not yet translated, or if you trip over any bugs; I will patch things up on demand.
Here are the copyright notices from the original C header files:
Copyright notice of PEX.h, PEXproto.h, PEXprotost.h: ----------------------------------------------------
Copyright 1989, 1990, 1991 by Sun Microsystems, Inc. and the X Consortium.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, 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 names of Sun Microsystems, the X Consortium, and MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.
SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SUN MICROSYSTEMS 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.
Copyright notice of MPEX.h, MPEXproto.h, MPEXprotostr.h: --------------------------------------------------------
Copyright 1989 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, 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 names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.
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.
Copyright notice of PEXlib.h, PEXlibprotos.h, PEXocbuf.h, MPEXlib.h: --------------------------------------------------------------------
COPYRIGHT (c) 1988,1989,1990,1991 by DIGITAL Equipment Corporation, Maynard, Mass.
This software is furnished under a license and may be used and copied only in accordance with the terms of such license and with the inclusion of the above copyright notice. This software or any other copies thereof may not be provided or otherwise made available to any other person. No title to and ownership of the software is hereby transferred.
The information in this software is subject to change without notice and should not be construed as a commitment by DIGITAL Equipment Corporation.
DIGITAL assumes no responsibility for the use or reliability of its software on equipment which is not supplied by DIGITAL.
*****************************************************************************
UNSAFE INTERFACE*************************************************************************** Misc. ***************************************************************************PEX ; IMPORT Ctypes, Word, X;
TYPE XIDStar = UNTRACED REF X.XID; DisplayStarStar = UNTRACED REF X.DisplayStar; Drawable = CARD32; (* Note that X.Drawable = X.XID = Ctypes.unsigned_long So under AOSF, BYTESIZE (X.Drawable) = 8, and BYTESIZE (Drawable) = 4 This appears strange, but is consistent with /usr/include/PEX/PEXproto.h (Revision 1.1.2.4 1993/03/23) and /usr/include/PEX/MPEXproto.h (Revision 1.1.1.6 1993/06/03) from the AOSF Open3D kit. Also note that the pxlPhigsWksInfo record and all procedures use X.Drawable, not drawable. This is consistent with the definition of Drawable in /usr/include/PEX/PEXlib.h and /usr/include/PEX/PEXlibprotos.h from the AOSF Open3D kit. *)*************************************************************************** Based on Xmd.h Performs only the definitions relevant for PEX. ***************************************************************************
TYPE INT8 = Ctypes.char; (* 8 bits *) INT16 = Ctypes.short; (* 16 bits *) INT32 = Ctypes.int; (* 32 bits *) CARD8 = Ctypes.unsigned_char; (* 8 bits *) CARD16 = Ctypes.unsigned_short; (* 16 bits *) CARD32 = Ctypes.unsigned_int; (* 32 bits *) BYTE = Ctypes.unsigned_char; (* 8 bits *)*************************************************************************** Based on PEX.h v 5.1 91/02/16 09:47:00 rws Should be complete! ***************************************************************************
CONST (* Matches revision 5.0P *) PEX_PROTO_MAJOR = 5; (* current protocol version *) PEX_PROTO_MINOR = 0; (* current minor version *)Subsets
PEXCompleteImplementation = 0; PEXImmediateModeOnly = 1; PEXPhigsWksOnly = 2;Resources
PEXAlreadyFreed = 1;Asf Attributes
Masks for setting Asf's
PEXMarkerTypeAsf = Word.LeftShift(1,0); PEXMarkerScaleAsf = Word.LeftShift(1,1); PEXMarkerColourAsf = Word.LeftShift(1,2); PEXTextFontIndexAsf = Word.LeftShift(1,3); PEXTextPrecAsf = Word.LeftShift(1,4); PEXCharExpansionAsf = Word.LeftShift(1,5); PEXCharSpacingAsf = Word.LeftShift(1,6); PEXTextColourAsf = Word.LeftShift(1,7); PEXLineTypeAsf = Word.LeftShift(1,8); PEXLineWidthAsf = Word.LeftShift(1,9); PEXLineColourAsf = Word.LeftShift(1,10); PEXCurveApproxAsf = Word.LeftShift(1,11); PEXPolylineInterpAsf = Word.LeftShift(1,12); PEXInteriorStyleAsf = Word.LeftShift(1,13); PEXInteriorStyleIndexAsf = Word.LeftShift(1,14); PEXSurfaceColourAsf = Word.LeftShift(1,15); PEXSurfaceInterpAsf = Word.LeftShift(1,16); PEXReflectionModelAsf = Word.LeftShift(1,17); PEXReflectionAttrAsf = Word.LeftShift(1,18); PEXBfInteriorStyleAsf = Word.LeftShift(1,19); PEXBfInteriorStyleIndexAsf = Word.LeftShift(1,20); PEXBfSurfaceColourAsf = Word.LeftShift(1,21); PEXBfSurfaceInterpAsf = Word.LeftShift(1,22); PEXBfReflectionModelAsf = Word.LeftShift(1,23); PEXBfReflectionAttrAsf = Word.LeftShift(1,24); PEXSurfaceApproxAsf = Word.LeftShift(1,25); PEXSurfaceEdgesAsf = Word.LeftShift(1,26); PEXSurfaceEdgeTypeAsf = Word.LeftShift(1,27); PEXSurfaceEdgeWidthAsf = Word.LeftShift(1,28); PEXSurfaceEdgeColourAsf = Word.LeftShift(1,29); PEXMaxAsfShift = 29;Asf Values
PEXBundled = 0; PEXIndividual = 1;Composition
PEXPreConcatenate = 0; PEXPostConcatenate = 1; PEXReplace = 2;Cull mode
0 None
PEXBackFaces = 1; PEXFrontFaces = 2;Curve Type and Surface Type
PEXRational = 0; PEXNonRational = 1;Edit Mode
PEXStructureInsert = 0; PEXStructureReplace = 1;Whence values
PEXBeginning = 0; PEXCurrent = 1; PEXEnd = 2;Element Search
PEXNotFound = 1; PEXFound = 2;GetEnumeratedType return format
PEXETIndex = 1; PEXETMnemonic = 2; PEXETBoth = 3;Enum Types
PEXETMarkerType = 1; PEXETATextStyle = 2; PEXETInteriorStyle = 3; PEXETHatchStyle = 4; PEXETLineType = 5; PEXETSurfaceEdgeType = 6; PEXETPickDeviceType = 7; PEXETPolylineInterpMethod = 8; PEXETCurveApproxMethod = 9; PEXETReflectionModel = 10; PEXETSurfaceInterpMethod = 11; PEXETSurfaceApproxMethod = 12; PEXETModelClipOperator = 13; PEXETLightType = 14; PEXETColourType = 15; PEXETFloatFormat = 16; PEXETHlhsrMode = 17; PEXETPromptEchoType = 18; PEXETDisplayUpdateMode = 19; PEXETColourApproxType = 20; PEXETColourApproxModel = 21; PEXETGDP = 22; PEXETGDP3 = 23; PEXETGSE = 24; PEXETTrimCurveApproxMethod = 25; PEXETRenderingColourModel = 26; PEXETParaSurfCharacteristics = 27;Renderer state
PEXIdle = 0; PEXRendering = 1;Flags (e.g., Switches, Visibility, and Edges)
PEXOff = 0; PEXOn = 1;Shape hints Complex, Nonconvex, Convex, are defined as 0, 1, 2 in X.h
PEXComplex = 0; PEXNonconvex = 1; PEXConvex = 2; PEXUnknownShape = 3;Contour hints
PEXDisjoint = 0; PEXNested = 1; PEXIntersecting = 2; PEXUnknownContour = 3;Table Type
PEXLineBundleLUT = 1; PEXMarkerBundleLUT = 2; PEXTextBundleLUT = 3; PEXInteriorBundleLUT = 4; PEXEdgeBundleLUT = 5; PEXPatternLUT = 6; PEXTextFontLUT = 7; PEXColourLUT = 8; PEXViewLUT = 9; PEXLightLUT = 10; PEXDepthCueLUT = 11; PEXColourApproxLUT = 12; PEXMaxTableType = 12;Status in GetTableEntry
PEXDefaultEntry = 0; PEXDefinedEntry = 1;ValueType in GetTableEntr{y|ies}
PEXSetValue = 0; PEXRealizedValue = 1;Constants for Path and Vertical and Horizontal alignment
PEXPathRight = 0; PEXPathLeft = 1; PEXPathUp = 2; PEXPathDown = 3; PEXValignNormal = 0; PEXValignTop = 1; PEXValignCap = 2; PEXValignHalf = 3; PEXValignBase = 4; PEXValignBottom = 5; PEXHalignNormal = 0; PEXHalignLeft = 1; PEXHalignCenter = 2; PEXHalignRight = 3;Text precision
PEXStringPrecision = 0; PEXCharPrecision = 1; PEXStrokePrecision = 2;Character Set Widths
PEXCSByte = 0; PEXCSShort = 1; PEXCSLong = 2;Update State
PEXNotPending = 0; PEXPending = 1;Visual State
PEXCorrect = 0; PEXDeferred = 1; PEXSimulated = 2;Display State
PEXEmpty = 0; PEXNotEmpty = 1;Buffer Mode
PEXSingleBuffered = 0; PEXDoubleBuffered = 1;Dynamic types
PEXIMM = 0; PEXIRG = 1; PEXCBS = 2;Geometric attributes (Vertex, Facet)
PEXGAColour = 16_0001; PEXGANormal = 16_0002; PEXGAEdges = 16_0004;Pick Status
PEXNoPick = 0; PEXOk = 1;Pick Echo Switch
PEXNoEcho = 0; PEXEcho = 1;Pick Path Order
PEXTopFirst = 0; PEXBottomFirst = 1;Items for GetStructureInfo
PEXElementPtr = 16_0001; PEXNumElements = 16_0002; PEXLengthStructure = 16_0004; PEXHasRefs = 16_0008; PEXEditMode = 16_0010;Flags for GetStructuresInNetwork
PEXAll = 0; PEXOrphans = 1;Path part for GetAncestors
PEXTopPart = 0; PEXBottomPart = 1;Direction for ElementSearch
PEXForward = 0; PEXBackward = 1;Nameset changes
PEXNSAdd = 0; PEXNSRemove = 1; PEXNSReplace = 2;Priorities
PEXHigher = 0; PEXLower = 1;Enumerated Type Descriptors
Marker Type
PEXMarkerDot = 1; PEXMarkerCross = 2; PEXMarkerAsterisk = 3; PEXMarkerCircle = 4; PEXMarkerX = 5; (* ATextStyle *) PEXATextNotConnected = 1; PEXATextConnected = 2; (* InteriorStyle *) PEXInteriorStyleHollow = 1; PEXInteriorStyleSolid = 2; PEXInteriorStylePattern = 3; PEXInteriorStyleHatch = 4; PEXInteriorStyleEmpty = 5; (* HatchStyle *) (* LineType *) PEXLineTypeSolid = 1; PEXLineTypeDashed = 2; PEXLineTypeDotted = 3; PEXLineTypeDashDot = 4; (* SurfaceEdgeType *) PEXSurfaceEdgeSolid = 1; PEXSurfaceEdgeDashed = 2; PEXSurfaceEdgeDotted = 3; PEXSurfaceEdgeDashDot = 4; (* PickDeviceType *) PEXPickDeviceDC_HitBox = 1; PEXPickDeviceNPC_HitVolume = 2; (* PolylineInterpMethod *) PEXPolylineInterpNone = 1; PEXPolylineInterpColour = 2; (* Curve(and Surface)(and Trim Curve)ApproxMethods *) PEXApproxImpDep = 1; PEXApproxConstantBetweenKnots = 2; PEXApproxWcsChordalSize = 3; PEXApproxNpcChordalSize = 4; PEXApproxDcChordalSize = 5; PEXCurveApproxWcsChordalDev = 6; PEXCurveApproxNpcChordalDev = 7; PEXCurveApproxDcChordalDev = 8; PEXSurfaceApproxWcsPlanarDev = 6; PEXSurfaceApproxNpcPlanarDev = 7; PEXSurfaceApproxDcPlanarDev = 8; PEXApproxWcsRelative = 9; PEXApproxNpcRelative = 10; PEXApproxDcRelative = 11; (* ReflectionModel *) PEXReflectionNoShading = 1; PEXReflectionAmbient = 2; PEXReflectionDiffuse = 3; PEXReflectionSpecular = 4; (* SurfaceInterpMethod *) PEXSurfaceInterpNone = 1; PEXSurfaceInterpColour = 2; PEXSurfaceInterpDotProduct = 3; PEXSurfaceInterpNormal = 4; (* ModelClipOperator *) PEXModelClipReplace = 1; PEXModelClipIntersection = 2; (* LightType *) PEXLightAmbient = 1; PEXLightWcsVector = 2; PEXLightWcsPoint = 3; PEXLightWcsSpot = 4; (* ColourType *) PEXIndexedColour = 0; PEXRgbFloatColour = 1; PEXCieFloatColour = 2; PEXHsvFloatColour = 3; PEXHlsFloatColour = 4; PEXRgb8Colour = 5; PEXRgb16Colour = 6; PEXMaxColour = 6; (* FloatFormat *) PEXIeee_754_32 = 1; PEXDEC_F_Floating = 2; PEXIeee_754_64 = 3; PEXDEC_D_Floating = 4; (* HlhsrMode *) PEXHlhsrOff = 1; PEXHlhsrZBuffer = 2; PEXHlhsrPainters = 3; PEXHlhsrScanline = 4; PEXHlhsrHiddenLineOnly = 5; (* PromptEchoType *) PEXEchoPrimitive = 1; PEXEchoStructure = 2; PEXEchoNetwork = 3; (* DisplayUpdateMethod *) PEXVisualizeEach = 1; PEXVisualizeEasy = 2; PEXVisualizeNone = 3; PEXSimulateSome = 4; PEXVisualizeWhenever = 5; (* ColourApproxType *) PEXColourSpace = 1; PEXColourRange = 2; (* ColourApproxMethod *) PEXColourApproxRGB = 1; PEXColourApproxCIE = 2; PEXColourApproxHSV = 3; PEXColourApproxHLS = 4; PEXColourApproxYIQ = 5; (* RenderingColourModel *) PEXRdrColourModelImpDep = 0; PEXRdrColourModelRGB = 1; PEXRdrColourModelCIE = 2; PEXRdrColourModelHSV = 3; PEXRdrColourModelHLS = 4; (* ParametricSurfaceCharacteristics *) PEXPSCNone = 1; PEXPSCImpDep = 2; PEXPSCIsoCurves = 3; PEXPSCMcLevelCurves = 4; PEXPSCWcLevelCurves = 5; (* Isoparametric Curves *) PEXICUniformPlacement = 0; PEXICNonuniformPlacement = 1;Clipping
PEXClipXY = 16_0001; PEXClipBack = 16_0002; PEXClipFront = 16_0004; PEXClip = 0; PEXNoClip = 1;Implementation Dependent Constant Names
PEXIDDitheringSupported = 1; PEXIDMaxEdgeWidth = 2; PEXIDMaxLineWidth = 3; PEXIDMaxMarkerSize = 4; PEXIDMaxModelClipPlanes = 5; PEXIDMaxNameSetNames = 6; PEXIDMaxNonAmbientLights = 7; PEXIDMaxNURBOrder = 8; PEXIDMaxTrimCurveOrder = 9; PEXIDMinEdgeWidth = 10; PEXIDMinLineWidth = 11; PEXIDMinMarkerSize = 12; PEXIDNominalEdgeWidth = 13; PEXIDNominalLineWidth = 14; PEXIDNominalMarkerSize = 15; PEXIDNumSupportedEdgeWidths = 16; PEXIDNumSupportedLineWidths = 17; PEXIDNumSupportedMarkerSizes = 18; PEXIDBestColourApproximation = 19; PEXIDTransparencySupported = 20; PEXIDDoubleBufferingSupported = 21; PEXIDChromaticityRedU = 22; PEXIDChromaticityRedV = 23; PEXIDLuminanceRed = 24; PEXIDChromaticityGreenU = 25; PEXIDChromaticityGreenV = 26; PEXIDLuminanceGreen = 27; PEXIDChromaticityBlueU = 28; PEXIDChromaticityBlueV = 29; PEXIDLuminanceBlue = 30; PEXIDChromaticityWhiteU = 31; PEXIDChromaticityWhiteV = 32; PEXIDLuminanceWhite = 33;Constants for IDRgbBestApproximation
PEXColourApproxAnyValues = 0; PEXColourApproxPowersOf2 = 1;*************************************************************************** The following procedures mimic a set of (#define) C macros in PEX.h. C Macros are a tricky thing: They do not contain type information, and can thereby realize ad-hoc polymorphism which Modula-3 cannot reproduce, and worse, they have an Algol-like call-by-name semantics, which can be nasty. Example: given #define FOO(x) ((x)+(x)) after executing i = 3; j = FOO(i++); j is not 6, but 7, and i is not 4, but 5. I recommend to look at your code very carefully when you replace one of these C macros with a Modula-3 function! CHECK_BITMASK_ARRAY is not a function, but just a stub of code (an if-statement with the condition, but where the then- and else part are missing). I cannot be translated. ***************************************************************************
* To convert a bit index to a mask number and a mask value, assuming ** 32 bit wide words. For example, a bitIndex of 5 will return ** maskNum == 0 and maskValue == (1 << 5) = 32, while a bitIndex of 39 ** will return maskNum == 1 and maskValue == (1 << 7) == 128 *
PROCEDURE PEX_BITNUM_TO_BITMASK (bitIndex : Ctypes.int; VAR maskNum : Ctypes.int; VAR maskValue : Ctypes.int); PROCEDURE PEX_BITMASK (i : Ctypes.int) : Ctypes.int; PROCEDURE PEX_MASKIDX (i : Ctypes.int) : Ctypes.int; PROCEDURE PEX_MASKWORD (READONLY buf : ARRAY OF Ctypes.int ; i : Ctypes.int) : Ctypes.int; PROCEDURE PEX_BITSET (VAR buf : ARRAY OF Ctypes.int ; i : Ctypes.int); PROCEDURE PEX_BITCLEAR (VAR buf : ARRAY OF Ctypes.int ; i : Ctypes.int); PROCEDURE PEX_GETBIT (READONLY buf : ARRAY OF Ctypes.int ; i : Ctypes.int) : Ctypes.int; CONST PEXMSGetWksInfo = 2; PEXMSPipeline = 3;Pipeline Context
PEXPCMarkerType = 0; PEXPCMarkerScale = 1; PEXPCMarkerColour = 2; PEXPCMarkerBundleIndex = 3; PEXPCTextFont = 4; PEXPCTextPrecision = 5; PEXPCCharExpansion = 6; PEXPCCharSpacing = 7; PEXPCTextColour = 8; PEXPCCharHeight = 9; PEXPCCharUpVector = 10; PEXPCTextPath = 11; PEXPCTextAlignment = 12; PEXPCAtextHeight = 13; PEXPCAtextUpVector = 14; PEXPCAtextPath = 15; PEXPCAtextAlignment = 16; PEXPCAtextStyle = 17; PEXPCTextBundleIndex = 18; PEXPCLineType = 19; PEXPCLineWidth = 20; PEXPCLineColour = 21; PEXPCCurveApproximation = 22; PEXPCPolylineInterp = 23; PEXPCLineBundleIndex = 24; PEXPCInteriorStyle = 25; PEXPCInteriorStyleIndex = 26; PEXPCSurfaceColour = 27; PEXPCSurfaceReflAttr = 28; PEXPCSurfaceReflModel = 29; PEXPCSurfaceInterp = 30; PEXPCBfInteriorStyle = 31; PEXPCBfInteriorStyleIndex = 32; PEXPCBfSurfaceColour = 33; PEXPCBfSurfaceReflAttr = 34; PEXPCBfSurfaceReflModel = 35; PEXPCBfSurfaceInterp = 36; PEXPCSurfaceApproximation = 37; PEXPCCullingMode = 38; PEXPCDistinguishFlag = 39; PEXPCPatternSize = 40; PEXPCPatternRefPt = 41; PEXPCPatternRefVec1 = 42; PEXPCPatternRefVec2 = 43; PEXPCInteriorBundleIndex = 44; PEXPCSurfaceEdgeFlag = 45; PEXPCSurfaceEdgeType = 46; PEXPCSurfaceEdgeWidth = 47; PEXPCSurfaceEdgeColour = 48; PEXPCEdgeBundleIndex = 49; PEXPCLocalTransform = 50; PEXPCGlobalTransform = 51; PEXPCModelClip = 52; PEXPCModelClipVolume = 53; PEXPCViewIndex = 54; PEXPCLightState = 55; PEXPCDepthCueIndex = 56; PEXPCSetAsfValues = 57; PEXPCPickId = 58; PEXPCHlhsrIdentifier = 59; PEXPCNameSet = 60; PEXPCColourApproxIndex = 61; PEXPCRenderingColourModel = 62; PEXPCParaSurfCharacteristics = 63; PEXMaxPCIndex = 63;Renderer Bitmasks
PEXRDPipelineContext = Word.LeftShift(1,0); PEXRDCurrentPath = Word.LeftShift(1,1); PEXRDMarkerBundle = Word.LeftShift(1,2); PEXRDTextBundle = Word.LeftShift(1,3); PEXRDLineBundle = Word.LeftShift(1,4); PEXRDInteriorBundle = Word.LeftShift(1,5); PEXRDEdgeBundle = Word.LeftShift(1,6); PEXRDViewTable = Word.LeftShift(1,7); PEXRDColourTable = Word.LeftShift(1,8); PEXRDDepthCueTable = Word.LeftShift(1,9); PEXRDLightTable = Word.LeftShift(1,10); PEXRDColourApproxTable = Word.LeftShift(1,11); PEXRDPatternTable = Word.LeftShift(1,12); PEXRDTextFontTable = Word.LeftShift(1,13); PEXRDHighlightIncl = Word.LeftShift(1,14); PEXRDHighlightExcl = Word.LeftShift(1,15); PEXRDInvisibilityIncl = Word.LeftShift(1,16); PEXRDInvisibilityExcl = Word.LeftShift(1,17); PEXRDRendererState = Word.LeftShift(1,18); PEXRDHlhsrMode = Word.LeftShift(1,19); PEXRDNpcSubvolume = Word.LeftShift(1,20); PEXRDViewport = Word.LeftShift(1,21); PEXRDClipList = Word.LeftShift(1,22); PEXMaxRDShift = 22;Renderer Dynamics Bitmasks
tables
PEXDynMarkerBundle = Word.LeftShift(1,0); PEXDynTextBundle = Word.LeftShift(1,1); PEXDynLineBundle = Word.LeftShift(1,2); PEXDynInteriorBundle = Word.LeftShift(1,3); PEXDynEdgeBundle = Word.LeftShift(1,4); PEXDynViewTable = Word.LeftShift(1,5); PEXDynColourTable = Word.LeftShift(1,6); PEXDynDepthCueTable = Word.LeftShift(1,7); PEXDynLightTable = Word.LeftShift(1,8); PEXDynColourApproxTable = Word.LeftShift(1,9); PEXDynPatternTable = Word.LeftShift(1,10); PEXDynTextFontTable = Word.LeftShift(1,11); PEXDynMarkerBundleContents = Word.LeftShift(1,16); PEXDynTextBundleContents = Word.LeftShift(1,17); PEXDynLineBundleContents = Word.LeftShift(1,18); PEXDynInteriorBundleContents = Word.LeftShift(1,19); PEXDynEdgeBundleContents = Word.LeftShift(1,20); PEXDynViewTableContents = Word.LeftShift(1,21); PEXDynColourTableContents = Word.LeftShift(1,22); PEXDynDepthCueTableContents = Word.LeftShift(1,23); PEXDynLightTableContents = Word.LeftShift(1,24); PEXDynColourApproxContents = Word.LeftShift(1,25); PEXDynPatternTableContents = Word.LeftShift(1,26); PEXDynTextFontTableContents = Word.LeftShift(1,27); (* namesets *) PEXDynHighlightNameset = Word.LeftShift(1,0); PEXDynInvisibilityNameset = Word.LeftShift(1,1); PEXDynHighlightNamesetContents = Word.LeftShift(1,12); PEXDynInvisibilityNamesetContents = Word.LeftShift(1,13); (* attributes *) PEXDynHlhsrMode = Word.LeftShift(1,0); PEXDynNpcSubvolume = Word.LeftShift(1,1); PEXDynViewport = Word.LeftShift(1,2); PEXDynClipList = Word.LeftShift(1,3); PEXElementType = Word.LeftShift(1,0); PEXElementSize = Word.LeftShift(1,1); PEXElementData = Word.LeftShift(1,2);Search Context Bitmasks
PEXSCPosition = Word.LeftShift(1,0); PEXSCDistance = Word.LeftShift(1,1); PEXSCCeiling = Word.LeftShift(1,2); PEXSCModelClipFlag = Word.LeftShift(1,3); PEXSCStartPath = Word.LeftShift(1,4); PEXSCNormalList = Word.LeftShift(1,5); PEXSCInvertedList = Word.LeftShift(1,6);Phigs Workstation Attribute Bitmasks
PEXPWDisplayUpdate = 0; PEXPWVisualState = 1; PEXPWDisplaySurface = 2; PEXPWViewUpdate = 3; PEXPWDefinedViews = 4; PEXPWWksUpdate = 5; PEXPWReqNpcSubvolume = 6; PEXPWCurNpcSubvolume = 7; PEXPWReqWksViewport = 8; PEXPWCurWksViewport = 9; PEXPWHlhsrUpdate = 10; PEXPWReqHlhsrMode = 11; PEXPWCurHlhsrMode = 12; PEXPWDrawable = 13; PEXPWMarkerBundle = 14; PEXPWTextBundle = 15; PEXPWLineBundle = 16; PEXPWInteriorBundle = 17; PEXPWEdgeBundle = 18; PEXPWColourTable = 19; PEXPWDepthCueTable = 20; PEXPWLightTable = 21; PEXPWColourApproxTable = 22; PEXPWPatternTable = 23; PEXPWTextFontTable = 24; PEXPWHighlightIncl = 25; PEXPWHighlightExcl = 26; PEXPWInvisibilityIncl = 27; PEXPWInvisibilityExcl = 28; PEXPWPostedStructures = 29; PEXPWNumPriorities = 30; PEXPWBufferUpdate = 31; PEXPWReqBufferMode = 32; PEXPWCurBufferMode = 33;Indices for GetDynamics
PEXPWDViewRep = 0; PEXPWDMarkerBundle = 1; PEXPWDTextBundle = 2; PEXPWDLineBundle = 3; PEXPWDInteriorBundle = 4; PEXPWDEdgeBundle = 5; PEXPWDColourTable = 6; PEXPWDPatternTable = 7; PEXPWDWksTransform = 8; PEXPWDHighlightFilter = 9; PEXPWDInvisibilityFilter = 10; PEXPWDHlhsrMode = 11; PEXPWDStructureModify = 12; PEXPWDPostStructure = 13; PEXPWDUnpostStructure = 14; PEXPWDDeleteStructure = 15; PEXPWDReferenceModify = 16; PEXPWDBufferModify = 17; PEXPWDLightTable = 18; PEXPWDDepthCueTable = 19; PEXPWDColourApproxTable = 20;Pick Device Bitmasks
PEXPDPickStatus = Word.LeftShift(1,0); PEXPDPickPath = Word.LeftShift(1,1); PEXPDPickPathOrder = Word.LeftShift(1,2); PEXPDPickIncl = Word.LeftShift(1,3); PEXPDPickExcl = Word.LeftShift(1,4); PEXPDPickDataRec = Word.LeftShift(1,5); PEXPDPickPromptEchoType = Word.LeftShift(1,6); PEXPDPickEchoVolume = Word.LeftShift(1,7); PEXPDPickEchoSwitch = Word.LeftShift(1,8);Pick Measure Bitmasks
PEXPMStatus = Word.LeftShift(1,0); PEXPMPath = Word.LeftShift(1,1);Errors
PEXColourTypeError = 0; PEXRendererStateError = 1; PEXFloatingPointFormatError = 2; PEXLabelError = 3; PEXLookupTableError = 4; PEXNameSetError = 5; PEXPathError = 6; PEXFontError = 7; PEXPhigsWksError = 8; PEXPickMeasureError = 9; PEXPipelineContextError = 10; PEXRendererError = 11; PEXSearchContextError = 12; PEXStructureError = 13; PEXOutputCommandError = 14; PEXMaxError = 14;Requests
PEX_GetExtensionInfo = 1; PEX_GetEnumeratedTypeInfo = 2; PEX_GetImpDepConstants = 3; PEX_CreateLookupTable = 4; PEX_CopyLookupTable = 5; PEX_FreeLookupTable = 6; PEX_GetTableInfo = 7; PEX_GetPredefinedEntries = 8; PEX_GetDefinedIndices = 9; PEX_GetTableEntry = 10; PEX_GetTableEntries = 11; PEX_SetTableEntries = 12; PEX_DeleteTableEntries = 13; PEX_CreatePipelineContext = 14; PEX_CopyPipelineContext = 15; PEX_FreePipelineContext = 16; PEX_GetPipelineContext = 17; PEX_ChangePipelineContext = 18; PEX_CreateRenderer = 19; PEX_FreeRenderer = 20; PEX_ChangeRenderer = 21; PEX_GetRendererAttributes = 22; PEX_GetRendererDynamics = 23; PEX_BeginRendering = 24; PEX_EndRendering = 25; PEX_BeginStructure = 26; PEX_EndStructure = 27; PEX_RenderOutputCommands = 28; PEX_RenderNetwork = 29; PEX_CreateStructure = 30; PEX_CopyStructure = 31; PEX_DestroyStructures = 32; PEX_GetStructureInfo = 33; PEX_GetElementInfo = 34; PEX_GetStructuresInNetwork = 35; PEX_GetAncestors = 36; PEX_GetDescendants = 37; PEX_FetchElements = 38; PEX_SetEditingMode = 39; PEX_SetElementPointer = 40; PEX_SetElementPointerAtLabel = 41; PEX_ElementSearch = 42; PEX_StoreElements = 43; PEX_DeleteElements = 44; PEX_DeleteElementsToLabel = 45; PEX_DeleteBetweenLabels = 46; PEX_CopyElements = 47; PEX_ChangeStructureRefs = 48; PEX_CreateNameSet = 49; PEX_CopyNameSet = 50; PEX_FreeNameSet = 51; PEX_GetNameSet = 52; PEX_ChangeNameSet = 53; PEX_CreateSearchContext = 54; PEX_CopySearchContext = 55; PEX_FreeSearchContext = 56; PEX_GetSearchContext = 57; PEX_ChangeSearchContext = 58; PEX_SearchNetwork = 59; PEX_CreatePhigsWks = 60; PEX_FreePhigsWks = 61; PEX_GetWksInfo = 62; PEX_GetDynamics = 63; PEX_GetViewRep = 64; PEX_RedrawAllStructures = 65; PEX_UpdateWorkstation = 66; PEX_RedrawClipRegion = 67; PEX_ExecuteDeferredActions = 68; PEX_SetViewPriority = 69; PEX_SetDisplayUpdateMode = 70; PEX_MapDCtoWC = 71; PEX_MapWCtoDC = 72; PEX_SetViewRep = 73; PEX_SetWksWindow = 74; PEX_SetWksViewport = 75; PEX_SetHlhsrMode = 76; PEX_SetWksBufferMode = 77; PEX_PostStructure = 78; PEX_UnpostStructure = 79; PEX_UnpostAllStructures = 80; PEX_GetWksPostings = 81; PEX_GetPickDevice = 82; PEX_ChangePickDevice = 83; PEX_CreatePickMeasure = 84; PEX_FreePickMeasure = 85; PEX_GetPickMeasure = 86; PEX_UpdatePickMeasure = 87; PEX_OpenFont = 88; PEX_CloseFont = 89; PEX_QueryFont = 90; PEX_ListFonts = 91; PEX_ListFontsWithInfo = 92; PEX_QueryTextExtents = 93; PEXMaxRequest = 93;Output Commands
PEXOCAll = 0; PEXOCMarkerType = 1; PEXOCMarkerScale = 2; PEXOCMarkerColourIndex = 3; PEXOCMarkerColour = 4; PEXOCMarkerBundleIndex = 5; PEXOCTextFontIndex = 6; PEXOCTextPrecision = 7; PEXOCCharExpansion = 8; PEXOCCharSpacing = 9; PEXOCTextColourIndex = 10; PEXOCTextColour = 11; PEXOCCharHeight = 12; PEXOCCharUpVector = 13; PEXOCTextPath = 14; PEXOCTextAlignment = 15; PEXOCAtextHeight = 16; PEXOCAtextUpVector = 17; PEXOCAtextPath = 18; PEXOCAtextAlignment = 19; PEXOCAtextStyle = 20; PEXOCTextBundleIndex = 21; PEXOCLineType = 22; PEXOCLineWidth = 23; PEXOCLineColourIndex = 24; PEXOCLineColour = 25; PEXOCCurveApproximation = 26; PEXOCPolylineInterp = 27; PEXOCLineBundleIndex = 28; PEXOCInteriorStyle = 29; PEXOCInteriorStyleIndex = 30; PEXOCSurfaceColourIndex = 31; PEXOCSurfaceColour = 32; PEXOCSurfaceReflAttr = 33; PEXOCSurfaceReflModel = 34; PEXOCSurfaceInterp = 35; PEXOCBfInteriorStyle = 36; PEXOCBfInteriorStyleIndex = 37; PEXOCBfSurfaceColourIndex = 38; PEXOCBfSurfaceColour = 39; PEXOCBfSurfaceReflAttr = 40; PEXOCBfSurfaceReflModel = 41; PEXOCBfSurfaceInterp = 42; PEXOCSurfaceApproximation = 43; PEXOCCullingMode = 44; PEXOCDistinguishFlag = 45; PEXOCPatternSize = 46; PEXOCPatternRefPt = 47; PEXOCPatternAttr = 48; PEXOCInteriorBundleIndex = 49; PEXOCSurfaceEdgeFlag = 50; PEXOCSurfaceEdgeType = 51; PEXOCSurfaceEdgeWidth = 52; PEXOCSurfaceEdgeColourIndex = 53; PEXOCSurfaceEdgeColour = 54; PEXOCEdgeBundleIndex = 55; PEXOCSetAsfValues = 56; PEXOCLocalTransform = 57; PEXOCLocalTransform2D = 58; PEXOCGlobalTransform = 59; PEXOCGlobalTransform2D = 60; PEXOCModelClip = 61; PEXOCModelClipVolume = 62; PEXOCModelClipVolume2D = 63; PEXOCRestoreModelClip = 64; PEXOCViewIndex = 65; PEXOCLightState = 66; PEXOCDepthCueIndex = 67; PEXOCPickId = 68; PEXOCHlhsrIdentifier = 69; PEXOCColourApproxIndex = 70; PEXOCRenderingColourModel = 71; PEXOCParaSurfCharacteristics = 72; PEXOCAddToNameSet = 73; PEXOCRemoveFromNameSet = 74; PEXOCExecuteStructure = 75; PEXOCLabel = 76; PEXOCApplicationData = 77; PEXOCGse = 78; PEXOCMarker = 79; PEXOCMarker2D = 80; PEXOCText = 81; PEXOCText2D = 82; PEXOCAnnotationText = 83; PEXOCAnnotationText2D = 84; PEXOCPolyline = 85; PEXOCPolyline2D = 86; PEXOCPolylineSet = 87; PEXOCNurbCurve = 88; PEXOCFillArea = 89; PEXOCFillArea2D = 90; PEXOCExtFillArea = 91; PEXOCFillAreaSet = 92; PEXOCFillAreaSet2D = 93; PEXOCExtFillAreaSet = 94; PEXOCTriangleStrip = 95; PEXOCQuadrilateralMesh = 96; PEXOCSOFAS = 97; PEXOCNurbSurface = 98; PEXOCCellArray = 99; PEXOCCellArray2D = 100; PEXOCExtCellArray = 101; PEXOCGdp = 102; PEXOCGdp2D = 103; PEXMaxOC = 103; PEXOCNil = Word.Not(0);*************************************************************************** Based on PEXproto.h 5.1 91/02/12 Should be complete! ***************************************************************************
Definitions for the PEX used by server and c bindings
* This packet-construction scheme makes the following assumptions: * * 1. The compiler is able to generate code which addresses one- and two-byte * quantities. In the worst case, this would be done with bit-fields. If * bit-fields are used it may be necessary to reorder the request fields in * this file, depending on the order in which the machine assigns bit fields * to machine words. There may also be a problem with sign extension, as K+R * specify that bitfields are always unsigned. * * 2. 2- and 4-byte fields in packet structures must be ordered by hand such * that they are naturally-aligned, so that no compiler will ever insert * padding bytes. * * 3. All packets are hand-padded to a multiple of 4 bytes, for the same * reason.
In the following typedefs, comments appear that say
* LISTof Foo( numItems )
, CLIST of Foo()
, and SINGLE Foo()
.
* These are used when the protocol specifies that a request or reply
* contains a variable length list of (possibly variable types of) objects.
*
* A LISTof list is one for which we have already been given the length.
* The items in the list are of type Foo
. The number of items in the list
* appears parenthetically after the type. (numItems
in our example.)
* Any other information needed to parse the list is also passed in the
* parentheses. (E.g., tableType
in a list of table entries.)
*
* A CLISTof list is the same, except that the first 4 bytes of the list
* indicate the number of items in the list. The length may need to be
* byte-swapped.
*
* A SINGLE item of an indeterminate length is indicated in the same
* manner. (E.g., a SINGLE TableEntry()
.) Any other information
* needed to parse the item is also passed in the parentheses.
* (E.g., itemMask
in a set of pipeline context attributes.)
*
* If no information is given in the parentheses, then the size is
* implicit.
*
* Variable length padding is noted with a comment, with the number
* of bytes of padding required as calculated from the value in
* the parentheses. (number of bytes of padding = n?(3-((n-1)%4):0 , where
* n is the parenthetical value.)
Matches revision 5.0P
*************************************************************** * REPLIES * ***************************************************************
TYPE pexGetExtensionInfoReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) majorVersion : CARD16; minorVersion : CARD16; release : CARD32; lengthName : CARD32; subsetInfo : CARD32; pad : ARRAY [0 .. 7] OF BYTE; (* LISTof CARD8 follows -- Don't swap *) (* pad *) END; (* pexGetExtensionInfoReply *) pexGetEnumeratedTypeInfoReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* NOT 0; this is an extra-large reply*) numLists : CARD32; pad : ARRAY [0 .. 19] OF BYTE; (* lists of lists begin afterwards *) (* LISTof CLISTof pexEnumTypeDesc( numLists ) *) (* pad *) END; (* pexGetEnumeratedTypeInfoReply *) pexGetImpDepConstantsReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) pad : ARRAY [0 .. 23] OF BYTE; (* LISTof VALUE() *) END; (* pexGetImpDepConstantsReply *) pexGetTableInfoReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* 0 *) unused : CARD16; definableEntries : CARD16; numPredefined : CARD16; predefinedMin : CARD16; predefinedMax : CARD16; pad : ARRAY [0 .. 13] OF BYTE; END; (* pexGetTableInfoReply *) pexGetPredefinedEntriesReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) unused : CARD32; numEntries : CARD32; pad : ARRAY [0 .. 15] OF BYTE; (* LISTof TableEntry( numEntries, tableType ) *) END; (* pexGetPredefinedEntriesReply *) pexGetDefinedIndicesReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) numIndices : CARD32; pad : ARRAY [0 .. 19] OF BYTE; (* LISTof pexTableIndex( numIndices ) *) (* pad( numIndices ) *) END; (* pexGetDefinedIndicesReply *) pexGetTableEntryReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) status : CARD16; tableType : CARD16; pad : ARRAY [0 .. 19] OF BYTE; (* SINGLE TableEntry( tableType ) *) END; (* pexGetTableEntryReply *) pexGetTableEntriesReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) tableType : CARD16; unused : CARD16; numEntries : CARD32; pad : ARRAY [0 .. 15] OF BYTE; (* LISTof TableEntry( numEntries, tableType ) *) END; (* pexGetTableEntriesReply *) pexGetPipelineContextReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) pad : ARRAY [0 .. 23] OF BYTE; (* SINGLE PipelineContextAttributes( itemMask ) *) END; (* pexGetPipelineContextReply *) pexGetRendererAttributesReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) pad : ARRAY [0 .. 23] OF BYTE; (* SINGLE RendererAttributes( itemMask ) *) END; (* pexGetRendererAttributesReply *) pexGetRendererDynamicsReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* 0 *) tables : pexBitmask; namesets : pexBitmask; attributes : pexBitmask; pad : ARRAY [0 .. 11] OF BYTE; END; (* pexGetRendererDynamicsReply *) pexGetStructureInfoReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* 0 *) editMode : CARD16; unused : CARD16; elementPtr : CARD32; numElements : CARD32; lengthStructure : CARD32; hasRefs : CARD16; pad : ARRAY [0 .. 5] OF BYTE; END; (* pexGetStructureInfoReply *) pexGetElementInfoReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) numInfo : CARD32; pad : ARRAY [0 .. 19] OF BYTE; (* LISTof pexElementInfo( numInfo ) *) END; (* pexGetElementInfoReply *) pexGetStructuresInNetworkReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) unused : ARRAY [0 .. 7] OF CARD8; numStructures : CARD32; pad : ARRAY [0 .. 11] OF BYTE; (* LISTof pexStructure( numStructures ) *) END; (* pexGetStructuresInNetworkReply *) pexGetAncestorsReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) unused : ARRAY [0 .. 11] OF CARD8; numPaths : CARD32; pad : ARRAY [0 .. 7] OF BYTE; (* LISTof CLISTof pexElementRef( numPaths ) *) END; (* pexGetAncestorsReply *) pexGetDescendantsReply = pexGetAncestorsReply; pexFetchElementsReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) numElements : CARD32; pad : ARRAY [0 .. 19] OF BYTE; (* LISTof OutputCommand( numElements ) *) END; (* pexFetchElementsReply *) pexElementSearchReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* 0 *) status : CARD16; unused : CARD16; foundOffset : CARD32; pad : ARRAY [0 .. 15] OF BYTE; END; (* pexElementSearchReply *) pexGetNameSetReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) numNames : CARD32; pad : ARRAY [0 .. 19] OF BYTE; (* LISTof pexName( numNames ) *) END; (* pexGetNameSetReply *) pexGetSearchContextReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) pad : ARRAY [0 .. 23] OF BYTE; (* SINGLE SearchContextAttributes( itemMask ) *) END; (* pexGetSearchContextReply *) pexSearchNetworkReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) unused : CARD32; numItems : CARD32; pad : ARRAY [0 .. 15] OF BYTE; (* LISTof pexElementRef( numItems ) *) END; (* pexSearchNetworkReply *) pexGetWksInfoReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) pad : ARRAY [0 .. 23] OF BYTE; (* SINGLE WksInfo( itemMask ) *) END; (* pexGetWksInfoReply *) pexGetDynamicsReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* 0 *) viewRep : pexDynamicType; markerBundle : pexDynamicType; textBundle : pexDynamicType; lineBundle : pexDynamicType; interiorBundle : pexDynamicType; edgeBundle : pexDynamicType; colourTable : pexDynamicType; patternTable : pexDynamicType; wksTransform : pexDynamicType; highlightFilter : pexDynamicType; invisibilityFilter : pexDynamicType; HlhsrMode : pexDynamicType; structureModify : pexDynamicType; postStructure : pexDynamicType; unpostStructure : pexDynamicType; deleteStructure : pexDynamicType; referenceModify : pexDynamicType; bufferModify : pexDynamicType; lightTable : pexDynamicType; depthCueTable : pexDynamicType; colourApproxTable : pexDynamicType; pad : ARRAY [0 .. 2] OF CARD8; END; (* pexGetDynamicsReply *) pexGetViewRepReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* 4 + 76*fp/4 *) viewUpdate : CARD16; (* Pending, NotPending *) pad : ARRAY [0 .. 21] OF BYTE; (* SINGLE pexViewRep() requested *) (* SINGLE pexViewRep() current *) END; (* pexGetViewRepReply *) pexMapDCtoWCReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) viewIndex : CARD16; unused : CARD16; numCoords : CARD32; pad : ARRAY [0 .. 15] OF BYTE; (* LISTof pexCoord3D( numCoords ) *) END; (* pexMapDCtoWCReply *) pexMapWCtoDCReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) unused : CARD32; numCoords : CARD32; pad : ARRAY [0 .. 15] OF BYTE; (* LISTof pexDeviceCoord( numCoords ) *) END; (* pexMapWCtoDCReply *) pexGetWksPostingsReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) pad : ARRAY [0 .. 23] OF BYTE; (* LISTof pexPhigsWksID() *) END; (* pexGetWksPostingsReply *) pexGetPickDeviceReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) pad : ARRAY [0 .. 23] OF BYTE; (* SINGLE PickDeviceAttributes( itemMask ) *) END; (* pexGetPickDeviceReply *) pexGetPickMeasureReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) pad : ARRAY [0 .. 23] OF BYTE; (* SINGLE pexPickMeasureAttributes( itemMask ) *) END; (* pexGetPickMeasureReply *) pexQueryFontReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) lengthFontInfo : CARD32; pad : ARRAY [0 .. 19] OF CARD8; (* SINGLE pexFontInfo() *) END; (* pexQueryFontReply *) pexListFontsReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) numStrings : CARD32; pad : ARRAY [0 .. 19] OF BYTE; (* LISTof pexString( numStrings ) *) END; (* pexListFontsReply *) pexListFontsWithInfoReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) numStrings : CARD32; pad : ARRAY [0 .. 19] OF BYTE; (* LISTof pexString( numStrings ) *) (* CLISTof pexFontInfo() *) END; (* pexListFontsWithInfoReply *) pexQueryTextExtentsReply = RECORD type : BYTE; (* X_Reply *) what : CARD8; (* unused *) sequenceNumber : CARD16; length : CARD32; (* not 0 *) pad : ARRAY [0 .. 23] OF BYTE; (* LISTof ExtentInfo() *) END; (* pexQueryTextExtentsReply *)*************************************************************** * REQUESTS * ***************************************************************
Request structure
pexReq = RECORD reqType : CARD8; opcode : CARD8; (* meaning depends on request type *) length : CARD16; (* length in 4 bytes quantities of *) (* whole request, including this header *) END; (* pexReq *)**************************************************************** * structures that follow request. ****************************************************************
ResourceReq is used for any request which has a resource ID ( or Atom or Time ) as its one and only argument.
pexResourceReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 2 *) id : CARD32; (* a Structure, Renderer, Font, LUT, etc. *) END; (* pexResourceReq *)**************************************************************** * Specific Requests ****************************************************************
pexGetExtensionInfoReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 2 *) clientProtocolMajor : CARD16; clientProtocolMinor : CARD16; END; (* pexGetExtensionInfoReq *) pexGetEnumeratedTypeInfoReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; drawable : Drawable; itemMask : pexBitmask; numEnums : CARD32; (* LISTof CARD16( numEnums ) *) (* pad( numEnums*2 ) *) END; (* pexGetEnumeratedTypeInfoReq *) pexGetImpDepConstantsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; drawable : Drawable; numNames : CARD32; (* LISTof pexImpDepConstantNames ( numNames ) *) (* pad *) END; (* pexGetImpDepConstantsReq *) pexCreateLookupTableReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) drawableExample : Drawable; lut : pexLookupTable; tableType : pexTableType; unused : CARD16; END; (* pexCreateLookupTableReq *) pexCopyLookupTableReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) src : pexLookupTable; dst : pexLookupTable; END; (* pexCopyLookupTableReq *) pexFreeLookupTableReq = pexResourceReq; pexGetTableInfoReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) drawableExample : Drawable; tableType : pexTableType; unused : CARD16; END; (* pexGetTableInfoReq *) pexGetPredefinedEntriesReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 5 *) fpFormat : pexEnumTypeIndex; unused : CARD16; drawableExample : Drawable; tableType : pexTableType; start : pexTableIndex; count : CARD16; pad : CARD16; END; (* pexGetPredefinedEntriesReq *) pexGetDefinedIndicesReq = pexResourceReq; pexGetTableEntryReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) fpFormat : pexEnumTypeIndex; valueType : CARD16; lut : pexLookupTable; index : pexTableIndex; pad : CARD16; END; (* pexGetTableEntryReq *) pexGetTableEntriesReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) fpFormat : pexEnumTypeIndex; valueType : CARD16; lut : pexLookupTable; start : pexTableIndex; count : CARD16; END; (* pexGetTableEntriesReq *) pexSetTableEntriesReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; lut : pexLookupTable; start : pexTableIndex; count : CARD16; (* LISTof TableEntry( count ) *) END; (* pexSetTableEntriesReq *) pexDeleteTableEntriesReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) lut : pexLookupTable; start : pexTableIndex; count : CARD16; END; (* pexDeleteTableEntriesReq *) pexCreatePipelineContextReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 6 *) fpFormat : pexEnumTypeIndex; unused : CARD16; pc : pexPC; itemMask : ARRAY [0 .. 2 ] OF pexBitmask; (* pexBitmask Array *) (* SINGLE PipelineContextAttributes( itemMask ) *) END; (* pexCreatePipelineContextReq *) pexCopyPipelineContextReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 6 *) src : pexPC; dst : pexPC; itemMask : ARRAY [0 .. 2 ] OF pexBitmask; (* pexBitmask Array *) END; (* pexCopyPipelineContextReq *) pexFreePipelineContextReq = pexResourceReq; pexGetPipelineContextReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 6 *) fpFormat : pexEnumTypeIndex; unused : CARD16; pc : pexPC; itemMask : ARRAY [0 .. 2 ] OF pexBitmask; (* pexBitmask Array *) END; (* pexGetPipelineContextReq *) pexChangePipelineContextReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; pc : pexPC; itemMask : ARRAY [0 .. 2 ] OF pexBitmask; (* pexBitmask Array *) (* SINGLE PipelineContextAttributes( itemMask ) *) END; (* pexChangePipelineContextReq *) pexCreateRendererReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; rdr : pexRenderer; drawable : Drawable; itemMask : pexBitmask; (* SINGLE RendererAttributes( itemMask ) *) END; (* pexCreateRendererReq *) pexFreeRendererReq = pexResourceReq; pexChangeRendererReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; rdr : pexRenderer; itemMask : pexBitmask; (* SINGLE RendererAttributes( itemMask ) *) END; (* pexChangeRendererReq *) pexGetRendererAttributesReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) fpFormat : pexEnumTypeIndex; unused : CARD16; rdr : pexRenderer; itemMask : pexBitmask; END; (* pexGetRendererAttributesReq *) pexGetRendererDynamicsReq = pexResourceReq; pexBeginRenderingReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) rdr : pexRenderer; drawable : Drawable; END; (* pexBeginRenderingReq *) pexEndRenderingReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) rdr : pexRenderer; flushFlag : pexSwitch; pad : ARRAY [0 .. 2] OF BYTE; END; (* pexEndRenderingReq *) pexBeginStructureReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) rdr : pexRenderer; sid : pexStructure; END; (* pexBeginStructureReq *) pexEndStructureReq = pexResourceReq; pexRenderOutputCommandsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; rdr : pexRenderer; numCommands : CARD32; (* LISTof OutputCommand( numCommands ) *) END; (* pexRenderOutputCommandsReq *)individual output commands may be found in the section
Output Commands
pexRenderNetworkReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) rdr : pexRenderer; drawable : Drawable; sid : pexStructure; END; (* pexRenderNetworkReq *) pexCreateStructureReq = pexResourceReq; pexCopyStructureReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) src : pexStructure; dst : pexStructure; END; (* pexCopyStructureReq *) pexDestroyStructuresReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; numStructures : CARD32; (* LISTof pexStructure( numStructures ) *) END; (* pexDestroyStructuresReq *) pexGetStructureInfoReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) fpFormat : pexEnumTypeIndex; itemMask : CARD16; sid : pexStructure; END; (* pexGetStructureInfoReq *) pexGetElementInfoReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 7 *) fpFormat : pexEnumTypeIndex; unused : CARD16; sid : pexStructure; range : BITS BITSIZE (pexElementRange) FOR pexElementRange; END; (* pexGetElementInfoReq *) pexGetStructuresInNetworkReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) sid : pexStructure; which : CARD16; pad : CARD16; END; (* pexGetStructuresInNetworkReq *) pexGetAncestorsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) sid : pexStructure; pathOrder : CARD16; unused : CARD16; pathDepth : CARD32; END; (* pexGetAncestorsReq *) pexGetDescendantsReq = pexGetAncestorsReq; pexFetchElementsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 7 *) fpFormat : pexEnumTypeIndex; unused : CARD16; sid : pexStructure; range : BITS BITSIZE (pexElementRange) FOR pexElementRange; END; (* pexFetchElementsReq *) pexSetEditingModeReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) sid : pexStructure; mode : CARD16; pad : CARD16; END; (* pexSetEditingModeReq *) pexSetElementPointerReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) sid : pexStructure; position : pexElementPos; END; (* pexSetElementPointerReq *) pexSetElementPointerAtLabelReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) sid : pexStructure; label : INT32; offset : INT32; END; (* pexSetElementPointerAtLabelReq *) pexElementSearchReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; sid : pexStructure; position : BITS BITSIZE (pexElementPos) FOR pexElementPos; direction : CARD32; numIncls : CARD32; numExcls : CARD32; (* LISTof CARD16( numIncls ) *) (* pad( numIncls*2 ) *) (* LISTof CARD16( numExcls ) *) (* pad( numExcls*2 ) *) END; (* pexElementSearchReq *) pexStoreElementsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; sid : pexStructure; numCommands : CARD32; (* LISTof OutputCommand( numCommands ) *) END; (* pexStoreElementsReq *) pexDeleteElementsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 6 *) sid : pexStructure; range : pexElementRange; END; (* pexDeleteElementsReq *) pexDeleteElementsToLabelReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 5 *) sid : BITS BITSIZE (pexStructure) FOR pexStructure; position : BITS BITSIZE (pexElementPos) FOR pexElementPos; label : INT32; END; (* pexDeleteElementsToLabelReq *) pexDeleteBetweenLabelsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) sid : pexStructure; label1 : INT32; label2 : INT32; END; (* pexDeleteBetweenLabelsReq *) pexCopyElementsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 9 *) src : BITS BITSIZE (pexStructure) FOR pexStructure; srcRange : BITS BITSIZE (pexElementRange) FOR pexElementRange; dst : BITS BITSIZE (pexStructure) FOR pexStructure; dstPosition : BITS BITSIZE (pexElementPos) FOR pexElementPos; END; (* pexCopyElementsReq *) pexChangeStructureRefsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) old_id : pexStructure; new_id : pexStructure; END; (* pexChangeStructureRefsReq *) pexCreateNameSetReq = pexResourceReq; pexCopyNameSetReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) src : pexNameSet; dst : pexNameSet; END; (* pexCopyNameSetReq *) pexFreeNameSetReq = pexResourceReq; pexGetNameSetReq = pexResourceReq; pexChangeNameSetReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; ns : pexNameSet; action : CARD16; unused : CARD16; (* LISTof pexName() *) END; (* pexChangeNameSetReq *) pexCreateSearchContextReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; sc : pexSC; itemMask : pexBitmask; (* SINGLE SearchContextAttributes( itemMask ) *) END; (* pexCreateSearchContextReq *) pexCopySearchContextReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) src : pexSC; dst : pexSC; itemMask : pexBitmask; END; (* pexCopySearchContextReq *) pexFreeSearchContextReq = pexResourceReq; pexGetSearchContextReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) fpFormat : pexEnumTypeIndex; unused : CARD16; sc : pexSC; itemMask : pexBitmask; END; (* pexGetSearchContextReq *) pexChangeSearchContextReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; sc : pexSC; itemMask : pexBitmask; (* SINGLE SearchContextAttributes( itemMask ) *) END; (* pexChangeSearchContextReq *) pexSearchNetworkReq = pexResourceReq; pexCreatePhigsWksReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 19 *) wks : pexPhigsWks; drawable : Drawable; markerBundle : pexLookupTable; textBundle : pexLookupTable; lineBundle : pexLookupTable; interiorBundle : pexLookupTable; edgeBundle : pexLookupTable; colourTable : pexLookupTable; depthCueTable : pexLookupTable; lightTable : pexLookupTable; colourApproxTable : pexLookupTable; patternTable : pexLookupTable; textFontTable : pexLookupTable; highlightIncl : pexNameSet; highlightExcl : pexNameSet; invisIncl : pexNameSet; invisExcl : pexNameSet; bufferMode : CARD16; pad : CARD16; END; (* pexCreatePhigsWksReq *) pexFreePhigsWksReq = pexResourceReq; pexGetWksInfoReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 5 *) fpFormat : pexEnumTypeIndex; unused : CARD16; wks : pexPhigsWks; itemMask : ARRAY [0 .. 1] OF pexBitmask; END; (* pexGetWksInfoReq *) pexGetDynamicsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 2 *) drawable : Drawable; END; (* pexGetDynamicsReq *) pexGetViewRepReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) fpFormat : pexEnumTypeIndex; index : pexTableIndex; wks : pexPhigsWks; END; (* pexGetViewRepReq *) pexRedrawAllStructuresReq = pexResourceReq; pexUpdateWorkstationReq = pexResourceReq; pexRedrawClipRegionReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; wks : pexPhigsWks; numRects : CARD32; (* LISTof pexDeviceRect( numRects ) *) END; (* pexRedrawClipRegionReq *) pexExecuteDeferredActionsReq = pexResourceReq; pexSetViewPriorityReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) wks : pexPhigsWks; index1 : pexTableIndex; index2 : pexTableIndex; priority : CARD16; pad : CARD16; END; (* pexSetViewPriorityReq *) pexSetDisplayUpdateModeReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) wks : pexPhigsWks; displayUpdate : pexEnumTypeIndex; pad : CARD16; END; (* pexSetDisplayUpdateModeReq *) pexMapDCtoWCReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; wks : pexPhigsWks; numCoords : CARD32; (* LISTof pexDeviceCoord( numCoords ) *) END; (* pexMapDCtoWCReq *) pexMapWCtoDCReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; index : CARD16; wks : pexPhigsWks; numCoords : CARD32; (* LISTof pexCoord3D( numCoords ) *) END; (* pexMapWCtoDCReq *) pexSetViewRepReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 43 *) fpFormat : pexEnumTypeIndex; unused : CARD16; wks : pexPhigsWks; viewRep : BITS BITSIZE (pexViewRep) FOR pexViewRep; END; (* pexSetViewRepReq *) pexSetWksWindowReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 9 *) fpFormat : pexEnumTypeIndex; unused : CARD16; wks : pexPhigsWks; npcSubvolume : BITS BITSIZE (pexNpcSubvolume) FOR pexNpcSubvolume; END; (* pexSetWksWindowReq *) pexSetWksViewportReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 8 *) fpFormat : pexEnumTypeIndex; unused : CARD16; wks : pexPhigsWks; viewport : pexViewport; END; (* pexSetWksViewportReq *) pexSetHlhsrModeReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) wks : pexPhigsWks; mode : pexEnumTypeIndex; pad : CARD16; END; (* pexSetHlhsrModeReq *) pexSetWksBufferModeReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) wks : pexPhigsWks; bufferMode : CARD16; pad : CARD16; END; (* pexSetWksBufferModeReq *) pexPostStructureReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 5 *) fpFormat : pexEnumTypeIndex; unused : CARD16; wks : pexPhigsWks; sid : pexStructure; priority : Ctypes.float; END; (* pexPostStructureReq *) pexUnpostStructureReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) wks : pexPhigsWks; sid : pexStructure; END; (* pexUnpostStructureReq *) pexUnpostAllStructuresReq = pexResourceReq; pexGetWksPostingsReq = pexResourceReq; pexGetPickDeviceReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) fpFormat : pexEnumTypeIndex; devType : pexEnumTypeIndex; wks : pexPhigsWks; itemMask : pexBitmask; END; (* pexGetPickDeviceReq *) pexChangePickDeviceReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; unused : CARD16; wks : pexPhigsWks; devType : pexEnumTypeIndex; unused2 : CARD16; itemMask : pexBitmask; (* SINGLE PickDeviceAttributes( itemMask ) *) END; (* pexChangePickDeviceReq *) pexCreatePickMeasureReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 4 *) wks : pexPhigsWks; pm : pexPickMeasure; devType : pexEnumTypeIndex; pad : CARD16; END; (* pexCreatePickMeasureReq *) pexFreePickMeasureReq = pexResourceReq; pexGetPickMeasureReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; (* 3 *) pm : pexPickMeasure; itemMask : pexBitmask; END; (* pexGetPickMeasureReq *) pexUpdatePickMeasureReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; pm : pexPickMeasure; numBytes : CARD32; (* LISTof CARD8( numBytes ) -- don't swap *) (* pad( numBytes ) *) END; (* pexUpdatePickMeasureReq *) pexOpenFontReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; font : pexFont; numBytes : CARD32; (* LISTof CARD8( numBytes ) -- don't swap *) (* pad( numBytes ) *) END; (* pexOpenFontReq *) pexCloseFontReq = pexResourceReq; pexQueryFontReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; font : pexFont; END; (* pexQueryFontReq *) pexListFontsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; maxNames : CARD16; numChars : CARD16; (* LISTof CARD8( numChars ) -- don't swap *) (* pad( numBytes ) *) END; (* pexListFontsReq *) pexListFontsWithInfoReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; unused : CARD16; maxNames : CARD16; numChars : CARD16; pad : CARD16; (* LISTof CARD8( numChars ) *) (* pad( numBytes ) *) END; (* pexListFontsWithInfoReq *) pexQueryTextExtentsReq = RECORD reqType : CARD8; opcode : CARD8; length : CARD16; fpFormat : pexEnumTypeIndex; textPath : CARD16; fontGroupIndex : pexTableIndex; unused : CARD16; id : CARD32; (* was XID -- renderer, wks, or text font lut *) charExpansion : Ctypes.float; charSpacing : Ctypes.float; charHeight : Ctypes.float; textAlignment : pexTextAlignmentData; numStrings : CARD32; (* LISTof LISTof MONO_ENCODINGS() *) (* pad() *) END; (* pexQueryTextExtentsReq *)**************************************************************** * Output Commands ****************************************************************
pexMarkerType = RECORD head : pexElementInfo; markerType : pexEnumTypeIndex; pad : CARD16; END; (* pexMarkerType *) pexMarkerScale = RECORD head : pexElementInfo; scale : Ctypes.float; END; (* pexMarkerScale *) pexMarkerBundleIndex = RECORD head : pexElementInfo; index : pexTableIndex; pad : CARD16; END; (* pexMarkerBundleIndex *) pexMarkerColourIndex = pexMarkerBundleIndex; pexTextColourIndex = pexMarkerBundleIndex; pexLineColourIndex = pexMarkerBundleIndex; pexSurfaceColourIndex = pexMarkerBundleIndex; pexBfSurfaceColourIndex = pexMarkerBundleIndex; pexSurfaceEdgeColourIndex = pexMarkerBundleIndex; pexTextFontIndex = pexMarkerBundleIndex; pexMarkerColour = RECORD head : pexElementInfo; colourSpec : pexColourSpecifier; (* SINGLE COLOUR() *) END; (* pexMarkerColour *) pexTextColour = pexMarkerColour; pexLineColour = pexMarkerColour; pexSurfaceColour = pexMarkerColour; pexBfSurfaceColour = pexMarkerColour; pexSurfaceEdgeColour = pexMarkerColour; pexAtextStyle = RECORD head : pexElementInfo; style : pexEnumTypeIndex; pad : CARD16; END; (* pexAtextStyle *) pexTextBundleIndex = pexMarkerBundleIndex; pexLineBundleIndex = pexMarkerBundleIndex; pexInteriorBundleIndex = pexMarkerBundleIndex; pexInteriorStyleIndex = pexMarkerBundleIndex; pexBfInteriorStyleIndex = pexMarkerBundleIndex; pexEdgeBundleIndex = pexMarkerBundleIndex; pexViewIndex = pexMarkerBundleIndex; pexDepthCueIndex = pexMarkerBundleIndex; pexColourApproxIndex = pexMarkerBundleIndex; pexTextPrecision = RECORD head : pexElementInfo; precision : CARD16; pad : CARD16; END; (* pexTextPrecision *) pexCharExpansion = RECORD head : pexElementInfo; expansion : Ctypes.float; END; (* pexCharExpansion *) pexCharSpacing = RECORD head : pexElementInfo; spacing : Ctypes.float; END; (* pexCharSpacing *) pexCharHeight = RECORD head : pexElementInfo; height : Ctypes.float; END; (* pexCharHeight *) pexAtextHeight = pexCharHeight; pexCharUpVector = RECORD head : pexElementInfo; up : BITS BITSIZE (pexVector2D) FOR pexVector2D; END; (* pexCharUpVector *) pexAtextUpVector = pexCharUpVector; pexTextPath = RECORD head : pexElementInfo; path : CARD16; pad : CARD16; END; (* pexTextPath *) pexAtextPath = pexTextPath; pexTextAlignment = RECORD head : pexElementInfo; alignment : pexTextAlignmentData; END; (* pexTextAlignment *) pexAtextAlignment = pexTextAlignment; pexLineType = RECORD head : pexElementInfo; lineType : pexEnumTypeIndex; pad : CARD16; END; (* pexLineType *) pexLineWidth = RECORD head : pexElementInfo; width : Ctypes.float; END; (* pexLineWidth *) pexSurfaceEdgeWidth = pexLineWidth; pexCurveApproximation = RECORD head : pexElementInfo; approx : BITS BITSIZE (pexCurveApprox) FOR pexCurveApprox; END; (* pexCurveApproximation *) pexPolylineInterp = RECORD head : pexElementInfo; polylineInterp : pexEnumTypeIndex; pad : CARD16; END; (* pexPolylineInterp *) pexInteriorStyle = RECORD head : pexElementInfo; interiorStyle : pexEnumTypeIndex; pad : CARD16; END; (* pexInteriorStyle *) pexBfInteriorStyle = pexInteriorStyle; pexSurfaceReflAttr = RECORD head : pexElementInfo; reflectionAttr : BITS BITSIZE (pexReflectionAttr) FOR pexReflectionAttr; END; (* pexSurfaceReflAttr *) pexBfSurfaceReflAttr = pexSurfaceReflAttr; pexSurfaceReflModel = RECORD head : pexElementInfo; reflectionModel : pexEnumTypeIndex; pad : CARD16; END; (* pexSurfaceReflModel *) pexBfSurfaceReflModel = pexSurfaceReflModel; pexSurfaceInterp = RECORD head : pexElementInfo; surfaceInterp : pexEnumTypeIndex; pad : CARD16; END; (* pexSurfaceInterp *) pexBfSurfaceInterp = pexSurfaceInterp; pexSurfaceApproximation = RECORD head : pexElementInfo; approx : pexSurfaceApprox; END; (* pexSurfaceApproximation *) pexCullingMode = RECORD head : pexElementInfo; cullMode : pexCullMode; pad : CARD16; END; (* pexCullingMode *) pexDistinguishFlag = RECORD head : pexElementInfo; distinguish : pexSwitch; pad : ARRAY [0 .. 2] OF BYTE; END; (* pexDistinguishFlag *) pexPatternSize = RECORD head : pexElementInfo; size : BITS BITSIZE (pexVector2D) FOR pexVector2D; END; (* pexPatternSize *) pexPatternRefPt = RECORD head : pexElementInfo; point : BITS BITSIZE (pexCoord2D) FOR pexCoord2D; END; (* pexPatternRefPt *) pexPatternAttr = RECORD head : pexElementInfo; refPt : pexCoord3D; vector1 : pexVector3D; vector2 : pexVector3D; END; (* pexPatternAttr *) pexSurfaceEdgeFlag = RECORD head : pexElementInfo; onoff : pexSwitch; pad : ARRAY [0 .. 2] OF BYTE; END; (* pexSurfaceEdgeFlag *) pexSurfaceEdgeType = RECORD head : pexElementInfo; edgeType : pexEnumTypeIndex; pad : CARD16; END; (* pexSurfaceEdgeType *) pexSetAsfValues = RECORD head : pexElementInfo; attribute : pexAsfAttribute; source : pexAsfValue; pad : ARRAY [0 .. 2] OF BYTE; END; (* pexSetAsfValues *) pexLocalTransform = RECORD head : pexElementInfo; compType : pexComposition; unused : CARD16; matrix : pexMatrix; END; (* pexLocalTransform *) pexLocalTransform2D = RECORD head : pexElementInfo; compType : pexComposition; unused : CARD16; matrix3X3 : pexMatrix3X3; END; (* pexLocalTransform2D *) pexGlobalTransform = RECORD head : pexElementInfo; matrix : pexMatrix; END; (* pexGlobalTransform *) pexGlobalTransform2D = RECORD head : pexElementInfo; matrix3X3 : pexMatrix3X3; END; (* pexGlobalTransform2D *) pexModelClip = RECORD head : pexElementInfo; onoff : pexSwitch; pad : ARRAY [0 .. 2] OF BYTE; END; (* pexModelClip *) pexModelClipVolume = RECORD head : pexElementInfo; modelClipOperator : pexEnumTypeIndex; numHalfSpaces : CARD16; (* LISTof pexHalfSpace( numHalfSpaces ) *) END; (* pexModelClipVolume *) pexModelClipVolume2D = RECORD head : pexElementInfo; modelClipOperator : pexEnumTypeIndex; numHalfSpaces : CARD16; (* LISTof pexHalfSpace2D( numHalfSpaces ) *) END; (* pexModelClipVolume2D *) pexRestoreModelClip = RECORD head : pexElementInfo; END; (* pexRestoreModelClip *) pexLightState = RECORD head : pexElementInfo; numEnable : CARD16; numDisable : CARD16; (* LISTof pexTableIndex( numEnable ) *) (* pad( ( numEnable )*2 ) *) (* LISTof pexTableIndex( numDisable ) *) (* pad( ( numDisable )*2 ) *) END; (* pexLightState *) pexPickId = RECORD head : pexElementInfo; pickId : CARD32; END; (* pexPickId *) pexHlhsrIdentifier = RECORD head : pexElementInfo; hlhsrID : CARD32; END; (* pexHlhsrIdentifier *) pexRenderingColourModel = RECORD head : pexElementInfo; model : pexEnumTypeIndex; pad : CARD16; END; (* pexRenderingColourModel *) pexParaSurfCharacteristics = RECORD head : pexElementInfo; characteristics : pexEnumTypeIndex; length : CARD16; (* SINGLEof PARAMETRIC_SURFACE_CHARACTERISTICS *) END; (* pexParaSurfCharacteristics *) pexAddToNameSet = RECORD head : pexElementInfo; (* LISTof pexName() *) END; (* pexAddToNameSet *) pexRemoveFromNameSet = pexAddToNameSet; pexExecuteStructure = RECORD head : pexElementInfo; id : pexStructure; END; (* pexExecuteStructure *) pexLabel = RECORD head : pexElementInfo; label : INT32; END; (* pexLabel *) pexApplicationData = RECORD head : pexElementInfo; numElements : CARD16; unused : CARD16; (* LISTof CARD8( numElements ) -- don't swap *) (* pad( numElements ) *) END; (* pexApplicationData *) pexGse = RECORD head : pexElementInfo; id : CARD32; numElements : CARD16; unused : CARD16; (* LISTof CARD8( numElements ) -- don't swap *) (* pad( numElements ) *) END; (* pexGse *) pexMarker = RECORD head : pexElementInfo; (* LISTof pexCoord3D() *) END; (* pexMarker; *) pexMarker2D = RECORD head : pexElementInfo; (* LISTof pexCoord2D() *) END; (* pexMarker2D; *) pexText = RECORD head : pexElementInfo; origin : pexCoord3D; vector1 : pexVector3D; vector2 : pexVector3D; numEncodings : CARD16; unused : CARD16; (* LISTof pexMonoEncoding( numEncodings ) *) END; (* pexText *) pexText2D = RECORD head : pexElementInfo; origin : BITS BITSIZE (pexCoord2D) FOR pexCoord2D; numEncodings : CARD16; unused : CARD16; (* LISTof pexMonoEncoding( numEncodings ) *) END; (* pexText2D *) pexAnnotationText = RECORD head : pexElementInfo; origin : pexCoord3D; offset : pexCoord3D; numEncodings : CARD16; unused : CARD16; (* LISTof pexMonoEncoding( numEncodings ) *) END; (* pexAnnotationText *) pexAnnotationText2D = RECORD head : pexElementInfo; origin : BITS BITSIZE (pexCoord2D) FOR pexCoord2D; offset : BITS BITSIZE (pexCoord2D) FOR pexCoord2D; numEncodings : CARD16; unused : CARD16; (* LISTof pexMonoEncoding( numEncodings ) *) END; (* pexAnnotationText2D *) pexPolyline = RECORD head : pexElementInfo; (* LISTof pexCoord3D() *) END; (* pexPolyline *) pexPolyline2D = RECORD head : pexElementInfo; (* LISTof pexCoord2D() *) END; (* pexPolyline2D *) pexPolylineSet = RECORD head : pexElementInfo; colourType : pexColourType; vertexAttribs : pexBitmaskShort; numLists : CARD32; (* LISTof CLISTof pexVertex( numLists, vertexAttribs, colourType ) *) END; (* pexPolylineSet *) pexNurbCurve = RECORD head : pexElementInfo; curveOrder : CARD16; coordType : pexCoordType; tmin : Ctypes.float; tmax : Ctypes.float; numKnots : CARD32; numPoints : CARD32; (* LISTof FLOAT( numKnots ) *) (* LISTof {pexCoord3D|pexCoord4D}( numPoints, coordType ) *) END; (* pexNurbCurve *) pexFillArea = RECORD head : pexElementInfo; shape : CARD16; ignoreEdges : pexSwitch; pad : CARD8; (* LISTof pexCoord3D() *) END; (* pexFillArea *) pexFillArea2D = RECORD head : pexElementInfo; shape : CARD16; ignoreEdges : pexSwitch; unused : CARD8; (* LISTof pexCoord2D() *) END; (* pexFillArea2D *) pexExtFillArea = RECORD head : pexElementInfo; shape : CARD16; ignoreEdges : pexSwitch; unused : CARD8; colourType : pexColourType; facetAttribs : pexBitmaskShort; vertexAttribs : pexBitmaskShort; unused2 : CARD16; (* SINGLE Facet( facetAttribs, vertexAttribs, colourType ) *) END; (* pexExtFillArea *) pexFillAreaSet = RECORD head : pexElementInfo; shape : CARD16; ignoreEdges : pexSwitch; contourHint : CARD8; numLists : CARD32; (* LISTof CLISTof Coord3D( numLists ) *) END; (* pexFillAreaSet *) pexFillAreaSet2D = RECORD head : pexElementInfo; shape : CARD16; ignoreEdges : pexSwitch; contourHint : CARD8; numLists : CARD32; (* LISTof CLISTof Coord2D( numLists ) *) END; (* pexFillAreaSet2D *) pexExtFillAreaSet = RECORD head : pexElementInfo; shape : CARD16; ignoreEdges : pexSwitch; contourHint : CARD8; colourType : pexColourType; facetAttribs : pexBitmaskShort; vertexAttribs : pexBitmaskShort; unused2 : CARD16; numLists : CARD32; (* pexOptData( facetAttribs ) *) (* LISTof CLISTof pexVertex( numLists, vertexAttribs, colourType ) *) END; (* pexExtFillAreaSet *) pexTriangleStrip = RECORD head : pexElementInfo; colourType : pexColourType; facetAttribs : pexBitmaskShort; vertexAttribs : pexBitmaskShort; unused : CARD16; numVertices : CARD32; (* number of OptData is numVert - 2 *) (* LISTof pexOptData( facetAttribs, colourType ) *) (* LISTof pexVertex( numVertices, vertexAttribs, colourType ) *) END; (* pexTriangleStrip *) pexQuadrilateralMesh = RECORD head : pexElementInfo; colourType : pexColourType; mPts : CARD16; nPts : CARD16; facetAttribs : pexBitmaskShort; vertexAttribs : pexBitmaskShort; shape : CARD16; (* actually, there are (mPts-1)*(nPts-1) opt data entries *) (* LISTof pexOptData( facetAttribs, colourType ) *) (* LISTof pexVertex( mPts, nPts, vertexAttribs, colourType ) *) END; (* pexQuadrilateralMesh *) pexSOFAS = RECORD head : pexElementInfo; shape : CARD16; colourType : pexColourType; FAS_Attributes : CARD16; vertexAttributes : CARD16; edgeAttributes : CARD16; contourHint : CARD8; contourCountsFlag : pexSwitch; numFAS : CARD16; numVertices : CARD16; numEdges : CARD16; numContours : CARD16; (* LISTof OPT_DATA( numFAS ) *) (* LISTof pexVertex( numVertices ) *) (* LISTof CARD8( numEdges ) *) (* pad( numEdges ) *) (* LISTof CLISTof CLISTof CARD16( numFAS, numContours, numEdges ) *) (* pad *) END; (* pexSOFAS *) pexNurbSurface = RECORD head : pexElementInfo; type : pexCoordType; uOrder : CARD16; vOrder : CARD16; unused : CARD16; numUknots : CARD32; numVknots : CARD32; mPts : CARD16; nPts : CARD16; numLists : CARD32; (* LISTof FLOAT( numUknots ) *) (* LISTof FLOAT( numVKnots ) *) (* LISTof {pexCoord3D|pexCoord4D}( mPts, nPts, surfaceType ) *) (* LISTof CLISTof pexTrimCurve( numLists ) *) END; (* pexNurbSurface *) pexNurbSurfaceStar = UNTRACED REF pexNurbSurface; pexCellArray = RECORD head : pexElementInfo; point1 : pexCoord3D; point2 : pexCoord3D; point3 : pexCoord3D; dx : CARD32; dy : CARD32; (* LISTof pexTableIndex( dx, dy ) *) (* pad( 2*dx*dy ) *) END; (* pexCellArray *) pexCellArray2D = RECORD head : pexElementInfo; point1 : BITS BITSIZE (pexCoord2D) FOR pexCoord2D; point2 : BITS BITSIZE (pexCoord2D) FOR pexCoord2D; dx : CARD32; dy : CARD32; (* LISTof pexTableIndex( dx, dy ) *) (* pad( 2*dx*dy ) *) END; (* pexCellArray2D *) pexExtCellArray = RECORD head : pexElementInfo; colourType : pexColourType; unused : CARD16; point1 : pexCoord3D; point2 : pexCoord3D; point3 : pexCoord3D; dx : CARD32; dy : CARD32; (* LISTof pexColourSpecifier( dx, dy ) *) END; (* pexExtCellArray *) pexGdp = RECORD head : pexElementInfo; gdpId : INT32; numPoints : CARD32; numBytes : CARD32; (* LISTof pexCoord3D( numPoints ) *) (* LISTof CARD8( numBytes ) -- don't swap *) (* pad( numBytes ) *) END; (* pexGdp *) pexGdp2D = RECORD head : pexElementInfo; gdpId : INT32; numPoints : CARD32; numBytes : CARD32; (* LISTof pexCoord2D( numPoints ) *) (* LISTof CARD8( numBytes ) -- don't swap *) (* pad( numBytes ) *) END; (* pexGdp2D *)*************************************************************************** Based on PEXprotost.h 5.1 91/02/12 Should be complete! ***************************************************************************
Matches revision 5.0P
TYPE pexAsfAttribute = CARD32; pexAsfValue = CARD8; pexBitmask = CARD32; pexBitmaskShort = CARD16; pexCoordType = CARD16; (* rational, nonrational *) pexComposition = CARD16; pexCullMode = CARD16; pexDynamicType = BYTE; pexEnumTypeIndex = INT16; pexLookupTable = CARD32; (* used to be XID *) pexName = CARD32; pexNameStar = UNTRACED REF pexName; pexNameStarStar = UNTRACED REF pexNameStar; pexNameSet = CARD32; (* used to be XID *) pexPC = CARD32; (* used to be XID *) pexFont = CARD32; (* used to be XID *) pexFontStar = UNTRACED REF pexFont; pexMatrix = ARRAY [0 .. 3],[0 .. 3] OF Ctypes.float; pexMatrixStar = UNTRACED REF pexMatrix; pexMatrix3X3 = ARRAY [0 .. 2],[0 .. 2] OF Ctypes.float; pexPhigsWks = CARD32; (* used to be XID *) pexPickMeasure = CARD32; (* used to be XID *) pexRenderer = CARD32; (* used to be XID *) pexSC = CARD32; (* used to be XID *) pexStructure = CARD32; (* used to be XID *) pexStructureStar = UNTRACED REF pexStructure; pexStructureStarStar = UNTRACED REF pexStructureStar; pexSwitch = CARD8; pexTableIndex = CARD16; pexTableIndexStar = UNTRACED REF pexTableIndex; pexTableType = CARD16; (* could be smaller if it ever helps *) pexTextHAlignment = CARD16; pexTextVAlignment = CARD16; pexTypeOrTableIndex = CARD16; pexColourType = pexEnumTypeIndex; (* ColourType *)included in others
pexString = RECORD length : CARD16; (* list of CARD8 -- don't swap *) END; (* pexString *) pexStructureInfo = RECORD sid : pexStructure; priority : Ctypes.float; END; (* pexStructureInfo *) pexStructureInfoStar = UNTRACED REF pexStructureInfo; pexVector2D = RECORD x : Ctypes.float; y : Ctypes.float; END; (* pexVector2D *) pexVector3D = RECORD x : Ctypes.float; y : Ctypes.float; z : Ctypes.float; END; (* pexVector3D *) pexVector3DStar = UNTRACED REF pexVector3D;Coord structures
pexCoord2D = RECORD x : Ctypes.float; y : Ctypes.float; END; (* pexCoord2D *) pexCoord2DStar = UNTRACED REF pexCoord2D; pexCoord3D = RECORD x : Ctypes.float; y : Ctypes.float; z : Ctypes.float; END; (* pexCoord3D *) pexCoord3DStar = UNTRACED REF pexCoord3D; pexCoord4D = RECORD x : Ctypes.float; y : Ctypes.float; z : Ctypes.float; w : Ctypes.float; END; (* pexCoord4D *) pexCoord4DStar = UNTRACED REF pexCoord4D;Colour structures
pexRgbFloatColour = RECORD red : Ctypes.float; green : Ctypes.float; blue : Ctypes.float; END; (* pexRgbFloatColour *) pexRgbFloatColourStar = UNTRACED REF pexRgbFloatColour; pexHsvColour = RECORD hue : Ctypes.float; saturation : Ctypes.float; value : Ctypes.float; END; (* pexHsvColour *) pexHlsColour = RECORD hue : Ctypes.float; lightness : Ctypes.float; saturation : Ctypes.float; END; (* pexHlsColour *) pexCieColour = RECORD x : Ctypes.float; y : Ctypes.float; z : Ctypes.float; END; (* pexCieColour *) pexRgb8Colour = RECORD red : CARD8; green : CARD8; blue : CARD8; pad : CARD8; END; (* pexRgb8Colour *) pexRgb16Colour = RECORD red : CARD16; green : CARD16; blue : CARD16; pad : CARD16; END; (* pexRgb16Colour *) pexIndexedColour = RECORD index : pexTableIndex; pad : CARD16; END; (* pexIndexedColour *) pexIndexedColourStar = UNTRACED REF pexIndexedColour;Recall that Modula-3 does not have variant records, or anything resembling a C union type!
CONST auxPexColourSize = MAX (BYTESIZE (pexIndexedColour), MAX (BYTESIZE (pexRgb8Colour), MAX (BYTESIZE (pexRgb16Colour), MAX (BYTESIZE (pexRgbFloatColour), MAX (BYTESIZE (pexHsvColour), MAX (BYTESIZE (pexHlsColour), BYTESIZE (pexCieColour))))))); TYPE pexColour = RECORD format : ARRAY [1 .. auxPexColourSize] OF BYTE; END; (* pexColour *) pexColourStar = UNTRACED REF pexColour; pexFloatColour = RECORD first : Ctypes.float; second : Ctypes.float; third : Ctypes.float; END; (* pexFloatColour *) pexColourSpecifier = RECORD colourType : pexColourType; (* ColourType enumerated type *) unused : CARD16; (* SINGLE COLOUR(colourType) *) END; (* pexColourSpecifier *) pexCurveApprox = RECORD approxMethod : pexEnumTypeIndex; unused : CARD16; tolerance : Ctypes.float; END; (* pexCurveApprox *) pexDeviceCoord = RECORD x : INT16; y : INT16; z : Ctypes.float; END; (* pexDeviceCoord *) pexDeviceCoord2D = RECORD x : INT16; y : INT16; END; (* pexDeviceCoord2D *) pexDeviceRect = RECORD xmin : INT16; ymin : INT16; xmax : INT16; ymax : INT16; END; (* pexDeviceRect *) pexDeviceRectStar = UNTRACED REF pexDeviceRect; pexElementInfo = RECORD elementType : CARD16; length : CARD16; END; (* pexElementInfo *) pexElementInfoStar = UNTRACED REF pexElementInfo; pexElementInfoStarStar = UNTRACED REF pexElementInfoStar; pexElementPos = RECORD whence : CARD16; unused : CARD16; offset : INT32; END; (* pexElementPos *) pexElementRange = RECORD position1 : pexElementPos; position2 : pexElementPos; END; (* pexElementRange *) pexElementRef = RECORD structure : pexStructure; offset : CARD32; END; (* pexElementRef *) pexElementRefStar = UNTRACED REF pexElementRef; pexExtentInfo = RECORD lowerLeft : pexCoord2D; upperRight : pexCoord2D; concatpoint : pexCoord2D; END; (* pexExtentInfo *) pexEnumTypeDesc = RECORD index : pexEnumTypeIndex; descriptor : pexString; END; (* pexEnumTypeDesc *) pexHalfSpace = RECORD point : pexCoord3D; vector : pexVector3D; END; (* pexHalfSpace *) pexHalfSpaceStar = UNTRACED REF pexHalfSpace; pexNameSetPair = RECORD incl : pexNameSet; excl : pexNameSet; END; (* pexNameSetPair *) pexNameSetPairStar = UNTRACED REF pexNameSetPair; pexHalfSpace2D = RECORD point : pexCoord2D; vector : pexVector2D; END; (* pexHalfSpace2D *) pexHalfSpace2DStar = UNTRACED REF pexHalfSpace2D; pexLocalTransform3DData = RECORD composition : CARD16; unused : CARD16; matrix : pexMatrix; END; (* pexLocalTransform3DData *) pexLocalTransform3DDataStar = UNTRACED REF pexLocalTransform3DData; pexLocalTransform2DData = RECORD composition : CARD16; unused : CARD16; matrix : pexMatrix3X3; END; (* pexLocalTransform2DData *) pexLocalTransform2DDataStar = UNTRACED REF pexLocalTransform2DData; pexNpcSubvolume = RECORD minval : pexCoord3D; maxval : pexCoord3D; END; (* pexNpcSubvolume *)an OPT_DATA structure cannot be defined because it has variable content * and size. An union structure could be used to define a template for * the data. However, since unions pad to a fixed amount of space and the * protocol uses variable lengths, this is not appropriate for protocol * data types. The most correct way of defining this data is to define * one data structure for every possible combination of color, normal and * edge data that could be given with a vertex or facet.
pexPickPath = RECORD sid : pexStructure; offset : CARD32; pickid : CARD32; END; (* pexPickPath *) pexPickPathStar = UNTRACED REF pexPickPath; pexPickPathStarStar = UNTRACED REF pexPickPathStar; pexTextAlignmentData = RECORD vertical : pexTextVAlignment; horizontal : pexTextHAlignment; END; (* pexTextAlignmentData *) pexTrimCurve = RECORD visibility : pexSwitch; unused : CARD8; order : CARD16; type : pexCoordType; approxMethod : INT16; tolerance : Ctypes.float; tMin : Ctypes.float; tMax : Ctypes.float; numKnots : CARD32; numCoord : CARD32; (* LISTof FLOAT(numKnots) -- length = order + number of coords *) (* LISTof {pexCoord3D|pexCoord4D}(numCoord) *) END; (* pexTrimCurve *) pexReflectionAttr = RECORD ambient : Ctypes.float; diffuse : Ctypes.float; specular : Ctypes.float; specularConc : Ctypes.float; transmission : Ctypes.float; (* 0.0 = opaque, 1.0 = transparent *) specularColour : pexColourSpecifier; (* SINGLE COLOUR() *) END; (* pexReflectionAttr *) pexSurfaceApprox = RECORD approxMethod : pexEnumTypeIndex; unused : CARD16; uTolerance : Ctypes.float; vTolerance : Ctypes.float; END; (* pexSurfaceApprox *) pexVertex = RECORD point : pexCoord3D; (* SINGLE OPT_DATA() *) END; (* pexVertex *) pexViewport = RECORD minval : BITS BITSIZE (pexDeviceCoord) FOR pexDeviceCoord; maxval : BITS BITSIZE (pexDeviceCoord) FOR pexDeviceCoord; useDrawable : pexSwitch; pad : ARRAY [0 .. 2] OF BYTE; END; (* pexViewport *) pexViewEntry = RECORD clipFlags : CARD16; unused : CARD16; clipLimits : BITS BITSIZE (pexNpcSubvolume) FOR pexNpcSubvolume; orientation : pexMatrix; mapping : pexMatrix; END; (* pexViewEntry *) pexViewRep = RECORD index : pexTableIndex; unused : CARD16; view : pexViewEntry; END; (* pexViewRep *)
* typedefs for lookup tables
pexTableInfo = RECORD definableEntries : CARD16; numPredefined : CARD16; predefinedMin : CARD16; predefinedMax : CARD16; END; (* pexTableInfo *) pexTableInfoStar = UNTRACED REF pexTableInfo; pexTableInfoStarStar = UNTRACED REF pexTableInfoStar; pexLineBundleEntry = RECORD lineType : pexEnumTypeIndex; polylineInterp : pexEnumTypeIndex; curveApprox : BITS BITSIZE (pexCurveApprox) FOR pexCurveApprox; lineWidth : Ctypes.float; lineColour : pexColourSpecifier; (* SINGLE COLOUR() *) END; (* pexLineBundleEntry *) pexMarkerBundleEntry = RECORD markerType : pexEnumTypeIndex; unused : INT16; markerScale : Ctypes.float; markerColour : pexColourSpecifier; (* SINGLE COLOUR() *) END; (* pexMarkerBundleEntry *) pexTextBundleEntry = RECORD textFontIndex : CARD16; textPrecision : CARD16; charExpansion : Ctypes.float; charSpacing : Ctypes.float; textColour : pexColourSpecifier; (* SINGLE COLOUR() *) END; (* pexTextBundleEntry *)
Note that since an InteriorBundleEntry contains 4 embedded instances of pexColourSpecifier, a variable-sized item, a data structure cannot be defined for it.
pexInteriorBundleEntry = RECORD interiorStyle : pexEnumTypeIndex; interiorStyleIndex : INT16; reflectionModel : pexEnumTypeIndex; surfaceInterp : pexEnumTypeIndex; bfInteriorStyle : pexEnumTypeIndex; bfInteriorStyleIndex : INT16; bfReflectionModel : pexEnumTypeIndex; bfSurfaceInterp : pexEnumTypeIndex; surfaceApprox : pexSurfaceApprox; (* SINGLE pexColourSpecifier surfaceColour *) (* SINGLE pexReflectionAttr reflectionAttr *) (* SINGLE pexColourSpecifier bfSurfaceColour *) (* SINGLE pexReflectionAttr bfReflectionAttr *) END; (* pexInteriorBundleEntry *) pexEdgeBundleEntry = RECORD edges : pexSwitch; unused : CARD8; edgeType : pexEnumTypeIndex; edgeWidth : Ctypes.float; edgeColour : pexColourSpecifier; (* SINGLE COLOUR() *) END; (* pexEdgeBundleEntry *) pexPatternEntry = RECORD colourType : pexColourType; numx : CARD16; numy : CARD16; unused : CARD16; (* LISTof Colour(numx, numy) 2D array of colours *) END; (* pexPatternEntry *)a pexColourEntry is just a pexColourSpecifier
pexTextFontEntry = RECORD numFonts : CARD32; (* LISTof pexFont( numFonts ) *) END; (* pexTextFontEntry *)a pexViewEntry is defined above
pexLightEntry = RECORD lightType : pexEnumTypeIndex; unused : INT16; direction : pexVector3D; point : pexCoord3D; concentration : Ctypes.float; spreadAngle : Ctypes.float; attenuation1 : Ctypes.float; attenuation2 : Ctypes.float; lightColour : pexColourSpecifier; (* SINGLE COLOUR() *) END; (* pexLightEntry *) pexDepthCueEntry = RECORD mode : pexSwitch; unused : CARD8; unused2 : CARD16; frontPlane : Ctypes.float; backPlane : Ctypes.float; frontScaling : Ctypes.float; backScaling : Ctypes.float; depthCueColour : pexColourSpecifier; (* SINGLE COLOUR() *) END; (* pexDepthCueEntry *) pexColourApproxEntry = RECORD approxType : INT16; approxModel : INT16; max1 : CARD16; max2 : CARD16; max3 : CARD16; dither : CARD8; unused : CARD8; mult1 : CARD32; mult2 : CARD32; mult3 : CARD32; weight1 : Ctypes.float; weight2 : Ctypes.float; weight3 : Ctypes.float; basePixel : CARD32; END; (* pexColourApproxEntry *)Font structures
pexFontProp = RECORD name : X.Atom; value : CARD32; END; (* pexFontProp *) pexFontInfo = RECORD firstGlyph : CARD32; lastGlyph : CARD32; defaultGlyph : CARD32; allExist : pexSwitch; strokeFont : pexSwitch; unused : CARD16; numProps : CARD32; (* LISTof pexFontProp(numProps) *) END; (* pexFontInfo *) pexFontInfoStar = UNTRACED REF pexFontInfo; pexFontInfoStarStar = UNTRACED REF pexFontInfoStar;Text Structures
pexMonoEncoding = RECORD characterSet : INT16; characterSetWidth : CARD8; encodingState : CARD8; unused : CARD16; numChars : CARD16; (* LISTof CHARACTER( numChars ) *) (* pad *) END; (* pexMonoEncoding *)CHARACTER is either a CARD8, a CARD16, or a CARD32
Parametric Surface Characteristics types
type 1 None
type 2 Implementation Dependent
pexPSC_IsoparametricCurves = RECORD placementType : CARD16; unused : CARD16; numUcurves : CARD16; numVcurves : CARD16; END; (* pexPSC_IsoparametricCurves *) (* type 3 *) pexPSC_LevelCurves = RECORD origin : pexCoord3D; direction : pexVector3D; numberIntersections : CARD16; pad : CARD16; (* LISTof pexCoord3D( numIntersections ) *) END; (* pexPSC_LevelCurves *) (* type 4: MC, type 5: WC *)Pick Device data records
pexPD_DC_HitBox = RECORD position : pexDeviceCoord2D; distance : Ctypes.float; END; (* pexPD_DC_HitBox *) (* pick device 1 *) pexPD_NPC_HitVolume = pexNpcSubvolume; (* pick device 2 *)Output Command errors
pexOutputCommandError = RECORD type : CARD8; (* 0 *) errorCode : CARD8; (* 14 *) sequenceNumber : CARD16; resourceId : CARD32; (* renderer or structure *) minorCode : CARD16; majorCode : CARD8; unused : CARD8; opcode : CARD16; (* opcode of failed output command *) numCommands : CARD16; (* number successfully done before error *) pad : ARRAY [0 .. 15] OF BYTE; END; (* pexOutputCommandError *)*************************************************************************** Based on PEXlib.h Not yet complete! ***************************************************************************
* PEXlib constants
for PEXRotationMatrix
CONST pxlXAxis = 1; pxlYAxis = 2; pxlZAxis = 3;output command buffer types
pxlRenderImmediate = PEX_RenderOutputCommands; pxlAddToStructure = PEX_StoreElements;A pxlInt is a 32-bit integeger value
TYPE pxlInt = INT32; unsigned_pxlInt = CARD32;
* Following are the typedefs used in the PEXlib interface. pxlFooBar * definitions are always supersets of the pexFooBar protocol definitions. * Note that most pxlFooBar definitions are equivalent to the pexFooBar * protocol definitions. However some of the definitions do have extra * fields. The extra fields are used to access data that would normally * follow a pexFooBar in the protocol. pxlFooBar definitions should * *never* contain fields which are not required in the protocol. This * means pexlib can copy pxlFooBar data into the protocol stream. Sometimes * the data which follows a pexFooBar is variable length. For example * * typedef struct pxlColourSpecifier * { * pxlColourType colourType; * CARD16 unused; * pxlColour colour; * } pxlColourSpecifier; * * typedef struct pexColourSpecifier * { * pexColourType colourType; * CARD16 unused; * ( SINGLE COLOUR(colourType) ) * } pexColourSpecifier; * * The pxlColorSpecifier has an extra field for accessing the colour data. * Note that the size of 'colour' depends on the colour type. (ie: pxlColour * and pexColour are defined as a union of all possible colour types) * Using a pxlColourSpecifier provides the application easy access to the * colour data. However PEXlib must pack the colour data before sending it * down to the pex server. *
* PEXlib definitions used globally
TYPE pxlAsfAttribute = pexAsfAttribute; pxlAsfValue = pexAsfValue; pxlBitmask = pexBitmask; pxlBitmaskShort = pexBitmaskShort; pxlCoordType = pexCoordType; pxlComposition = pexComposition; pxlCullMode = pexCullMode; pxlDynamicType = pexDynamicType; pxlEnumTypeIndex = pexEnumTypeIndex; pxlLookupTable = X.XID; (* was pexLookupTable *) pxlName = pexName; pxlNameStar = pexNameStar; pxlNameStarStar = pexNameStarStar; pxlNameSet = X.XID; (* was pexNameSet *) pxlPipelineContext = pexPC; pxlFont = pexFont; pxlMatrix = pexMatrix; pxlMatrixStar = pexMatrixStar; pxlMatrix3X3 = pexMatrix3X3; pxlRenderer = pexRenderer; pxlStructure = pexStructure; pxlStructureStar = pexStructureStar; pxlStructureStarStar = pexStructureStarStar; pxlSwitch = pexSwitch; pxlTableIndex = pexTableIndex; pxlTableIndexStar = pexTableIndexStar; pxlTableType = pexTableType; pxlTextHAlignment = pexTextHAlignment; pxlTextVAlignment = pexTextVAlignment; pxlTypeOrTableIndex = pexTypeOrTableIndex; pxlColourType = pexColourType; pxlString = pexString; pxlStructureInfo = pexStructureInfo; pxlStructureInfoStar = pexStructureInfoStar; pxlVector2D = pexVector2D; pxlVector3D = pexVector3D; pxlVector3DStar = pexVector3DStar; pxlCurveApprox = pexCurveApprox; pxlDeviceRect = pexDeviceRect; pxlDeviceRectStar = pexDeviceRectStar; pxlElementInfo = pexElementInfo; pxlElementInfoStar = pexElementInfoStar; pxlElementInfoStarStar = pexElementInfoStarStar; pxlElementPos = pexElementPos; pxlElementRange = pexElementRange; pxlElementRef = pexElementRef; pxlElementRefStar = pexElementRefStar; pxlExtentInfo = pexExtentInfo; pxlEnumTypeDesc = pexEnumTypeDesc; pxlHalfSpace = pexHalfSpace; pxlHalfSpaceStar = pexHalfSpaceStar; pxlNameSetPair = pexNameSetPair; pxlNameSetPairStar = pexNameSetPairStar; pxlHalfSpace2D = pexHalfSpace2D; pxlHalfSpace2DStar = pexHalfSpace2DStar; pxlLocalTransform3DData = pexLocalTransform3DData; pxlLocalTransform3DDataStar = pexLocalTransform3DDataStar; pxlLocalTransform2DData = pexLocalTransform2DData; pxlLocalTransform2DDataStar = pexLocalTransform2DDataStar; pxlNpcSubvolume = pexNpcSubvolume; pxlPickPath = pexPickPath; pxlPickPathStar = pexPickPathStar; pxlPickPathStarStar = pexPickPathStarStar; pxlTextAlignmentData = pexTextAlignmentData; pxlTrimCurve = pexTrimCurve; pxlSurfaceApprox = pexSurfaceApprox; pxlVertex = pexVertex; pxlViewport = pexViewport; pxlViewRep = pexViewRep; pxlMonoEncoding = pexMonoEncoding; pxlPSC_IsoparametricCurves = pexPSC_IsoparametricCurves; pxlPSC_LevelCurves = pexPSC_LevelCurves; pxlSearchContext = X.XID; pxlPhigsWks = pexPhigsWks;
* Coordinate definitions
pxlCoord2D = pexCoord2D; pxlCoord2DStar = pexCoord2DStar; pxlCoord3D = pexCoord3D; pxlCoord3DStar = pexCoord3DStar; pxlCoord4D = pexCoord4D; pxlCoord4DStar = pexCoord4DStar; pxlDeviceCoord = pexDeviceCoord; pxlDeviceCoord2D = pexDeviceCoord2D;
* Colour definitions
pxlRgbFloatColour = pexRgbFloatColour; pxlHsvColour = pexHsvColour; pxlHlsColour = pexHlsColour; pxlCieColour = pexCieColour; pxlRgb8Colour = pexRgb8Colour; pxlRgb16Colour = pexRgb16Colour; pxlIndexedColour = pexIndexedColour; pxlIndexedColourStar = pexIndexedColourStar; pxlColour = pexColour; pxlColourStar = pexColourStar; pxlFloatColour = pexFloatColour; pxlColourSpecifier = RECORD colourType : pxlColourType; unused : CARD16; colour : pxlColour; END; (* pxlColourSpecifier *)
* reflection attributes
pxlReflectionAttr = RECORD ambient : Ctypes.float; diffuse : Ctypes.float; specular : Ctypes.float; specularConc : Ctypes.float; transmission : Ctypes.float; specularColour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier; END; (* pxlReflectionAttr *) pxlReflectionAttrStar = UNTRACED REF pxlReflectionAttr;
* Definitions used for output commands
pxlMarkerType = pexMarkerType; pxlMarkerScale = pexMarkerScale; pxlMarkerColourIndex = pexMarkerColourIndex; pxlMarkerColour = pexMarkerColour; pxlMarkerBundleIndex = pexMarkerBundleIndex; pxlTextFontIndex = pexTextFontIndex; pxlTextPrecision = pexTextPrecision; pxlCharExpansion = pexCharExpansion; pxlCharSpacing = pexCharSpacing; pxlTextColourIndex = pexTextColourIndex; pxlTextColour = pexTextColour; pxlCharHeight = pexCharHeight; pxlCharUpVector = pexCharUpVector; pxlTextPath = pexTextPath; pxlTextAlignment = pexTextAlignment; pxlAtextHeight = pexAtextHeight; pxlAtextUpVector = pexAtextUpVector; pxlAtextPath = pexAtextPath; pxlAtextAlignment = pexAtextAlignment; pxlAtextStyle = pexAtextStyle; pxlTextBundleIndex = pexTextBundleIndex; pxlLineType = pexLineType; pxlLineWidth = pexLineWidth; pxlLineColourIndex = pexLineColourIndex; pxlLineColour = pexLineColour; pxlCurveApproximation = pexCurveApproximation; pxlPolylineInterp = pexPolylineInterp; pxlLineBundleIndex = pexLineBundleIndex; pxlInteriorStyle = pexInteriorStyle; pxlInteriorStyleIndex = pexInteriorStyleIndex; pxlSurfaceColourIndex = pexSurfaceColourIndex; pxlSurfaceColour = pexSurfaceColour; pxlSurfaceReflAttr = pexSurfaceReflAttr; pxlSurfaceReflModel = pexSurfaceReflModel; pxlSurfaceInterp = pexSurfaceInterp; pxlBfInteriorStyle = pexBfInteriorStyle; pxlBfInteriorStyleIndex = pexBfInteriorStyleIndex; pxlBfSurfaceColourIndex = pexBfSurfaceColourIndex; pxlBfSurfaceColour = pexBfSurfaceColour; pxlBfSurfaceReflAttr = pexBfSurfaceReflAttr; pxlBfSurfaceReflModel = pexBfSurfaceReflModel; pxlBfSurfaceInterp = pexBfSurfaceInterp; pxlSurfaceApproximation = pexSurfaceApproximation; pxlCullingMode = pexCullingMode; pxlDistinguishFlag = pexDistinguishFlag; pxlPatternSize = pexPatternSize; pxlPatternRefPt = pexPatternRefPt; pxlPatternAttr = pexPatternAttr; pxlInteriorBundleIndex = pexInteriorBundleIndex; pxlSurfaceEdgeFlag = pexSurfaceEdgeFlag; pxlSurfaceEdgeType = pexSurfaceEdgeType; pxlSurfaceEdgeWidth = pexSurfaceEdgeWidth; pxlSurfaceEdgeColourIndex = pexSurfaceEdgeColourIndex; pxlSurfaceEdgeColour = pexSurfaceEdgeColour; pxlEdgeBundleIndex = pexEdgeBundleIndex; pxlSetAsfValues = pexSetAsfValues; pxlLocalTransform = pexLocalTransform; pxlLocalTransform2D = pexLocalTransform2D; pxlGlobalTransform = pexGlobalTransform; pxlGlobalTransform2D = pexGlobalTransform2D; pxlModelClip = pexModelClip; pxlModelClipVolume = pexModelClipVolume; pxlModelClipVolume2D = pexModelClipVolume2D; pxlRestoreModelClip = pexRestoreModelClip; pxlViewIndex = pexViewIndex; pxlLightState = pexLightState; pxlDepthCueIndex = pexDepthCueIndex; pxlPickId = pexPickId; pxlHlhsrIdentifier = pexHlhsrIdentifier; pxlColourApproxIndex = pexColourApproxIndex; pxlRenderingColourModel = pexRenderingColourModel; pxlParaSurfCharacteristics = pexParaSurfCharacteristics; pxlAddToNameSet = pexAddToNameSet; pxlRemoveFromNameSet = pexRemoveFromNameSet; pxlExecuteStructure = pexExecuteStructure; pxlLabel = pexLabel; pxlApplicationData = pexApplicationData; pxlGse = pexGse; pxlMarker = pexMarker; pxlMarker2D = pexMarker2D; pxlText = pexText; pxlText2D = pexText2D; pxlAnnotationText = pexAnnotationText; pxlAnnotationText2D = pexAnnotationText2D; pxlPolyline = pexPolyline; pxlPolyline2D = pexPolyline2D; pxlPolylineSet = pexPolylineSet; pxlNurbCurve = pexNurbCurve; pxlFillArea = pexFillArea; pxlFillArea2D = pexFillArea2D; pxlExtFillArea = pexExtFillArea; pxlFillAreaSet = pexFillAreaSet; pxlFillAreaSet2D = pexFillAreaSet2D; pxlExtFillAreaSet = pexExtFillAreaSet; pxlTriangleStrip = pexTriangleStrip; pxlQuadrilateralMesh = pexQuadrilateralMesh; pxlSOFAS = pexSOFAS; pxlNurbSurface = pexNurbSurface; pxlNurbSurfaceStar = pexNurbSurfaceStar; pxlCellArray = pexCellArray; pxlCellArray2D = pexCellArray2D; pxlExtCellArray = pexExtCellArray; pxlGdp = pexGdp; pxlGdp2D = pexGdp2D; pxlAsfData = RECORD attribute : unsigned_pxlInt; (* was unsigned long *) value : Ctypes.unsigned_char; pad : ARRAY [0 .. 2] OF Ctypes.unsigned_char; END; (* pxlAsfData *) pxlStringData = RECORD numChars : Ctypes.int; chars : Ctypes.char_star; END; (* pxlStringData *) pxlStringDataStar = UNTRACED REF pxlStringData; pxlStringDataStarStar = UNTRACED REF pxlStringDataStar; pxlMonoEncodedTextData = RECORD characterSet : INT16; characterSetWidth : CARD8; encodingState : CARD8; unused : CARD16; numChars : CARD16; chars : Ctypes.char_star; END; (* pxlMonoEncodedTextData *) pxlMonoEncodedTextDataStar = UNTRACED REF pxlMonoEncodedTextData; pxlPolylineData = RECORD numPoints : Ctypes.int; points : Ctypes.char_star; END; (* pxlPolylineData *) pxlPolylineDataStar = UNTRACED REF pxlPolylineData; pxlPolygonData = RECORD facetData : Ctypes.char_star; numPoints : Ctypes.int; points : Ctypes.char_star; END; (* pxlPolygonData *) pxlPolygonDataStar = UNTRACED REF pxlPolygonData; pxlContourData = RECORD numPoints : Ctypes.int; points : Ctypes.char_star; END; (* pxlContourData *) pxlContourDataStar = UNTRACED REF pxlContourData; pxlComplexPolygonData = RECORD facetData : Ctypes.char_star; numPolygons : Ctypes.int; polygons : pxlContourDataStar; END; (* pxlComplexPolygonData *) pxlComplexPolygonDataStar = UNTRACED REF pxlComplexPolygonData; pxlTrimCurveData = RECORD visibility : Ctypes.int; order : Ctypes.int; type : Ctypes.int; approxMethod : Ctypes.int; tolerance : Ctypes.float; tmin : Ctypes.float; tmax : Ctypes.float; numPoints : Ctypes.int; knots : Ctypes.float_star; points : Ctypes.char_star; END; (* pxlTrimCurveData *) pxlTrimCurveDataStar = UNTRACED REF pxlTrimCurveData; pxlTrimLoopData = RECORD numTrimCurves : Ctypes.int; trimCurves : pxlTrimCurveDataStar; END; (* pxlTrimLoopData *) pxlTrimLoopDataStar = UNTRACED REF pxlTrimLoopData; pxlNurbSurfaceData = RECORD type : Ctypes.unsigned_short; uorder : Ctypes.unsigned_short; vorder : Ctypes.unsigned_short; numTrimLoops : Ctypes.unsigned_short; numMPoints : Ctypes.unsigned_short; numNPoints : Ctypes.unsigned_short; uknots : Ctypes.float_star; vknots : Ctypes.float_star; points : Ctypes.char_star; trimLoop : pxlTrimLoopDataStar; END; (* pxlNurbSurfaceData *) pxlNurbSurfaceDataStar = UNTRACED REF pxlNurbSurfaceData; pxlOutputCommandError = pexOutputCommandError;
* Definitions used for output commands * Note that these MUST match the equivalent DEC PHIGS structures
pxlPhigsPointList23 = RECORD number : Ctypes.int; type : Ctypes.int; pts23 : Ctypes.char_star; END; (* pxlPhigsPointList23 *) pxlPhigsFloatList = RECORD number : Ctypes.int; floats : Ctypes.float_star; END; (* pxlPhigsFloatList *) pxlPhigsTrimCurve = RECORD visflag : Ctypes.int; order : Ctypes.int; trimKnot : pxlPhigsFloatList; ctlpts : pxlPhigsPointList23; tmin : Ctypes.float; tmax : Ctypes.float; END; (* pxlPhigsTrimCurve *) pxlPhigsTrimCurveStar = UNTRACED REF pxlPhigsTrimCurve; pxlPhigsTrimList = RECORD number : Ctypes.int; trim : pxlPhigsTrimCurveStar; END; (* pxlPhigsTrimList *) pxlPhigsTrimListStar = UNTRACED REF pxlPhigsTrimList;
* Definitions for lookup tables
pxlTableInfo = pexTableInfo; pxlTableInfoStar = pexTableInfoStar; pxlTableInfoStarStar = pexTableInfoStarStar; pxlLineBundleEntry = RECORD lineType : pxlEnumTypeIndex; polylineInterp : pxlEnumTypeIndex; curveApprox : BITS BITSIZE (pxlCurveApprox) FOR pxlCurveApprox; lineWidth : Ctypes.float; lineColour : pxlColourSpecifier; END; (* pxlLineBundleEntry *) pxlMarkerBundleEntry = RECORD markerType : pxlEnumTypeIndex; unused : INT16; markerScale : Ctypes.float; markerColour : pxlColourSpecifier; END; (* pxlMarkerBundleEntry *) pxlTextBundleEntry = RECORD textFontIndex : CARD16; textPrecision : CARD16; charExpansion : Ctypes.float; charSpacing : Ctypes.float; textColour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier; END; (* pxlTextBundleEntry *) pxlInteriorBundleEntry = RECORD interiorStyle : pxlEnumTypeIndex; interiorStyleIndex : INT16; reflectionModel : pxlEnumTypeIndex; surfaceInterp : pxlEnumTypeIndex; bfInteriorStyle : pxlEnumTypeIndex; bfInteriorStyleIndex : INT16; bfReflectionModel : pxlEnumTypeIndex; bfSurfaceInterp : pxlEnumTypeIndex; surfaceApprox : pxlSurfaceApprox; surfaceColour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier; reflectionAttr : pxlReflectionAttr; bfSurfaceColour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier; bfReflectionAttr : pxlReflectionAttr; END; (* pxlInteriorBundleEntry *) pxlEdgeBundleEntry = RECORD edges : pxlSwitch; unused : CARD8; edgeType : pxlEnumTypeIndex; edgeWidth : Ctypes.float; edgeColour : pxlColourSpecifier; END; (* pxlEdgeBundleEntry *) pxlPatternEntry = RECORD colourType : pxlColourType; numx : Ctypes.unsigned_short; numy : Ctypes.unsigned_short; unused : CARD16; colours : Ctypes.char_star; (* ptr to 2D array of colours of type: *) (* pxlRgbFloatColour, pxlHsvColour, pxlHlsColour, pxlCieColour, pxlRgb8Colour, pxlRgb16Colour, or short (for PEXIndexedColour colours) *) END; (* pxlPatternEntry *) pxlColourEntry = RECORD colour : pxlColourSpecifier; END; (* pxlColourEntry *) pxlTextFontEntry = RECORD numFonts : CARD32; fonts : pexFontStar; END; (* pxlTextFontEntry *) pxlViewEntry = pexViewEntry; pxlLightEntry = RECORD lightType : pxlEnumTypeIndex; unused : INT16; direction : pxlVector3D; point : pxlCoord3D; concentration : Ctypes.float; spreadAngle : Ctypes.float; attenuation1 : Ctypes.float; attenuation2 : Ctypes.float; lightColour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier; END; (* pxlLightEntry *) pxlDepthCueEntry = RECORD mode : pxlSwitch; unused : CARD8; unused2 : CARD16; frontPlane : Ctypes.float; backPlane : Ctypes.float; frontScaling : Ctypes.float; backScaling : Ctypes.float; depthCueColour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier; END; (* pxlDepthCueEntry *) pxlColourApproxEntry = pexColourApproxEntry;
* Definitions for fonts
pxlFontProp = pexFontProp; pxlFontInfo = pexFontInfo; pxlFontInfoStar = pexFontInfoStar; pxlFontInfoStarStar = pexFontInfoStarStar;
* Defintions for PEX extension info
pxlInfo = RECORD majorVersion : Ctypes.unsigned_short; minorVersion : Ctypes.unsigned_short; release : unsigned_pxlInt; (* was unsigned long *) subsetInfo : unsigned_pxlInt; (* was unsigned long *) vendorName : Ctypes.char_star; END; (* pxlInfo *) pxlInfoStar = UNTRACED REF pxlInfo; pxlInfoStarStar = UNTRACED REF pxlInfoStar;
* Definitions for enumerated type descriptions
pxlEnumTypeDescList = RECORD enumVal : Ctypes.short; string : Ctypes.char_star; END; (* pxlEnumTypeDescList *) pxlEnumTypeDescListStar = UNTRACED REF pxlEnumTypeDescList; pxlEnumTypeDescListStarStar = UNTRACED REF pxlEnumTypeDescListStar;
* Definitions for pipeline context.
pxlLightList = RECORD numLights : unsigned_pxlInt; (* was unsigned long *) lightIndex : pxlTableIndexStar; END; (* pxlLightList *) pxlModelClipVolumeList = RECORD numHalfSpaces : Ctypes.int; halfSpace : pxlHalfSpaceStar; END; (* pxlModelClipVolumeList *) pxlPSCData = RECORD characteristics : Ctypes.short; length : Ctypes.short; pscData : Ctypes.char_star; END; (* pxlPSCData *) pxlPCAttributes = RECORD markerType : Ctypes.short; markerScale : Ctypes.float; markerColour : pxlColourSpecifier; markerBundleIndex : Ctypes.unsigned_short; textFont : Ctypes.unsigned_short; textPrecision : Ctypes.unsigned_short; charExpansion : Ctypes.float; charSpacing : Ctypes.float; textColour : pxlColourSpecifier; charHeight : Ctypes.float; charUpVector : BITS BITSIZE (pxlVector2D) FOR pxlVector2D; textPath : Ctypes.unsigned_short; textAlignment : BITS BITSIZE (pxlTextAlignmentData) FOR pxlTextAlignmentData; atextHeight : Ctypes.float; atextUpVector : pxlVector2D; atextPath : Ctypes.unsigned_short; atextAlignment : BITS BITSIZE (pxlTextAlignmentData) FOR pxlTextAlignmentData; atextStyle : Ctypes.short; textBundleIndex : Ctypes.unsigned_short; lineType : Ctypes.short; lineWidth : Ctypes.float; lineColour : pxlColourSpecifier; curveApprox : pxlCurveApprox; polylineInterp : Ctypes.short; lineBundleIndex : Ctypes.unsigned_short; interiorStyle : Ctypes.short; interiorStyleIndex : Ctypes.unsigned_short; surfaceColour : pxlColourSpecifier; reflectionAttr : pxlReflectionAttr; reflectionModel : Ctypes.short; surfaceInterp : Ctypes.short; bfInteriorStyle : Ctypes.short; bfInteriorStyleIndex : Ctypes.unsigned_short; bfSurfaceColour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier; bfReflectionAttr : pxlReflectionAttr; bfReflectionModel : Ctypes.short; bfSurfaceInterp : Ctypes.short; surfaceApprox : pxlSurfaceApprox; cullingMode : Ctypes.unsigned_short; distinguish : Ctypes.unsigned_char; pad : BYTE; (* Not present in C source! *) patternSize : BITS BITSIZE (pxlCoord2D) FOR pxlCoord2D; patternRefPt : pxlCoord3D; patternRefVec1 : pxlVector3D; patternRefVec2 : pxlVector3D; interiorBundleIndex : Ctypes.unsigned_short; surfaceEdges : Ctypes.unsigned_short; surfaceEdgeType : Ctypes.short; surfaceEdgeWidth : Ctypes.float; surfaceEdgeColour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier; edgeBundleIndex : Ctypes.unsigned_short; localTransform : pxlMatrix; globalTransform : pxlMatrix; modelClip : Ctypes.unsigned_short; modelClipVolume : pxlModelClipVolumeList; viewIndex : Ctypes.unsigned_short; lightState : pxlLightList; depthCueIndex : Ctypes.unsigned_short; asfValues : ARRAY [0 .. 1] OF unsigned_pxlInt; (* first word is mask, second is values *) pickId : pxlInt; HlhsrIdentifier : unsigned_pxlInt; nameSet : pxlNameSet; colourApproxIndex : Ctypes.unsigned_short; rdrColourModel : Ctypes.short; psc : pxlPSCData; END; (* pxlPCAttributes *) pxlPCAttributesStar = UNTRACED REF pxlPCAttributes; pxlPCAttributesStarStar = UNTRACED REF pxlPCAttributesStar;macro for setting bits in a PC value mask
UNSAFE C MACRO TRANSLATION!
PROCEDURE PEX_SetPCAttrMaskBit(VAR mask : ARRAY [0 .. 1] OF Ctypes.int; attrNum : Ctypes.int);
* Definitions for structures
TYPE pxlStructureInformation = RECORD numElements : unsigned_pxlInt; length : unsigned_pxlInt; numRefs : unsigned_pxlInt; editMode : Ctypes.unsigned_short; elementPtr : unsigned_pxlInt; END; (* pxlStructureInformation *) pxlStructureInformationStar = UNTRACED REF pxlStructureInformation; pxlStructureInformationStarStar = UNTRACED REF pxlStructureInformationStar; pxlStructurePath = RECORD pathLength : Ctypes.int; elementRefs : pxlElementRefStar; END; (* pxlStructurePath *) pxlStructurePathStar = UNTRACED REF pxlStructurePath; pxlStructurePathStarStar = UNTRACED REF pxlStructurePathStar; pxlNameSetPairList = RECORD numPairs : Ctypes.int; pairs : pxlNameSetPairStar; END; (* pxlNameSetPairList *)typedefs for search context attributes. defines in PEX.h
CONST pxlMaxSCShift = 6; TYPE pxlSCAttributes = RECORD position : pxlCoord3D; distance : Ctypes.float; ceiling : Ctypes.unsigned_short; startPath : pxlStructurePath; normalList : pxlNameSetPairList; invertedList : pxlNameSetPairList; END; (* pxlSCAttributes *)typedefs for PHIGS workstation info attributes. defines in PEX.h
pxlViewList = RECORD numViews : unsigned_pxlInt; views : Ctypes.unsigned_short_star; END; (* pxlViewList *) pxlStructureInfoList = RECORD numStructureInfo : unsigned_pxlInt; info : pxlStructureInfoStar; END; (* pxlStructureInfoList *) pxlPhigsWksInfo = RECORD drawableUpdate : Ctypes.short; visualState : Ctypes.unsigned_short; drawableSurface : Ctypes.unsigned_short; viewUpdate : Ctypes.unsigned_short; definedViews : pxlViewList; wksUpdate : Ctypes.unsigned_short; reqNpcSubvolume : pxlNpcSubvolume; curNpcSubvolume : pxlNpcSubvolume; reqWksViewport : pxlViewport; curWksViewport : pxlViewport; hlhsrUpdate : Ctypes.unsigned_short; reqHlhsrMode : Ctypes.unsigned_short; curHlhsrMode : Ctypes.unsigned_short; drawable : X.Drawable; markerBundle : pxlLookupTable; textBundle : pxlLookupTable; lineBundle : pxlLookupTable; interiorBundle : pxlLookupTable; edgeBundle : pxlLookupTable; colorTable : pxlLookupTable; depthCueTable : pxlLookupTable; lightTable : pxlLookupTable; colorApproxTable : pxlLookupTable; patternTable : pxlLookupTable; textFontTable : pxlLookupTable; highlightIncl : pxlNameSet; highlightExcl : pxlNameSet; invisibilityIncl : pxlNameSet; invisibilityExcl : pxlNameSet; postedStructures : pxlStructureInfoList; numPriorities : unsigned_pxlInt; END; (* pxlPhigsWksInfo *)typedefs for PHIGS workstation dynamics. defines in PEX.h
pxlPhigsWksDynamics = RECORD viewRep : Ctypes.unsigned_char; markerBundle : Ctypes.unsigned_char; textBundle : Ctypes.unsigned_char; lineBundle : Ctypes.unsigned_char; interiorBundle : Ctypes.unsigned_char; edgeBundle : Ctypes.unsigned_char; colorTable : Ctypes.unsigned_char; patternTable : Ctypes.unsigned_char; wksTransform : Ctypes.unsigned_char; highlightFilter : Ctypes.unsigned_char; invisibilityFilter : Ctypes.unsigned_char; hlhsrMode : Ctypes.unsigned_char; structureModify : Ctypes.unsigned_char; postStructure : Ctypes.unsigned_char; unpostStructure : Ctypes.unsigned_char; deleteStructure : Ctypes.unsigned_char; referenceModify : Ctypes.unsigned_char; END; (* pxlPhigsWksDynamics *)
* Definitions for renderer
pxlClipList = RECORD numDeviceRects : unsigned_pxlInt; deviceRect : pxlDeviceRectStar; END; (* pxlClipList *) pxlRendererAttributes = RECORD pipelineContext : pxlPipelineContext; currentPath : pxlStructurePath; markerBundle : pxlLookupTable; textBundle : pxlLookupTable; lineBundle : pxlLookupTable; interiorBundle : pxlLookupTable; edgeBundle : pxlLookupTable; viewTable : pxlLookupTable; colourTable : pxlLookupTable; depthCueTable : pxlLookupTable; lightTable : pxlLookupTable; colourApproxTable : pxlLookupTable; patternTable : pxlLookupTable; textFontTable : pxlLookupTable; highlightIncl : pxlNameSet; highlightExcl : pxlNameSet; invisibilityIncl : pxlNameSet; invisibilityExcl : pxlNameSet; rendererState : Ctypes.unsigned_short; hlhsrMode : Ctypes.unsigned_short; npcSubvolume : BITS BITSIZE (pxlNpcSubvolume) FOR pxlNpcSubvolume; viewport : pxlViewport; clipList : pxlClipList; (*** rest is new in the AOSF version ***) pickInclusion : pexNameSet; pickExclusion : pexNameSet; pickStartPath : pxlStructurePath; backgroundColour : pxlColourSpecifier; clearI : Ctypes.unsigned_char; clearZ : Ctypes.unsigned_char; echoMode : Ctypes.unsigned_char; END; (* pxlRendererAttributes *) pxlRendererAttributesStar = UNTRACED REF pxlRendererAttributes; pxlRendererAttributesStarStar = UNTRACED REF pxlRendererAttributesStar;
* Generic definition of pex OC buffers
pxlOCBuf = RECORD initLengthRequested : Ctypes.int; (* hint for size of oc request *) initLength : Ctypes.int; display : X. DisplayStar; extOpcode : Ctypes.char; (* opcode for pex extension *) pexOpcode : Ctypes.char; (* opcode for ROC or StoreElements *) retainedOCBuffer : Ctypes.short; (* for transient, 1 for retained *) target : Ctypes.unsigned_long; (* renderer id or structure id *) basePtr : Ctypes.unsigned_int_star; (* points to start of current oc request *) curPtr : Ctypes.unsigned_int_star; (* where to store next oc *) bufMax : Ctypes.unsigned_int_star; (* end of buffer containing oc request *) ocWordsLeft : Ctypes.int; (* words left to copy to oc buffer, *) (* words allocated via PEXInitOC *) lrTotalNum : Ctypes.int; (* number of packets for large request *) lrTotalLength : Ctypes.int; (* size of data for large request *) lrSequenceNum : Ctypes.int; (* # of current large request packet *) lrBufferLength : Ctypes.int; (* # words avail in a lr packet *) lrBufferLeft : Ctypes.int; (* # of words left in current lr packet*) OCError : PROCEDURE (); FreeOCBuf : PROCEDURE (); ClearOCBuf : PROCEDURE (); SetOCBufType : PROCEDURE (); SetOCBufTarget : PROCEDURE (); GetOCBufType : PROCEDURE (); GetOCBufFreeSpace : PROCEDURE () : Ctypes.int; GetMaxOCChunkSize : PROCEDURE () : Ctypes.int;
DIFFERS FROM ORIGINAL C SOURCE !!
FlushOCBuf : (PROCEDURE (ocbuf : pxlOCBufStar));
FlushOCBuf : PROCEDURE ();
SendOCBuf : (PROCEDURE (ocbuf : pxlOCBufStar));
SendOCBuf : PROCEDURE ();
StartOC : PROCEDURE () : Ctypes.int; StartLargeRequest : PROCEDURE () : Ctypes.int; FinishOC : PROCEDURE (); GetOCWords : PROCEDURE () : Ctypes.unsigned_int_star; CopyOCBytes : PROCEDURE (); StoreOCList : PROCEDURE (); END; (* pxlOCBuf *) pxlOCBufStar = UNTRACED REF pxlOCBuf; pxlOCBufStarStar = UNTRACED REF pxlOCBufStar;*************************************************************************** Should be in pexlibprotos.h, but is missing for some reason: ***************************************************************************
<*EXTERNAL*> PROCEDURE PEXSetColourApproxIndex ( ocbuf : pxlOCBufStar; index : Ctypes.int);*************************************************************************** Based on pexlibprotos.h Version 0.1 Not yet complete! ***************************************************************************
* * File Name: * pexlibprotos.h * * Subsystem: * pex * * Version: * 0.1 * * Abstract: * Define prototypes for all external pexlib routines * * Keywords: * pex, pexlib * * Environment: * included by pexlib.h if PROTOS is defined * * Author: * Andrew F. Vesper, Worksystems Graphics Software, PEXlib * * Creation Date: * 13-Mar-1991 * * Modification History: * xx-Apr-91 P?W Updated for PEX protocol V5 * 29-Apr-91 AFV Fixed some prototype definitions. * 6-May-91 AFV Change names of PEXPHIGS... routines * 11-Jul-91 STC Add Ellipse stuff * 9-Sep-91 SB Added 2 new OC's MPEXGridRectangular MPEXGridRadial * 13-Sep-91 SB Modified MPEXGridRectangular to take an Origin as * input. * 25-Sep-91 SB Added a new prototype MPEXReferToStructure * 10-Oct-91 DM Added the new pipeline context requests * MPEXCopyNewPipelineContext, * MPEXGetNewPipelineContext, * MPEXChangeNewPipelineContext. Also added new text * skewed text attribute oc MPEXSetAnnotationTextSkew, * MPEXSetTextSkew.
* ErrorFunctionType is used in
* PEXAllocateRetainedOCBuffer
* PEXAllocateTransientOCBuffer
* PEXAllocateOCBuffer
* It is defined as PROCEDURE ()
in the C source, but the above procedures
* take PEXDefaultOCError as an argument, which has type
* PROCEDURE (ocbuf : pxlOCBufStar; value : Ctypes.int)
TYPE ErrorFunctionType = PROCEDURE (ocbuf : pxlOCBufStar ; value : Ctypes.int);
* Routines defined in pl_oc_buff.c
<*EXTERNAL*> PROCEDURE PEXAllocateRetainedOCBuffer ( (* INPUT *) display : X.DisplayStar; (* INPUT *) type : Ctypes.int; (* INPUT *) target : X.XID; (* INPUT *) errorFunction : ErrorFunctionType; (* INPUT *) initSize : Ctypes.unsigned_int) : pxlOCBufStar; <*EXTERNAL*> PROCEDURE PEXAllocateTransientOCBuffer ( (* INPUT *) display : X.DisplayStar; (* INPUT *) type : Ctypes.int; (* INPUT *) target : X.XID; (* INPUT *) errorFunction : ErrorFunctionType; (* INPUT *) initSize : Ctypes.int) : pxlOCBufStar; <*EXTERNAL*> PROCEDURE PEXGetDefaultOCBufferType ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* OUTPUT *) displayReturn : DisplayStarStar; (* OUTPUT *) typeReturn : Ctypes.int_star; (* OUTPUT *) targetReturn : XIDStar); <*EXTERNAL*> PROCEDURE PEXGetWordsError ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) nWords : Ctypes.int) : Ctypes.unsigned_int_star; <*EXTERNAL*> PROCEDURE PEXCopyBytesError ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) nBytes : Ctypes.int; (* INPUT *) buffer : Ctypes.char_star); <*EXTERNAL*> PROCEDURE PEXInitOC ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) ocType : Ctypes.int; (* INPUT *) ocHeaderLength : Ctypes.int; (* INPUT *) ocDataLength : Ctypes.int; (* INPUT *) pReq : Ctypes.char_star_star); <*EXTERNAL*> PROCEDURE PEXCopyBytesToOC ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) nBytes : Ctypes.int; (* INPUT *) OCData : Ctypes.char_star); <*EXTERNAL*> PROCEDURE PEXCopyWordsToOC ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) nWords : Ctypes.int; (* INPUT *) OCData : Ctypes.char_star); <*EXTERNAL*> PROCEDURE PEXGetOCWords ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) nWords : Ctypes.int) : Ctypes.unsigned_int_star; <*EXTERNAL*> PROCEDURE PEXAddOC ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) ocType : Ctypes.unsigned_int; (* INPUT *) size : Ctypes.int; (* INPUT *) OCData : Ctypes.char_star); <*EXTERNAL*> PROCEDURE PEXAddListOC ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) ocType : Ctypes.unsigned_int; (* INPUT *) countNeeded : Ctypes.int; (* INPUT *) count : Ctypes.int; (* INPUT *) elementSize : Ctypes.int; (* INPUT *) elementList : Ctypes.char_star); <*EXTERNAL*> PROCEDURE PEXDefaultStoreOCList ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) numElements : Ctypes.int; (* INPUT *) ocList : pxlElementInfoStar) ; <*EXTERNAL*> PROCEDURE PEXDefaultTransientOCBuffer () : Ctypes.int; <*EXTERNAL*> PROCEDURE PEXDefaultRetainedOCBuffer () : Ctypes.int; <*EXTERNAL*> PROCEDURE PEXDefaultOCError ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) value : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetOCOverflow ( (* INPUT *) value : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXGetOCOverflow () : Ctypes.int; <*EXTERNAL*> PROCEDURE PEXClearOCOverflow ();
* Routines defined in pl_oc_attr.c
<*EXTERNAL*> PROCEDURE PEXSetMarkerType ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) type : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetMarkerScale ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) scale : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetMarkerColourIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetMarkerColour ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) colour : pxlColourStar); <*EXTERNAL*> PROCEDURE PEXSetMarkerBundleIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetTextFontIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetTextPrecision ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) precision : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetCharExpansion ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) expansion : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetCharSpacing ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) spacing : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetTextColourIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetTextColour ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) colour : pxlColourStar); <*EXTERNAL*> PROCEDURE PEXSetCharHeight ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) height : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetCharUpVector ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) x : Ctypes.double; (* INPUT *) y : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetTextPath ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) path : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetTextAlignment ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) halignment : Ctypes.int; (* INPUT *) valignment : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetATextHeight ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) height : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetATextUpVector ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) x : Ctypes.double; (* INPUT *) y : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetATextPath ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) path : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetATextAlignment ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) halignment : Ctypes.int; (* INPUT *) valignment : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetATextStyle ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) style : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetTextBundleIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetLineType ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) type : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetLineWidth ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) width : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetLineColourIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetLineColour ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) colour : pxlColourStar); <*EXTERNAL*> PROCEDURE PEXSetCurveApproxMethod ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) approxMethod : Ctypes.int; (* INPUT *) tolerance : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetPolylineInterpMethod ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) method : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetLineBundleIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetInteriorStyle ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) style : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetInteriorStyleIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetSurfaceColourIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetSurfaceColour ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) colour : pxlColourStar); <*EXTERNAL*> PROCEDURE PEXSetReflectionAttributes ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) reflectionAttr : pxlReflectionAttrStar); <*EXTERNAL*> PROCEDURE PEXSetReflectionModel ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) model : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetSurfaceInterpMethod ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) method : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetBFInteriorStyle ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) style : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetBFInteriorStyleIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetBFSurfaceColourIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetBFSurfaceColour ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) colour : pxlColourStar); <*EXTERNAL*> PROCEDURE PEXSetBFReflectionAttributes ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) reflectionAttr : pxlReflectionAttrStar); <*EXTERNAL*> PROCEDURE PEXSetBFReflectionModel ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) model : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetBFSurfaceInterpMethod ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) method : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetSurfaceApproxMethod ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) approxMethod : Ctypes.int; (* INPUT *) sTolerance : Ctypes.double; (* INPUT *) tTolerance : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetFacetCullingMode ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) mode : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetFacetDistinguishFlag ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) flag : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetPatternSize ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) width : Ctypes.double; (* INPUT *) height : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetPatternRefPt ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) x : Ctypes.double; (* INPUT *) y : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetPatternAttributes ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) refPt : pxlCoord3DStar; (* INPUT *) vec1 : pxlVector3DStar; (* INPUT *) vec2 : pxlVector3DStar); <*EXTERNAL*> PROCEDURE PEXSetInteriorBundleIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetSurfaceEdgeFlag ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) flag : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetSurfaceEdgeType ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) type : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetSurfaceEdgeWidth ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) width : Ctypes.double); <*EXTERNAL*> PROCEDURE PEXSetSurfaceEdgeColourIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetSurfaceEdgeColour ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) colour : pxlColourStar); <*EXTERNAL*> PROCEDURE PEXSetEdgeBundleIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetIndividualASF ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) attribute : Ctypes.int; (* INPUT *) value : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetLocalTransform ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) transform : pxlLocalTransform3DDataStar); <*EXTERNAL*> PROCEDURE PEXSetLocalTransform2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) transform : pxlLocalTransform2DDataStar); <*EXTERNAL*> PROCEDURE PEXSetGlobalTransform ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) transform : pxlMatrixStar); (* was pxlMatrix (C vs Modula-3 Array passing problem) *) <*EXTERNAL*> PROCEDURE PEXSetGlobalTransform2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) transform : pxlMatrix3X3); <*EXTERNAL*> PROCEDURE PEXSetModelClipFlag ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) flag : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetModelClipVolume ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) operator : Ctypes.int; (* INPUT *) halfSpaces : pxlHalfSpaceStar; (* INPUT *) numHalfSpaces : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetModelClipVolume2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) operator : Ctypes.int; (* INPUT *) halfSpaces : pxlHalfSpace2DStar; (* INPUT *) numHalfSpaces : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXRestoreModelClipVolume ( (* IN-OUT *) ocbuf : pxlOCBufStar); <*EXTERNAL*> PROCEDURE PEXSetViewIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetLightSourceState ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) enable : pxlTableIndexStar; (* INPUT *) numEnable : Ctypes.int; (* INPUT *) disable : pxlTableIndexStar; (* INPUT *) numDisable : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetDepthCueIndex ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetRenderingColourModel ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) model : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetParaSurfCharacteristics ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) pscType : Ctypes.int; (* INPUT *) pscData : Ctypes.char_star); <*EXTERNAL*> PROCEDURE PEXSetPickID ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) id : Ctypes.unsigned_long); <*EXTERNAL*> PROCEDURE PEXSetHlhsrID ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) id : Ctypes.unsigned_long); <*EXTERNAL*> PROCEDURE PEXAddToNameSet ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) names : pxlNameStar; (* INPUT *) numNames : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXRemoveFromNameSet ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) names : pxlNameStar; (* INPUT *) numNames : Ctypes.int);
* Routines defined in pl_oc_prim.c
<*EXTERNAL*> PROCEDURE PEXMarkers ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) numPoints : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXMarkers2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) pts : pxlCoord2DStar; (* INPUT *) numPts : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXText ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord3DStar; (* INPUT *) vec1 : pxlVector3DStar; (* INPUT *) vec2 : pxlVector3DStar; (* INPUT *) string : Ctypes.char_star; (* INPUT *) count : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXText2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord2DStar; (* INPUT *) string : Ctypes.char_star; (* INPUT *) count : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXAnnotationText ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord3DStar; (* INPUT *) offset : pxlCoord3DStar; (* INPUT *) string : Ctypes.char_star; (* INPUT *) count : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXAnnotationText2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord2DStar; (* INPUT *) offset : pxlCoord2DStar; (* INPUT *) string : Ctypes.char_star; (* INPUT *) count : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXMonoEncodedText ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord3DStar; (* INPUT *) vec1 : pxlVector3DStar; (* INPUT *) vec2 : pxlVector3DStar; (* INPUT *) numEncodings : Ctypes.int; (* INPUT *) encodedTextList : pxlMonoEncodedTextDataStar); <*EXTERNAL*> PROCEDURE PEXMonoEncodedText2D ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord2DStar; (* INPUT *) numEncodings : Ctypes.int; (* INPUT *) encodedTextList : pxlMonoEncodedTextDataStar); <*EXTERNAL*> PROCEDURE PEXMonoEncodedAnnoText ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord3DStar; (* INPUT *) offset : pxlCoord3DStar; (* INPUT *) numEncodings : Ctypes.int; (* INPUT *) encodedTextList : pxlMonoEncodedTextDataStar); <*EXTERNAL*> PROCEDURE PEXMonoEncodedAnnoText2D ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord2DStar; (* INPUT *) offset : pxlCoord2DStar; (* INPUT *) numEncodings : Ctypes.int; (* INPUT *) encodedTextList : pxlMonoEncodedTextDataStar); <*EXTERNAL*> PROCEDURE PEXPolyline ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) vertices : pxlCoord3DStar; (* INPUT *) numVertices : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXPolyline2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) vertices : pxlCoord2DStar; (* INPUT *) numVertices : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXPolylineSet ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) polylines : pxlPolylineDataStar; (* INPUT *) numPolylines : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXNurbCurve ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) order : Ctypes.int; (* INPUT *) type : Ctypes.int; (* INPUT *) tmin : Ctypes.double; (* INPUT *) tmax : Ctypes.double; (* INPUT *) knots : Ctypes.float_star; (* INPUT *) points : Ctypes.char_star; (* INPUT *) numPoints : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXFillArea ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) numPoints : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXFillArea2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) points : pxlCoord2DStar; (* INPUT *) numPoints : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXMultiFillAreaData ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) polygons : pxlPolygonDataStar; (* INPUT *) numPolygons : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXFillAreaSet ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) contourHint : Ctypes.int; (* INPUT *) polygons : pxlPolygonDataStar; (* INPUT *) numPolygons : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXFillAreaSet2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) contourHint : Ctypes.int; (* INPUT *) polygons : pxlPolygonDataStar; (* INPUT *) numPolygons : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXMultiFillAreaSetData ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) contourHint : Ctypes.int; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) complexPolygons : pxlComplexPolygonDataStar; (* INPUT *) numComplexPolygons : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetOfFillAreaSets ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) contourHint : Ctypes.int; (* INPUT *) contoursAllOne : Ctypes.int; (* INPUT *) FASAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) edgeAttributes : Ctypes.unsigned_long; (* INPUT *) numFAS : Ctypes.int; (* INPUT *) numVertices : Ctypes.int; (* INPUT *) numEdges : Ctypes.int; (* INPUT *) numContours : Ctypes.int; (* INPUT *) FASOptDataList : Ctypes.char_star; (* INPUT *) verticeList : Ctypes.char_star; (* INPUT *) edgeList : Ctypes.char_star; (* INPUT *) FASList : Ctypes.char_star); <*EXTERNAL*> PROCEDURE PEXTriangleStrip ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) facetData : Ctypes.char_star; (* INPUT *) points : Ctypes.char_star; (* INPUT *) numPoints : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXQuadMesh ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) facetData : Ctypes.char_star; (* INPUT *) points : Ctypes.char_star; (* INPUT *) numPointsM : Ctypes.int; (* INPUT *) numPointsN : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXNurbSurface ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) nurb : pxlNurbSurfaceStar); <*EXTERNAL*> PROCEDURE PEXCellArray ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) pt1 : pxlCoord3DStar; (* INPUT *) pt2 : pxlCoord3DStar; (* INPUT *) pt3 : pxlCoord3DStar; (* INPUT *) dx : Ctypes.int; (* INPUT *) dy : Ctypes.int; (* INPUT *) icolours : pxlIndexedColourStar); <*EXTERNAL*> PROCEDURE PEXCellArray2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) pt1 : pxlCoord2DStar; (* INPUT *) pt2 : pxlCoord2DStar; (* INPUT *) dx : Ctypes.int; (* INPUT *) dy : Ctypes.int; (* INPUT *) icolours : pxlIndexedColourStar); <*EXTERNAL*> PROCEDURE PEXExtendedCellArray ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) pt1 : pxlCoord3DStar; (* INPUT *) pt2 : pxlCoord3DStar; (* INPUT *) pt3 : pxlCoord3DStar; (* INPUT *) dx : Ctypes.int; (* INPUT *) dy : Ctypes.int; (* INPUT *) colours : Ctypes.char_star); <*EXTERNAL*> PROCEDURE PEXGdp ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) id : Ctypes.int; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) numPoints : Ctypes.int; (* INPUT *) data : Ctypes.char_star; (* INPUT *) numBytes : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXGdp2D ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) id : Ctypes.int; (* INPUT *) points : pxlCoord2DStar; (* INPUT *) numPoints : Ctypes.int; (* INPUT *) data : Ctypes.char_star; (* INPUT *) numBytes : Ctypes.int);
* Routines defined in pl_oc_phigs.c
<*EXTERNAL*> PROCEDURE PEXPolylineSetUnpacked ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) colourType : Ctypes.int; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) colours : Ctypes.int_star; (* INPUT *) numPolylines : Ctypes.int; (* INPUT *) sizes : Ctypes.int_star); <*EXTERNAL*> PROCEDURE PEXEncodedTextUnpacked ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord3DStar; (* INPUT *) vec1 : pxlVector3DStar; (* INPUT *) vec2 : pxlVector3DStar; (* INPUT *) numCharStrings : Ctypes.int; (* INPUT *) charSetList : Ctypes.int_star; (* INPUT *) charWidthList : Ctypes.int_star; (* INPUT *) encodingStateList : Ctypes.int_star; (* INPUT *) charStringsList : pxlStringDataStar; (* INPUT *) highByteFirst : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXEncodedText2DUnpacked ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord2DStar; (* INPUT *) numCharStrings : Ctypes.int; (* INPUT *) charSetList : Ctypes.int_star; (* INPUT *) charWidthList : Ctypes.int_star; (* INPUT *) encodingStateList : Ctypes.int_star; (* INPUT *) charStringsList : pxlStringDataStar; (* INPUT *) highByteFirst : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXEncodedAnnoTextUnpacked ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord3DStar; (* INPUT *) offset : pxlCoord3DStar; (* INPUT *) numCharStrings : Ctypes.int; (* INPUT *) charSetList : Ctypes.int_star; (* INPUT *) charWidthList : Ctypes.int_star; (* INPUT *) encodingStateList : Ctypes.int_star; (* INPUT *) charStringsList : pxlStringDataStar; (* INPUT *) highByteFirst : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXEncodedAnnoText2DUnpacked ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord2DStar; (* INPUT *) offset : pxlCoord2DStar; (* INPUT *) numCharStrings : Ctypes.int; (* INPUT *) charSetList : Ctypes.int_star; (* INPUT *) charWidthList : Ctypes.int_star; (* INPUT *) encodingStateList : Ctypes.int_star; (* INPUT *) charStringsList : pxlStringDataStar; (* INPUT *) highByteFirst : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXFillAreaDataUnpacked ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) colourType : Ctypes.int; (* INPUT *) facetColour : Ctypes.int_star; (* INPUT *) facetNormal : pxlVector3DStar; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) colours : Ctypes.int_star; (* INPUT *) normals : pxlVector3DStar; (* INPUT *) numPoints : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXFillAreaSetUnpacked ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) contourHint : Ctypes.int; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) numContours : Ctypes.int; (* INPUT *) sizes : Ctypes.int_star); <*EXTERNAL*> PROCEDURE PEXFillAreaSet2DUnpacked ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) contourHint : Ctypes.int; (* INPUT *) points : pxlCoord2DStar; (* INPUT *) numContours : Ctypes.int; (* INPUT *) sizes : Ctypes.int_star); <*EXTERNAL*> PROCEDURE PEXFillAreaSetWithDataUnpacked ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) ignoreEdges : Ctypes.int; (* INPUT *) contourHint : Ctypes.int; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) colourType : Ctypes.int; (* INPUT *) facetColour : Ctypes.int_star; (* INPUT *) facetNormal : pxlVector3DStar; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) colours : Ctypes.int_star; (* INPUT *) normals : pxlVector3DStar; (* INPUT *) edges : Ctypes.int_star; (* INPUT *) numContours : Ctypes.int; (* INPUT *) sizes : Ctypes.int_star); <*EXTERNAL*> PROCEDURE PEXTriangleStripUnpacked ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) colourType : Ctypes.int; (* INPUT *) facetColours : Ctypes.int_star; (* INPUT *) facetNormals : pxlVector3DStar; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) colours : Ctypes.int_star; (* INPUT *) normals : pxlVector3DStar; (* INPUT *) numPoints : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXQuadMeshUnpacked ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) colourType : Ctypes.int; (* INPUT *) facetColours : Ctypes.int_star; (* INPUT *) facetNormals : pxlVector3DStar; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) colours : Ctypes.int_star; (* INPUT *) normals : pxlVector3DStar; (* INPUT *) numPointsM : Ctypes.int; (* INPUT *) numPointsN : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXIndexedPolygonsToSOFAS ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) edgeAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) colourType : Ctypes.int; (* INPUT *) facetColours : Ctypes.int_star; (* INPUT *) facetNormals : pxlVector3DStar; (* INPUT *) numFacets : Ctypes.int; (* INPUT *) edges : Ctypes.int_star; (* INPUT *) edgeVisFlags : Ctypes.int_star; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) colours : Ctypes.int_star; (* INPUT *) normals : pxlVector3DStar; (* INPUT *) numVertices : Ctypes.int; (* INPUT *) facetCounts : Ctypes.int_star); <*EXTERNAL*> PROCEDURE MPEXIndexedPolygonsUnpacked ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) edgeAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) colourType : Ctypes.int; (* INPUT *) facetColours : Ctypes.int_star; (* INPUT *) facetNormals : pxlVector3DStar; (* INPUT *) numFacets : Ctypes.int; (* INPUT *) edges : Ctypes.int_star; (* INPUT *) edgeVisFlags : Ctypes.int_star; (* INPUT *) points : pxlCoord3DStar; (* INPUT *) colours : Ctypes.int_star; (* INPUT *) normals : pxlVector3DStar; (* INPUT *) numVertices : Ctypes.int; (* INPUT *) facetCounts : Ctypes.int_star); <*EXTERNAL*> PROCEDURE PEXNurbSurfaceUnpacked ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) uOrder : Ctypes.int; (* INPUT *) vOrder : Ctypes.int; (* INPUT *) uKnots : Ctypes.float_star; (* INPUT *) numUKnots : Ctypes.int; (* INPUT *) vKnots : Ctypes.float_star; (* INPUT *) numVKnots : Ctypes.int; (* INPUT *) surfaceType : Ctypes.int; (* INPUT *) points : Ctypes.char_star; (* INPUT *) numMPoints : Ctypes.int; (* INPUT *) numNPoints : Ctypes.int; (* INPUT *) trimList : pxlPhigsTrimListStar; (* INPUT *) numTrimLoops : Ctypes.int);
* Routines declared in pl_font.c
<*EXTERNAL*> PROCEDURE PEXOpenFont ( (* INPUT *) display : X.DisplayStar; (* INPUT *) fontname : Ctypes.char_star) : pxlFont; <*EXTERNAL*> PROCEDURE PEXCloseFont ( (* INPUT *) display : X.DisplayStar; (* INPUT *) font : pxlFont); <*EXTERNAL*> PROCEDURE PEXQueryFont ( (* INPUT *) display : X.DisplayStar; (* INPUT *) font : pxlFont; (* OUTPUT *) fontInfoReturn : pxlFontInfoStarStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXListFonts ( (* INPUT *) display : X.DisplayStar; (* INPUT *) pattern : Ctypes.char_star; (* INPUT *) maxNames : Ctypes.int; (* OUTPUT *) countReturn : Ctypes.int_star; (* OUTPUT *) namesReturn : pxlStringDataStarStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXListFontsWithInfo ( (* INPUT *) display : X.DisplayStar; (* INPUT *) pattern : Ctypes.char_star; (* INPUT *) maxNames : Ctypes.int; (* OUTPUT *) numStringsReturn : Ctypes.int_star; (* OUTPUT *) numFontInfoReturn : Ctypes.int_star; (* OUTPUT *) namesReturn : pxlStringDataStarStar; (* OUTPUT *) infoReturn : pxlFontInfoStarStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXQueryTextExtents ( (* INPUT *) display : X.DisplayStar; (* INPUT *) id : X.XID; (* INPUT *) fontGroup : Ctypes.int; (* INPUT *) path : Ctypes.int; (* INPUT *) expansion : Ctypes.double; (* INPUT *) spacing : Ctypes.double; (* INPUT *) height : Ctypes.double; (* INPUT *) halign : Ctypes.int; (* INPUT *) valign : Ctypes.int; (* INPUT *) string : Ctypes.char_star; (* INPUT *) count : Ctypes.int; (* OUTPUT *) lowerLeftReturn : pxlCoord2DStar; (* OUTPUT *) upperRightReturn : pxlCoord2DStar; (* OUTPUT *) concatPtReturn : pxlCoord2DStar) : X.Status;
* Routines defined in pl_free.c
<*EXTERNAL*> PROCEDURE PEXFree ( (* INPUT *) pch : Ctypes.char_star);
* Routines defined in pl_lut.c
<*EXTERNAL*> PROCEDURE PEXCreateLookupTable ( (* INPUT *) display : X.DisplayStar; (* INPUT *) d : X.Drawable; (* INPUT *) type : Ctypes.int) : pxlLookupTable; <*EXTERNAL*> PROCEDURE PEXFreeLookupTable ( (* INPUT *) display : X.DisplayStar; (* INPUT *) lut : pxlLookupTable); <*EXTERNAL*> PROCEDURE PEXCopyLookupTable ( (* INPUT *) display : X.DisplayStar; (* INPUT *) srcLut : pxlLookupTable; (* INPUT *) destLut : pxlLookupTable); <*EXTERNAL*> PROCEDURE PEXGetTableInfo ( (* INPUT *) display : X.DisplayStar; (* INPUT *) d : X.Drawable; (* INPUT *) type : Ctypes.int; (* OUTPUT *) tableInfoReturn : pxlTableInfoStarStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetPredefinedEntries ( (* INPUT *) display : X.DisplayStar; (* INPUT *) d : X.Drawable; (* INPUT *) type : Ctypes.int; (* INPUT *) start : Ctypes.int; (* INPUT *) count : Ctypes.int; (* OUTPUT *) entriesReturn : Ctypes.char_star_star; (* OUTPUT *) numEntriesReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetDefinedIndices ( (* INPUT *) display : X.DisplayStar; (* INPUT *) lut : pxlLookupTable; (* OUTPUT *) indicesReturn : UNTRACED REF Ctypes.unsigned_short_star; (* OUTPUT *) numIndicesReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetTableEntry ( (* INPUT *) display : X.DisplayStar; (* INPUT *) lut : pxlLookupTable; (* INPUT *) index : Ctypes.int; (* INPUT *) valueType : Ctypes.int; (* OUTPUT *) statusReturn : Ctypes.int_star; (* OUTPUT *) entryReturn : Ctypes.char_star_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetTableEntries ( (* INPUT *) display : X.DisplayStar; (* INPUT *) lut : pxlLookupTable; (* INPUT *) start : Ctypes.int; (* INPUT *) count : Ctypes.int; (* INPUT *) valueType : Ctypes.int; (* OUTPUT *) entriesReturn : Ctypes.char_star_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXSetTableEntries ( (* INPUT *) display : X.DisplayStar; (* INPUT *) lut : pxlLookupTable; (* INPUT *) type : Ctypes.int; (* INPUT *) start : Ctypes.int; (* INPUT *) count : Ctypes.int; (* INPUT *) entries : Ctypes.char_star); <*EXTERNAL*> PROCEDURE PEXDeleteTableEntries ( (* INPUT *) display : X.DisplayStar; (* INPUT *) lut : pxlLookupTable; (* INPUT *) start : Ctypes.int; (* INPUT *) count : Ctypes.int);
* Routines defined in pl_nameset.c
<*EXTERNAL*> PROCEDURE PEXCreateNameSet ( (* INPUT *) display : X.DisplayStar) : pxlNameSet; <*EXTERNAL*> PROCEDURE PEXFreeNameSet ( (* INPUT *) display : X.DisplayStar; (* INPUT *) ns : pxlNameSet); <*EXTERNAL*> PROCEDURE PEXCopyNameSet ( (* INPUT *) display : X.DisplayStar; (* INPUT *) srcNs : pxlNameSet; (* INPUT *) destNs : pxlNameSet); <*EXTERNAL*> PROCEDURE PEXGetNameSet ( (* INPUT *) display : X.DisplayStar; (* INPUT *) ns : pxlNameSet; (* OUTPUT *) namesReturn : pxlNameStarStar; (* OUTPUT *) numNamesReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXChangeNameSet ( (* INPUT *) display : X.DisplayStar; (* INPUT *) ns : pxlNameSet; (* INPUT *) action : Ctypes.int; (* INPUT *) values : pxlNameStar; (* INPUT *) numValues : Ctypes.int);
* Routines defined in pl_oc_struct.c
<*EXTERNAL*> PROCEDURE PEXExecuteStructure ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) structure : pxlStructure); <*EXTERNAL*> PROCEDURE PEXLabel ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) label : Ctypes.long); <*EXTERNAL*> PROCEDURE PEXApplicationData ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) data : Ctypes.char_star; (* INPUT *) numBytes : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXGse ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) id : Ctypes.unsigned_long; (* INPUT *) data : Ctypes.char_star; (* INPUT *) numBytes : Ctypes.int);
* Routines defined in pl_pc.c
<*EXTERNAL*> PROCEDURE PEXCreatePipelineContext ( (* INPUT *) display : X.DisplayStar; (* INPUT *) valueMask : Ctypes.unsigned_long_star; (* C version : INPUT unsigned long valueMask[2] *) (* INPUT *) values : pxlPCAttributesStar) : pxlPipelineContext; <*EXTERNAL*> PROCEDURE PEXFreePipelineContext ( (* INPUT *) display : X.DisplayStar; (* INPUT *) pc : pxlPipelineContext); <*EXTERNAL*> PROCEDURE PEXCopyPipelineContext ( (* INPUT *) display : X.DisplayStar; (* INPUT *) valueMask : Ctypes.unsigned_long_star; (* C version : INPUT unsigned long valueMask[2] *) (* INPUT *) srcPc : pxlPipelineContext; (* INPUT *) destPc : pxlPipelineContext); <*EXTERNAL*> PROCEDURE PEXGetPipelineContext ( (* INPUT *) display : X.DisplayStar; (* INPUT *) pc : pxlPipelineContext; (* INPUT *) valueMask : Ctypes.unsigned_long_star; (* version : INPUT unsigned long valueMask[2] *) (* OUTPUT *) pcAttributesReturn : pxlPCAttributesStarStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXChangePipelineContext ( (* INPUT *) display : X.DisplayStar; (* INPUT *) pc : pxlPipelineContext; (* INPUT *) valueMask : Ctypes.unsigned_long_star; (* C version : INPUT unsigned long valueMask[2] *) (* INPUT *) pcAttributes : pxlPCAttributesStar);
* Routines defined in pl_rdr.c
<*EXTERNAL*> PROCEDURE PEXCreateRenderer ( (* INPUT *) display : X.DisplayStar; (* INPUT *) d : X.Drawable; (* INPUT *) valueMask : Ctypes.unsigned_long; (* INPUT *) values : pxlRendererAttributesStar) : pxlRenderer; <*EXTERNAL*> PROCEDURE PEXFreeRenderer ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer); <*EXTERNAL*> PROCEDURE PEXGetRendererAttributes ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) valueMask : Ctypes.unsigned_long; (* OUTPUT *) valuesReturn : pxlRendererAttributesStarStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetRendererDynamics ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* OUTPUT *) tablesReturn : Ctypes.unsigned_long_star; (* OUTPUT *) namesetsReturn : Ctypes.unsigned_long_star; (* OUTPUT *) attributesReturn : Ctypes.unsigned_long_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXChangeRenderer ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) valueMask : Ctypes.unsigned_long; (* INPUT *) values : pxlRendererAttributesStar); <*EXTERNAL*> PROCEDURE PEXBeginRendering ( (* INPUT *) display : X.DisplayStar; (* INPUT *) d : X.Drawable; (* INPUT *) renderer : pxlRenderer); <*EXTERNAL*> PROCEDURE PEXEndRendering ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) flush : X.Bool); <*EXTERNAL*> PROCEDURE PEXBeginStructure ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) id : Ctypes.unsigned_long); <*EXTERNAL*> PROCEDURE PEXEndStructure ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer); <*EXTERNAL*> PROCEDURE PEXRenderNetwork ( (* INPUT *) display : X.DisplayStar; (* INPUT *) d : X.Drawable; (* INPUT *) renderer : pxlRenderer; (* INPUT *) structure : pxlStructure); <*EXTERNAL*> PROCEDURE MPEXBeginTransparencyRendering ( (* INPUT *) display : X.DisplayStar; (* INPUT *) d : X.Drawable; (* INPUT *) renderer : pxlRenderer; (* INPUT *) clear : Ctypes.int); <*EXTERNAL*> PROCEDURE MPEXEndTransparencyRendering ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) flush : X.Bool) : Ctypes.int;
* Routines defined in pl_startup.c
<*EXTERNAL*> PROCEDURE PEXInitialize ( (* INPUT *) display : X.DisplayStar; (* OUTPUT *) pexinfo : pxlInfoStarStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXTerminate ( (* INPUT *) display : X.DisplayStar; (* INPUT *) codes : X.XExtCodesStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetEnumTypeInfo ( (* INPUT *) display : X.DisplayStar; (* INPUT *) drawable : X.Drawable; (* INPUT *) enumType : Ctypes.int; (* INPUT *) returnMask : Ctypes.unsigned_long; (* OUTPUT *) enumInfoReturn : pxlEnumTypeDescListStarStar; (* OUTPUT *) countReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXSetFloatingPointFormat ( (* INPUT *) fpFormat : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXGetFloatingPointFormat () : Ctypes.int; <*EXTERNAL*> PROCEDURE PEXSetDirectColourFormat ( (* INPUT *) colourFormat : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXGetDirectColourFormat () : Ctypes.int; <*EXTERNAL*> PROCEDURE PEXSetColourType ( (* INPUT *) colourType : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXGetColourType () : Ctypes.int; <*EXTERNAL*> PROCEDURE PEXGetImpDepConstants ( (* INPUT *) display : X.DisplayStar; (* INPUT *) drawable : X.Drawable; (* INPUT *) names : Ctypes.short_star; (* INPUT *) count : Ctypes.int; (* OUTPUT *) valuesReturn : Ctypes.unsigned_long_star) : X.Status;
* Routines defined in pl_struct.c
<*EXTERNAL*> PROCEDURE PEXCreateStructure ( (* INPUT *) display : X.DisplayStar) : pxlStructure; <*EXTERNAL*> PROCEDURE PEXDestroyStructures ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structures : pxlStructureStar; (* INPUT *) numStructures : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXCopyStructure ( (* INPUT *) display : X.DisplayStar; (* INPUT *) srcStructure : pxlStructure; (* INPUT *) destStructure : pxlStructure); <*EXTERNAL*> PROCEDURE PEXGetStructureInfo ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* OUTPUT *) structureInfoReturn : pxlStructureInformationStarStar ) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetElementInfo ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) whence1 : Ctypes.int; (* INPUT *) offset1 : Ctypes.long; (* INPUT *) whence2 : Ctypes.int; (* INPUT *) offset2 : Ctypes.long; (* OUTPUT *) elementInfoReturn : pxlElementInfoStarStar; (* OUTPUT *) numElementInfoReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetStructuresInNetwork ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) which : Ctypes.int; (* OUTPUT *) structuresReturn : pxlStructureStarStar; (* OUTPUT *) numStructuresReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetAncestors ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) pathOrder : Ctypes.int; (* INPUT *) pathDepth : Ctypes.int; (* OUTPUT *) pathsReturn : pxlStructurePathStarStar; (* OUTPUT *) numPathsReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXGetDescendants ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) pathOrder : Ctypes.int; (* INPUT *) pathDepth : Ctypes.int; (* OUTPUT *) pathsReturn : pxlStructurePathStarStar; (* OUTPUT *) numPathsReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXFetchElements ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) whence1 : Ctypes.int; (* INPUT *) offset1 : Ctypes.long; (* INPUT *) whence2 : Ctypes.int; (* INPUT *) offset2 : Ctypes.long; (* OUTPUT *) ocbufReturn : pxlOCBufStarStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXSetEditingMode ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) mode : Ctypes.int); <*EXTERNAL*> PROCEDURE PEXSetElementPtr ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) whence : Ctypes.int; (* INPUT *) offset : Ctypes.long); <*EXTERNAL*> PROCEDURE PEXSetElementPtrAtLabel ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) label : Ctypes.long; (* INPUT *) offset : Ctypes.long); <*EXTERNAL*> PROCEDURE PEXElementSearch ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) whence : Ctypes.int; (* INPUT *) offset : Ctypes.long; (* INPUT *) direction : Ctypes.int; (* INPUT *) inclList : Ctypes.short_star; (* INPUT *) numIncl : Ctypes.int; (* INPUT *) exclList : Ctypes.short_star; (* INPUT *) numExcl : Ctypes.int; (* OUTPUT *) statusReturn : Ctypes.int_star; (* OUTPUT *) offsetReturn : Ctypes.unsigned_long_star) : X.Status; <*EXTERNAL*> PROCEDURE PEXDeleteElements ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) whence1 : Ctypes.int; (* INPUT *) offset1 : Ctypes.long; (* INPUT *) whence2 : Ctypes.int; (* INPUT *) offset2 : Ctypes.long); <*EXTERNAL*> PROCEDURE PEXDeleteToLabel ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) whence : Ctypes.int; (* INPUT *) offset : Ctypes.long; (* INPUT *) label : Ctypes.long); <*EXTERNAL*> PROCEDURE PEXDeleteBetweenLabels ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) label1 : Ctypes.long; (* INPUT *) label2 : Ctypes.long); <*EXTERNAL*> PROCEDURE PEXCopyElements ( (* INPUT *) display : X.DisplayStar; (* INPUT *) srcStructure : pxlStructure; (* INPUT *) srcWhence1 : Ctypes.int; (* INPUT *) srcOffset1 : Ctypes.long; (* INPUT *) srcWhence2 : Ctypes.int; (* INPUT *) srcOffset2 : Ctypes.long; (* INPUT *) destStructure : pxlStructure; (* INPUT *) destWhence : Ctypes.int; (* INPUT *) destOffset : Ctypes.long); <*EXTERNAL*> PROCEDURE PEXChangeStructureRefs ( (* INPUT *) display : X.DisplayStar; (* INPUT *) oldStructure : pxlStructure; (* INPUT *) newStructure : pxlStructure);
* Routines defined in pl_utl.c
<*EXTERNAL*> PROCEDURE PEXRotationMatrix ( (* INPUT *) axis : Ctypes.int; (* INPUT *) angle : Ctypes.double; (* OUTPUT *) matrixReturn : pxlMatrixStar) (* was pxlMatrix (C vs Modula-3 Array passing problem) *) : X.Status; <*EXTERNAL*> PROCEDURE PEXArbRotationMatrix ( (* INPUT *) pt1 : pxlCoord3DStar; (* INPUT *) pt2 : pxlCoord3DStar; (* INPUT *) angle : Ctypes.double; (* OUTPUT *) matrixReturn : pxlMatrixStar); (* was pxlMatrix (C vs Modula-3 Array passing problem) *) <*EXTERNAL*> PROCEDURE PEXScalingMatrix ( (* INPUT *) sx : Ctypes.double; (* INPUT *) sy : Ctypes.double; (* INPUT *) sz : Ctypes.double; (* OUTPUT *) matrixReturn : pxlMatrixStar); (* was pxlMatrix (C vs Modula-3 Array passing problem) *) <*EXTERNAL*> PROCEDURE PEXTranslationMatrix ( (* INPUT *) tx : Ctypes.double; (* INPUT *) ty : Ctypes.double; (* INPUT *) tz : Ctypes.double; (* OUTPUT *) matrixReturn : pxlMatrixStar); (* was pxlMatrix (C vs Modula-3 Array passing problem) *) <*EXTERNAL*> PROCEDURE PEXCopyMatrix ( (* INPUT *) matrix : pxlMatrixStar; (* OUTPUT *) matrixReturn : pxlMatrixStar); (* was pxlMatrix (C vs Modula-3 Array passing problem) *) <*EXTERNAL*> PROCEDURE PEXMultiplyMatrices ( (* INPUT *) mat1 : pxlMatrixStar; (* INPUT *) mat2 : pxlMatrixStar; (* OUTPUT *) matrixReturn : pxlMatrixStar); (* was pxlMatrix (C vs Modula-3 Array passing problem) *) <*EXTERNAL*> PROCEDURE PEXIdentityMatrix ( (* OUTPUT *) matrixReturn : pxlMatrixStar); (* was pxlMatrix (C vs Modula-3 Array passing problem) *) <*EXTERNAL*> PROCEDURE PEXInvertMatrix ( (* INPUT *) matrix : pxlMatrixStar; (* OUTPUT *) inverseReturn : pxlMatrixStar) (* was pxlMatrix (C vs Modula-3 Array passing problem) *) : X.Status; <*EXTERNAL*> PROCEDURE PEXTransform3dPoints ( (* INPUT *) mat : pxlMatrixStar; (* was pxlMatrix (C vs Modula-3 Array passing problem) *) (* INPUT *) pts : pxlCoord3DStar; (* INPUT *) numPts : Ctypes.int; (* OUTPUT *) ptsReturn : pxlCoord3DStar) : X.Status; <*EXTERNAL*> PROCEDURE PEXTransform4dPoints ( (* INPUT *) mat : pxlMatrixStar; (* was pxlMatrix (C vs Modula-3 Array passing problem) *) (* INPUT *) pts : pxlCoord4DStar; (* INPUT *) numPts : Ctypes.int; (* OUTPUT *) ptsReturn : pxlCoord4DStar); <*EXTERNAL*> PROCEDURE PEXLookatViewMatrix ( (* INPUT *) from : pxlCoord3DStar; (* INPUT *) to : pxlCoord3DStar; (* INPUT *) up : pxlVector3DStar; (* OUTPUT *) matReturn : pxlMatrixStar) (* was pxlMatrix (C vs Modula-3 Array passing problem) *) : X.Status; <*EXTERNAL*> PROCEDURE PEXPolarViewMatrix ( (* INPUT *) from : pxlCoord3DStar; (* INPUT *) distance : Ctypes.double; (* INPUT *) azimuth : Ctypes.double; (* INPUT *) altitude : Ctypes.double; (* INPUT *) twist : Ctypes.double; (* OUTPUT *) matReturn : pxlMatrixStar) (* was pxlMatrix (C vs Modula-3 Array passing problem) *) : X.Status; <*EXTERNAL*> PROCEDURE PEXOrthoProjMatrix ( (* INPUT *) height : Ctypes.double; (* INPUT *) aspect : Ctypes.double; (* INPUT *) near : Ctypes.double; (* INPUT *) far : Ctypes.double; (* OUTPUT *) matReturn : pxlMatrixStar) (* was pxlMatrix (C vs Modula-3 Array passing problem) *) : X.Status; <*EXTERNAL*> PROCEDURE PEXPerspProjMatrix ( (* INPUT *) fovy : Ctypes.double; (* INPUT *) distance : Ctypes.double; (* INPUT *) aspect : Ctypes.double; (* INPUT *) near : Ctypes.double; (* INPUT *) far : Ctypes.double; (* OUTPUT *) matReturn : pxlMatrixStar) (* was pxlMatrix (C vs Modula-3 Array passing problem) *) : X.Status; <*EXTERNAL*> PROCEDURE PEXComputeNormals ( (* INPUT *) method : Ctypes.int; (* INPUT *) primType : Ctypes.int; (* INPUT *) prim : Ctypes.char_star; (* OUTPUT *) primReturn : Ctypes.char_star);************** Translated up to here! **************
* Routines from pl_mpex.c
<*EXTERNAL*> PROCEDURE MPEXChangeNewRenderer ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) valueMask : Ctypes.unsigned_long; (* INPUT *) values : mpxlRendererAttributesStar); <*EXTERNAL*> PROCEDURE MPEXGetNewRendererAttributes ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) valueMask : Ctypes.unsigned_long; (* OUTPUT *) valuesReturn : mpxlRendererAttributesStarStar ) : X.Status; <*EXTERNAL*> PROCEDURE MPEXRenderElements ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) structure : pxlStructure; (* INPUT *) whence1 : Ctypes.int; (* INPUT *) offset1 : Ctypes.long; (* INPUT *) whence2 : Ctypes.int; (* INPUT *) offset2 : Ctypes.long); <*EXTERNAL*> PROCEDURE MPEXAccumulateState ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) elements : pxlElementRefStar; (* INPUT *) numElements : Ctypes.int); <*EXTERNAL*> PROCEDURE MPEXBeginPickOne ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) d : X.Drawable; (* INPUT *) id : Ctypes.unsigned_long; (* INPUT *) which : Ctypes.int); <*EXTERNAL*> PROCEDURE MPEXEndPickOne ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* OUTPUT *) elementsReturn : pxlPickPathStarStar; (* OUTPUT *) numElementsReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE MPEXPickOne ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) d : X.Drawable; (* INPUT *) structure : pxlStructure; (* INPUT *) which : Ctypes.int; (* OUTPUT *) elementsReturn : pxlPickPathStarStar; (* OUTPUT *) numElementsReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE MPEXBeginPickAll ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) d : X.Drawable; (* INPUT *) id : Ctypes.unsigned_long; (* INPUT *) sendEvent : X.Bool); <*EXTERNAL*> PROCEDURE MPEXEndPickAll ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* OUTPUT *) moreReturn : Ctypes.int_star; (* OUTPUT *) pathsReturn : mpxlPickAllPathStarStar; (* OUTPUT *) numPathsReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE MPEXPickAll ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) d : X.Drawable; (* OUTPUT *) moreReturn : Ctypes.int_star; (* OUTPUT *) pathsReturn : mpxlPickAllPathStarStar; (* OUTPUT *) numPathsReturn : Ctypes.int_star) : X.Status; <*EXTERNAL*> PROCEDURE MPEXCopyNewPipelineContext ( (* INPUT *) display : X.DisplayStar; (* INPUT *) valueMask : Ctypes.unsigned_long; (* INPUT *) srcPc : pxlPipelineContext; (* INPUT *) destPc : pxlPipelineContext); <*EXTERNAL*> PROCEDURE MPEXGetNewPipelineContext ( (* INPUT *) display : X.DisplayStar; (* INPUT *) pc : pxlPipelineContext; (* INPUT *) valueMask : Ctypes.unsigned_long; (* OUTPUT *) npcAttributesReturn : mpxlPCAttributesStarStar ) : X.Status; <*EXTERNAL*> PROCEDURE MPEXChangeNewPipelineContext ( (* INPUT *) display : X.DisplayStar; (* INPUT *) pc : pxlPipelineContext; (* INPUT *) valueMask : Ctypes.unsigned_long; (* INPUT *) npcAttributes : mpxlPCAttributesStar); <*EXTERNAL*> PROCEDURE MPEXSetHighlightIndex ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE MPEXSetEchoIndex ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE MPEXSetElementPtrAtPickID ( (* INPUT *) display : X.DisplayStar; (* INPUT *) structure : pxlStructure; (* INPUT *) id : Ctypes.unsigned_long; (* INPUT *) offset : Ctypes.long); <*EXTERNAL*> PROCEDURE MPEXNoop ( (* INPUT *) ocbuf : pxlOCBufStar); <*EXTERNAL*> PROCEDURE MPEXSetAnnotationTextSkew ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) skew : Ctypes.float); <*EXTERNAL*> PROCEDURE MPEXSetTextSkew ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) skew : Ctypes.float); <*EXTERNAL*> PROCEDURE MPEXCircle ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) center : pxlCoord3DStar; (* INPUT *) radius : Ctypes.double); <*EXTERNAL*> PROCEDURE MPEXArc ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) center : pxlCoord3DStar; (* INPUT *) radius : Ctypes.double; (* INPUT *) startAngle : Ctypes.double; (* INPUT *) endAngle : Ctypes.double); <*EXTERNAL*> PROCEDURE MPEXEllipticalArc2D ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) center : pxlCoord2DStar; (* INPUT *) majorAxis : pxlCoord2DStar; (* INPUT *) minorAxis : pxlCoord2DStar; (* INPUT *) startAngle : Ctypes.double; (* INPUT *) endAngle : Ctypes.double); <*EXTERNAL*> PROCEDURE MPEXEllipticalArc3D ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) center : pxlCoord3DStar; (* INPUT *) majorAxis : pxlCoord3DStar; (* INPUT *) minorAxis : pxlCoord3DStar; (* INPUT *) startAngle : Ctypes.double; (* INPUT *) endAngle : Ctypes.double); <*EXTERNAL*> PROCEDURE MPEXEllipse2D ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) center : pxlCoord2DStar; (* INPUT *) majorAxis : pxlCoord2DStar; (* INPUT *) minorAxis : pxlCoord2DStar); <*EXTERNAL*> PROCEDURE MPEXEllipse3D ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) center : pxlCoord3DStar; (* INPUT *) majorAxis : pxlCoord3DStar; (* INPUT *) minorAxis : pxlCoord3DStar); <*EXTERNAL*> PROCEDURE MPEXIndexedPolygons ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) shape : Ctypes.int; (* INPUT *) facetAttributes : Ctypes.unsigned_long; (* INPUT *) edgeAttributes : Ctypes.unsigned_long; (* INPUT *) vertexAttributes : Ctypes.unsigned_long; (* INPUT *) numFacets : Ctypes.int; (* INPUT *) numEdges : Ctypes.int; (* INPUT *) numVertices : Ctypes.int; (* INPUT *) facetCounts : Ctypes.unsigned_short_star; (* INPUT *) facetOptData : Ctypes.unsigned_char_star; (* INPUT *) edges : Ctypes.unsigned_char_star; (* INPUT *) vertices : Ctypes.unsigned_char_star); <*EXTERNAL*> PROCEDURE MPEXGridRectangular ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord3DStar; (* INPUT *) xdist : Ctypes.float; (* INPUT *) ydist : Ctypes.float); <*EXTERNAL*> PROCEDURE MPEXGridRadial ( (* IN-OUT *) ocbuf : pxlOCBufStar; (* INPUT *) center : pxlCoord3DStar; (* INPUT *) startAngle : Ctypes.float; (* INPUT *) endAngle : Ctypes.float; (* INPUT *) angDist : Ctypes.float; (* INPUT *) radDist : Ctypes.float); <*EXTERNAL*> PROCEDURE MPEXReferToStructure ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) structure : pxlStructure); <*EXTERNAL*> PROCEDURE MPEXAnnotationPixmap ( (* INPUT *) ocbuf : pxlOCBufStar; (* INPUT *) origin : pxlCoord3DStar; (* INPUT *) index : Ctypes.int); <*EXTERNAL*> PROCEDURE MPEXSetDashPattern ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) patternNumber : Ctypes.int; (* INPUT *) pattern : Ctypes.unsigned_long); <*EXTERNAL*> PROCEDURE MPEXGetDashPattern ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) patternNumber : Ctypes.int; (* OUTPUT *) pattern : Ctypes.unsigned_long_star ) : X.Status; <*EXTERNAL*> PROCEDURE MPEXSetMarkerGlyph ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) glyphNumber : Ctypes.int; (* INPUT *) glyph : Ctypes.unsigned_short_star; (* in C: unsigned short glyph[16] *) (* INPUT *) xOffset : Ctypes.int; (* INPUT *) yOffset : Ctypes.int); <*EXTERNAL*> PROCEDURE MPEXGetMarkerGlyph ( (* INPUT *) display : X.DisplayStar; (* INPUT *) renderer : pxlRenderer; (* INPUT *) glyphNumber : Ctypes.int; (* OUTPUT *) glyph : Ctypes.unsigned_short_star; (* in C: unsigned short glyph[16] *) (* OUTPUT *) xOffset : Ctypes.int_star; (* OUTPUT *) yOffset : Ctypes.int_star) : X.Status;
* Routines from pl_oc_parse.c
* <*EXTERNAL*> PROCEDURE PEXDumpOCBufHeader ( * (* IN-OUT
oc : pxlOCBufStar; * (* IN-OUT *) output_file : UNTRACED REF Cstdio.iobuf); * (* was in C: FILE * output_file *) *) <*EXTERNAL*> PROCEDURE PEXGetOCListsFromOCBuf ( (* IN-OUT *) oc : pxlOCBufStar; (* INPUT *) routine : PROCEDURE (); (* INPUT *) arg : Ctypes.unsigned_long);
* Routines defined in pl_sc.c
<*EXTERNAL*> PROCEDURE PEXCreateSearchContext ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ Ctypes.unsigned_long valueMask, * /* INPUT */ pxlSCAttributesStar values * ) : pxlSearchContext; * * <*EXTERNAL*> PROCEDURE PEXFreeSearchContext ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlSearchContext sc * ); * * <*EXTERNAL*> PROCEDURE PEXCopySearchContext ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ Ctypes.unsigned_long valueMask, * /* INPUT */ pxlSearchContext srcSc, * /* INPUT */ pxlSearchContext destSc * ); * * <*EXTERNAL*> PROCEDURE PEXGetSearchContext ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlSearchContext sc, * /* INPUT */ Ctypes.unsigned_long valueMask, * /* OUTPUT */ pxlSCAttributesStarStar scAttributesReturn * ) : X.Status; * * <*EXTERNAL*> PROCEDURE PEXChangeSearchContext ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlSearchContext sc, * /* INPUT */ Ctypes.unsigned_long valueMask, * /* OUTPUT */ pxlSCAttributesStar values * ); * * <*EXTERNAL*> PROCEDURE PEXSearchNetwork ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlSearchContext sc, * /* OUTPUT */ pxlStructurePathStarStar pathReturn * ) : X.Status; * * /* * * Routined defined in pl_wks.c * */ * * <*EXTERNAL*> PROCEDURE PEXCreatePhigsWks ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ Drawable d, * /* INPUT */ pxlLookupTable lineBundle, * /* INPUT */ pxlLookupTable markerBundle, * /* INPUT */ pxlLookupTable textBundle, * /* INPUT */ pxlLookupTable interiorBundle, * /* INPUT */ pxlLookupTable edgeBundle, * /* INPUT */ pxlLookupTable colourTable, * /* INPUT */ pxlLookupTable patternTable, * /* INPUT */ pxlLookupTable textFontTable, * /* INPUT */ pxlLookupTable depthCueTable, * /* INPUT */ pxlLookupTable lightTable, * /* INPUT */ pxlLookupTable colourApproxTable, * /* INPUT */ pxlNameSet highlightIncl, * /* INPUT */ pxlNameSet highlightExcl, * /* INPUT */ pxlNameSet invisibilityIncl, * /* INPUT */ pxlNameSet invisibilityExcl * ) : pxlPhigsWks; * * <*EXTERNAL*> PROCEDURE PEXFreePhigsWks ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks * ); * * <*EXTERNAL*> PROCEDURE PEXGetWksInfo ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ Ctypes.unsigned_long valueMask, * /* OUTPUT */ pxlPhigsWksInfoStarStar wksAttributesReturn * ) : X.Status; * * <*EXTERNAL*> PROCEDURE PEXGetWksDynamics ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ Drawable d, * /* OUTPUT */ pxlPhigsWksDynamicsStarStar wksDynamicsReturn * ) : X.Status; * * <*EXTERNAL*> PROCEDURE PEXGetWksViewRep ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ Ctypes.UnsignedInt index, * /* OUTPUT */ Ctypes.int_star viewUpdateReturn, * /* OUTPUT */ pxlViewEntryStarStar reqViewReturn, * /* OUTPUT */ pxlViewEntryStarStar curViewReturn * ) : X.Status; * * <*EXTERNAL*> PROCEDURE PEXGetWksPostings ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlStructure structure, * /* OUTPUT */ pxlPhigsWksStarStar wksReturn * ) : X.Status; * * <*EXTERNAL*> PROCEDURE PEXSetWksViewPriority ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ Ctypes.UnsignedInt index1, * /* INPUT */ Ctypes.UnsignedInt index2, * /* INPUT */ Ctypes.int priority * ); * * <*EXTERNAL*> PROCEDURE PEXSetWksDrawableUpdate ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ Ctypes.int drawableUpdate * ); * * <*EXTERNAL*> PROCEDURE PEXSetWksViewRep ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ Ctypes.UnsignedInt viewIndex, * /* INPUT */ pxlViewEntryStar viewRep * ); * * <*EXTERNAL*> PROCEDURE PEXSetWksNpcSubvolume ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ pxlNpcSubvolumeStar npcSubvolume * ); * * <*EXTERNAL*> PROCEDURE PEXSetWksViewport ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ pxlViewportStar viewport * ); * * <*EXTERNAL*> PROCEDURE PEXSetWksHlhsrMode ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ Ctypes.UnsignedInt hlhsrMode * ); * * <*EXTERNAL*> PROCEDURE PEXRedrawStructures ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks * ); * * <*EXTERNAL*> PROCEDURE PEXUpdatePhigsWks ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks * ); * * <*EXTERNAL*> PROCEDURE PEXExecuteDeferredActions ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks * ); * * <*EXTERNAL*> PROCEDURE PEXMapDCtoWC ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ pxlDeviceCoordStar dcPoints, * /* INPUT */ Ctypes.int numPoints, * /* OUTPUT */ pxlCoord3DStar wcPointsReturn, * /* OUTPUT */ Ctypes.unsigned_int_star viewIndexReturn * ); * * <*EXTERNAL*> PROCEDURE PEXMapWCtoDC ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ pxlCoord3DStar wcPoints, * /* INPUT */ Ctypes.int numPoints, * /* INPUT */ Ctypes.UnsignedInt viewIndex, * /* OUTPUT */ pxlDeviceCoordStar dcPointsReturn * ); * * <*EXTERNAL*> PROCEDURE PEXPostStructure ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ pxlStructure structure, * /* INPUT */ Ctypes.unsigned_long priority * ); * * <*EXTERNAL*> PROCEDURE PEXUnpostStructure ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks, * /* INPUT */ pxlStructure structure * ); * * <*EXTERNAL*> PROCEDURE PEXUnpostAllStructures ( * /* INPUT */ X.DisplayStar display, * /* INPUT */ pxlPhigsWks wks * );
*************************************************************************** Based on PEXocbuf.h Everything included, but not everything translated yet! ***************************************************************************
* typedefs for referencing fields in oc requests
typedef struct pexRequestHeader * { * unsigned char extOpcode; * unsigned char pexOpcode; * unsigned short reqLength; * } pexRequestHeader; * * typedef struct pexOCRequestHeader * { * unsigned char extOpcode; * unsigned char pexOpcode; * unsigned short reqLength; * unsigned short fpFormat; * unsigned short pad; * unsigned long target; * unsigned long numCommands; * } pexOCRequestHeader; * * typedef pexElementInfo pexOCListHeader; * * typedef struct pexOCcListHeader * { * pexElementInfo head; * unsigned short length; * unsigned short pad; * } pexOCcListHeader; * * * #define STORE_ELEMENT_INFO(_reqPtr_,_ocType_,_ocLength_) \ * { \ * ((pexElementInfo * )(_reqPtr_))->elementType = (_ocType_); \ * ((pexElementInfo * )(_reqPtr_))->length = (_ocLength_); \ * }
PROCEDURE PEXAllocateOCBuffer(display : X.DisplayStar; type : Ctypes.int; target : X.XID; bufTyp : PROCEDURE () : Ctypes.int; errorFn : ErrorFunctionType; initSize: Ctypes.int) : pxlOCBufStar;
* NAME:
* PEXDeallocateOCBuffer
*
* FORMAT:
* void PEXDeallocateOCBuffer( ocbuf)
* pxlOCBuf *ocbuf;
*
* ARGUMENTS:
* ocbuf The OC buffer to be deallocated.
*
* RETURNS:
* None
*
* DESCRIPTION:
* This routine frees all memory for the oc buffer
* specified by `ocbuf'.
*
* NOTE: This is the only proper way to deallocate an OC buffer.
* Do not use the `PEXFree
* #define PEXDeallocateOCBuffer(_ocbuf_) ( *(_ocbuf_)->FreeOCBuf)(_ocbuf_)
* NAME:
* PEXClearOCBuffer
*
* FORMAT:
* void PEXClearOCBuffer( ocbuf)
* pxlOCBuf *ocbuf;
*
* ARGUMENTS:
* ocbuf The OC buffer to be emptied
*
* RETURNS:
* None
*
* DESCRIPTION:
* This routine empties all ocs in the oc buffer. If the oc
* buffer is retained then all the ocs currently stored in the buffer
* will be deleted. If the oc buffer is transient then the next
* oc will start a new request in the transport buffer.
*
* ERRORS:
* None
*
* SEE ALSO:
* `PEXAllocateRetainedOCBuffer
* #define PEXClearOCBuffer(_ocbuf_) ( *(_ocbuf_)->ClearOCBuf)(_ocbuf_)
* NAME:
* PEXSetOCBufferType
*
* FORMAT:
* void PEXSetOCBufferType (display, ocbuf, type, target)
* Display *display;
* pxlOCBuf *ocbuf;
* int type;
* XID target;
*
* ARGUMENTS:
* display A pointer to a display structure
* returned by a successful `XOpenDisplay
* #define PEXSetOCBufferType(_display_, _ocbuf_, _type_, _target_) \
* ( *(_ocbuf_)->SetOCBufType)(_display_,_ocbuf_,_type_,_target_)
* NAME:
* PEXSetOCBufferTarget
*
* FORMAT:
* void PEXSetOCBufferTarget (ocbuf, target)
* pxlOCBuf *ocbuf;
* XID target;
*
* ARGUMENTS:
* ocbuf The OC buffer whose attributes are
* to be modified.
*
* target The resource identifier of the renderer or structure
* used as a target for the output commands
*
* RETURNS:
* None
*
* DESCRIPTION:
* Change the target associated with the oc buffer.
*
* `Target' defines the destination for the output commands.
* If the buffer type is `pxlRenderImmediate', `target' is the resource
* identifier of the renderer to which the output commands will be sent.
* If the buffer type is `pxlAddToStructure', `target' is the resource
* identifier of the structure to which the output commands will be sent.
*
* For retained oc buffers this routine will modify the target
* associated with the output commands currently stored in the oc
* buffer. For transient oc buffers this routine will modify the
* target of subsequent output commands. This routine will `not`
* flush the current contents of `ocbuf'.
*
* ERRORS:
* None
*
* SEE ALSO:
* `PEXAllocateRetainedOCBuffer
* #define PEXSetOCBufferTarget(_ocbuf_, _target_) \
* ( *(_ocbuf_)->SetOCBufTarget)(_ocbuf_,_target_)
* NAME:
* PEXGetOCBufferType
*
* FORMAT:
* void PEXGetOCBufferType (ocbuf, displayReturn, typeReturn, targetReturn)
* pxlOCBuf *ocbuf;
* Display **displayReturn;
* int *typeReturn;
* XID *targetReturn;
*
* ARGUMENTS:
* ocbuf The OC buffer to be queried.
*
* displayReturn Returns a pointer to the display structure used
* when the OC buffer is flushed or sent.
*
* typeReturn Returns the type of the OC buffer.
*
* targetReturn Returns the resource identifier of the OC buffer target
* renderer or structure
*
* RETURNS:
* None
*
* DESCRIPTION:
* This routine returns attributes of `ocbuf' that can be altered.
*
* `DisplayReturn' returns a pointer to information
* about the connection over which the output commands are sent.
*
* `typeReturn' returns the OC buffer type.
*
* `targetReturn' returns the resource identifier of the target resource
* for the output commands in `ocbuf'. The resource identifier is
* either a renderer or a structure resource identifier, depending on
* the OC buffer type.
*
* ERRORS:
* None
*
* SEE ALSO:
* `PEXAllocateRetainedOCBuffer
* #define PEXGetOCBufferType(_ocbuf_,_displayReturn_,_typeReturn_,_targetReturn_)\
* ( *(_ocbuf_)->GetOCBufType)(_ocbuf_,_displayReturn_,_typeReturn_,_targetReturn_)
* NAME:
* PEXGetOCBufferFreeSpace
*
* FORMAT:
* int PEXGetOCBufferFreeSpace (ocbuf)
* pxlOCBuf *ocbuf;
*
* ARGUMENTS:
* ocbuf The OC buffer to be queried.
*
* RETURNS:
* See description.
*
* DESCRIPTION:
* This routine returns the free space (in words) remaining in the output
* command buffer pointed to by `ocbuf'.
*
* ERRORS:
* None
*
* SEE ALSO:
* `PEXAllocateRetainedOCBuffer
* #define PEXGetOCBufferFreeSpace(_ocbuf_) \
* ( *(_ocbuf_)->GetOCBufFreeSpace)(_ocbuf_)
* NAME:
* PEXGetMaxOCChunkSize
*
* FORMAT:
* int PEXGetMaxOCChunkSize (ocbuf)
* pxlOCBuf *ocbuf;
*
* ARGUMENTS:
* ocbuf The OC buffer to be queried.
*
* RETURNS:
* See description.
*
* DESCRIPTION:
* This routine returns the maximum number of words which can be
* reserved via PEXGetOCWords. Note that the size may change if the
* display is changed (ie: if `PEXSetOCBufferType
* #define PEXGetMaxOCChunkSize(_ocbuf_) ( *(_ocbuf_)->GetMaxOCChunkSize)(_ocbuf_)
***************************************************************************
Based on MPEX.h
***************************************************************************
* /* Definitions for Digital Pick/Echo/Z PEX extension likely to be used by
* applications */
*
* #define MPEX_REQ 0x00000080 /* reqType is CARD8 */
* #define MPEX_EVENT 0x00000000 /* offset from base event num from XInitExt */
* #define MPEX_OC 0x00008000 /* elementType is CARD16 */
* #define MPEX_ENUM 0x00008000 /* enum types are CARD16 */
* #define MPEX_TABLE 0x00008000 /* pexTableType is CARD16 */
*
* /*** Enumerated Types ***/
* #define MPEXETHighlightMethod (MPEX_ENUM+0)
* #define MPEXETEchoMethod (MPEX_ENUM+1)
* #define MPEXETOverlapMode (MPEX_ENUM+2)
* #define MPEXETLogicalOp (MPEX_ENUM+3)
*
* #define FirstMPEXEnumType (MPEX_ENUM+0)
* #define LastMPEXEnumType (MPEX_ENUM+3)
*
* /*** MPEXHighlightLUT and Echo Methods ***/
* #define MPEXChangeAllColors 0
* #define MPEXChangeEdgeColor 1
* #define MPEXChangeInteriorColor 2
*
* /*** additional Hlhsr mode ***/
* #define MPEXHlhsrZBufferId -2
*
* /*** Overlap Mode Values ***/
* #define MPEXAnyPrim 0
* #define MPEXFirstPrim 1
* #define MPEXLastPrim 2
*
* /*** Logical Operations ***/
* #define MPEXOpClear 0x0
* #define MPEXOpAnd 0x1
* #define MPEXOpAndReverse 0x2
* #define MPEXOpCopy 0x3
* #define MPEXOpAndInverted 0x4
* #define MPEXOpNoop 0x5
* #define MPEXOpXor 0x6
* #define MPEXOpOr 0x7
* #define MPEXOpNor 0x8
* #define MPEXOpEquiv 0x9
* #define MPEXOpInvert 0xA
* #define MPEXOpOrReverse 0xB
* #define MPEXOpCopyInverted 0xC
* #define MPEXOpOrInverted 0xD
* #define MPEXOpNand 0xE
* #define MPEXOpSet 0xF
*
* /*** Lookup Table Types ***/
* #define MPEXHighlightLUT (MPEX_TABLE+0)
* #define MPEXEchoLUT (MPEX_TABLE+1)
* #define MPEXPixmapLUT (MPEX_TABLE+2)
* #define MPEXTextureLUT (MPEX_TABLE+3)
*
* #define maxMPEXTableType (MPEX_TABLE+4)
* #define FirstMPEXTableType (MPEX_TABLE+0)
* #define LastMPEXTableType (MPEX_TABLE+3)
*
* /*** Renderer State ***/
* #define MPEXPicking 2
* #define MPEXTransparencyOpaque 3
* #define MPEXTransparency 4
*
* /*** Which Element to Pick ***/
* #define MPEXPickClosest 0
* #define MPEXPickLast 1
*
* /*** Values for ** Bit Numbers for Change/GetNewRendererAttributes **
***************************************************************************
Based on MPEXlib.h
***************************************************************************
* #ifndef MPEX_H
* # include
* Following are the typedefs used in the PEXlib interface. mpxlFooBar
* definitions are always supersets of the mpexFooBar protocol definitions.
* Note that most mpxlFooBar definitions are equivalent to the mpexFooBar
* protocol definitions. However, some of the definitions do have extra
* fields. See documentation in PEXlib.h for more details.
* Definitions for output commands
* Definitions for lookup table entries
* pick path returned by pick all
* Definition for MPEX Pipeline Context Attributes. Defines are in MPEX.h.
* #define MPEX_SetPCAttrMaskBit(mask, attrNum) \
* mask |= 1L << ( ((attrNum)) & 0x1F)
* Definition for MPEX Renderer Attributes. Defines are in MPEX.h.
The first several items in each event structure must be as they are or
toolkits will break
typedef struct mpxlMaxHitsReachedEvent
* {
* int type; /* type of event, MPEXMaxHitsReached */
* unsigned long serial; /* # of last req processed by server */
* Bool send_event; /* True if came from SendEvent req */
* Display *display; /* Display the event was read from */
* pxlRenderer rdr; /* renderer doing the pick */
* } mpxlMaxHitsReachedEvent;
* From MPEXproto.h
Definitions for Digital Pick/PEXEcho/Z PEX extension used by the server and
C bindings
***************************************************************
* REPLIES *
***************************************************************
* typedef struct
* {
* BYTE type; /* X_Reply */
* CARD8 what;
* CARD16 sequenceNumber B16;
* CARD32 length B32; /* not 0 */
* BYTE pad[24];
* /* SINGLE NewRendererAttributes(itemMask) */
* } mpexGetNewRendererAttributesReply;
*
* typedef struct
* {
* BYTE type; /* X_Reply */
* CARD8 what;
* CARD16 sequenceNumber B16;
* CARD32 length B32; /* not 0 */
* CARD32 numRefs B32;
* BYTE pad[20];
* /* LISTof PickElementRef(numRefs) */
* } mpexEndPickOneReply;
*
* typedef mpexEndPickOneReply mpexPickOneReply;
*
* typedef struct
* {
* BYTE type; /* X_Reply */
* CARD8 what;
* CARD16 sequenceNumber B16;
* CARD32 length B32; /* not 0 */
* CARD32 numPicks B32;
* CARD8 morePicks;
* BYTE pad[19];
* /* LISTof CLISTof PickElementRef(numPicks) */
* } mpexEndPickAllReply;
*
* typedef mpexEndPickAllReply mpexPickAllReply;
*
* typedef struct
* {
* BYTE type; /* X_Reply */
* CARD8 what;
* CARD16 sequenceNumber B16;
* CARD32 length B32; /* 0 */
* CARD32 pattern B32;
* BYTE pad[20];
* } mpexGetDashPatternReply;
*
* typedef struct
* {
* BYTE type; /* X_Reply */
* CARD8 what;
* CARD16 sequenceNumber B16;
* CARD32 length B32; /* not 0 */
* INT16 xOffset B16;
* INT16 yOffset B16;
* BYTE pad[20];
* CARD16 glyph[16];
* } mpexGetMarkerGlyphReply;
*
*
* typedef struct
* {
* BYTE type; /* X_Reply */
* CARD8 what;
* CARD16 sequenceNumber B16;
* CARD32 length B32; /* 0 */
* BYTE requireAnotherPass;
* BYTE pad[23];
* } mpexEndTransparencyRenderingReply;
*
*
* /****************************************************************
* * EVENTS *
* ****************************************************************/
*
* typedef struct
* {
* BYTE type;
* BYTE detail;
* CARD16 sequenceNumber B16;
* pexRenderer rdr B32;
* BYTE pad[24];
* } mpexMaxHitsReachedEvent;
*
* /****************************************************************
* * REQUESTS *
* ****************************************************************/
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexEnumTypeIndex fpFormat B16;
* CARD16 pad B16;
* pexRenderer rdr B32;
* pexBitmask itemMask B32;
* /* SINGLE NewRendererAttributes(itemMask) */
* } mpexChangeNewRendererReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexEnumTypeIndex fpFormat B16;
* CARD16 pad B16;
* pexRenderer rdr B32;
* pexBitmask itemMask B32;
* } mpexGetNewRendererAttributesReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* pexStructure sid B32;
* pexElementRange range;
* } mpexRenderElementsReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* CARD32 numRefs B32;
* /* LISTof ElementRef(numRefs) */
* } mpexAccumulateStateReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* Drawable drawable B32;
* CARD32 id B32;
* CARD8 which;
* BYTE pad[3];
* } mpexBeginPickOneReq;
*
* typedef pexResourceReq mpexEndPickOneReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* Drawable drawable B32;
* pexStructure sid B32;
* CARD8 which;
* BYTE pad[3];
* } mpexPickOneReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* Drawable drawable B32;
* unsigned long id B32;
* CARD8 sendEvent;
* BYTE pad[3];
* } mpexBeginPickAllReq;
*
* typedef pexResourceReq mpexEndPickAllReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* Drawable drawable B32;
* } mpexPickAllReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexStructure str B32;
* CARD32 pickid B32;
* INT32 offset B32;
* } mpexSetElementPointerAtPickIdReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* INT16 patternNum B16;
* CARD16 pad B16;
* CARD32 pattern B32;
* } mpexSetDashPatternReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* INT16 patternNum B16;
* CARD16 pad B16;
* } mpexGetDashPatternReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* INT16 glyphNum B16;
* CARD16 pad B16;
* INT16 xOffset B16;
* INT16 yOffset B16;
* CARD16 glyph[16];
* } mpexSetMarkerGlyphReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* INT16 glyphNum B16;
* CARD16 pad B16;
* } mpexGetMarkerGlyphReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* CARD16 sequenceNum B16;
* CARD16 totalNum B16;
* CARD32 totalLength B32;
* } mpexLargeRequestReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* Drawable drawable B32;
* CARD8 firstPass;
* BYTE pad[3];
* } mpexBeginTransparencyRenderingReq;
*
* typedef struct
* {
* CARD8 reqType;
* CARD8 opcode;
* CARD16 length B16;
* pexRenderer rdr B32;
* pexSwitch flushFlag;
* BYTE pad[3];
* } mpexEndTransparencyRenderingReq;
****************************************************************
* Output Commands
****************************************************************
* From MPEXprotostr.h
Definitions for Digital Pick/Echo/Z PEX extension likely to be used by
applications
Typedefs for lookup tables
command to deallocate OC buffers.
*
* ERRORS:
* None
*
* SEE ALSO:
* `PEXAllocateRetainedOCBuffer
, `PEXAllocateTransientOCBuffer
, `PEXAllocateTransientOCBuffer
call.
*
* ocbuf The OC buffer whose attributes are
* to be modified.
*
* type The type of OC buffer.
*
* target The resource identifier of the renderer or structure
* used as a target for the output commands
*
* RETURNS:
* None
*
* DESCRIPTION:
* Change the display, target and type associated with the oc buffer.
*
* If `type' is `pxlRenderImmediate', requests that pass output commands to
* a renderer are created.
* If `type' is `pxlAddToStructure', requests that pass output commands to
* a structure are created.
* The `PEXlib.h' include file contains definitions of these constants.
*
* `Target' defines the destination for the output commands.
* If the buffer type is `pxlRenderImmediate', `target' is the resource
* identifier of the renderer to which the output commands will be sent.
* If the buffer type is `pxlAddToStructure', `target' is the resource
* identifier of the structure to which the output commands will be sent.
*
* This routine will flush the current contents of `ocbuf'.
*
* ERRORS:
* None
*
* SEE ALSO:
* `PEXAllocateRetainedOCBuffer
, `PEXAllocateTransientOCBuffer,
* `PEXGetOCBufferType
, `PEXCreateRenderer, `PEXCreateStructure
*
, `PEXAllocateTransientOCBuffer
,
* `PEXGetOCBufferType, `PEXCreateRenderer
, `PEXCreateStructure
*
, `PEXAllocateTransientOCBuffer,
* `PEXSetOCBufferType
, `PEXCreateRenderer, `PEXCreateStructure
*
, `PEXAllocateTransientOCBuffer
*
is called)
*
* ERRORS:
* None
*
* SEE ALSO:
* `PEXAllocateRetainedOCBuffer
, `PEXAllocateTransientOCBuffer
* `PEXGetOCWords
, `PEXSetOCBufferType
*
PROCEDURE PEXFlushOCBuffer (ocbuf : pxlOCBufStar);
PROCEDURE PEXSendOCBuffer (ocbuf : pxlOCBufStar);
/*+
* * NAME:
* * INIT_OC
* *
* * DESCRIPTION:
* * Macro to start an oc. Calls PEXInitOC.
* */
* #define INIT_OC(_ocbuf_,_ocType_,_ocDataLength_,_pReq_) \
* PEXInitOC(_ocbuf_,OC/**/_ocType_,LENOF( pex/**/_ocType_),_ocDataLength_,\
* &(_pReq_))
*
* /*+
* * NAME:
* * PEXFinishOC
* *
* * FORMAT:
* * void PEXFinishOC (ocbuf)
* * pxlOCBuf *ocbuf;
* *
* * ARGUMENTS:
* * ocbuf The OC buffer to which the oc was sent
* *
* * RETURNS:
* * None
* *
* * DESCRIPTION:
* * Called after all the data for the oc has been sent.
* * `PEXCopyBytesToOC, `PEXCopyWordsToOC
or `PEXGetOCWords may be
* * called between `PEXInitOC
and `PEXFinishOC pairs. Note that
* * calling `PEXFinishOC
without first calling `PEXInitOC successfully
* * can have severe consequences since pexlib does not check for this.
* *
* * ERRORS:
* * None
* *
* * SEE ALSO:
* * `PEXGetOCWords
,`PEXCopyWordsToOC,`PEXCopyBytesToOC
* * `PEXInitOC,`PEXSendOCBuffer
,`PEXFlushOCBuffer
* */
* #define PEXFinishOC(_ocbuf_) ( *(_ocbuf_)->FinishOC)( _ocbuf_)
*
* /*+
* * NAME:
* * PEXStoreOCList
* *
* * FORMAT:
* * void PEXStoreOCList (ocbuf, numElements, ocList)
* * pxlOCBuf *ocbuf;
* * int numElements;
* * pxlElementInfo *ocList;
* *
* * ARGUMENTS:
* * ocbuf The OC buffer to store the ocs in
* * numElements The number of ocs to store
* * ocList list of ocs to store
* *
* * RETURNS:
* * None
* *
* * DESCRIPTION:
* * Copies the list of output commands to the specified oc buffer.
* * The registered error function will be called if a memory alloc
* * error occurs.
* *
* * ERRORS:
* * None
* *
* * SEE ALSO:
* * `PEXAllocateRetainedOCBuffer
, `PEXAllocateTransientOCBuffer,
* * `PEXSendOCBuffer
,`PEXFlushOCBuffer
* */
* #define PEXStoreOCList(_ocbuf_,_numElements_,_ocList_) \
* ( *(_ocbuf_)->StoreOCList)( _ocbuf_,_numElements_,_ocList_)
*
* #ifndef DEBUG
* /*+
* * NAME:
* * PEXGetOCWords
* *
* * FORMAT:
* * unsigned int *PEXGetOCWords (ocbuf, nWords)
* * pxlOCBuf *ocbuf;
* * int nWords;
* *
* * ARGUMENTS:
* * ocbuf The OC buffer to allocate words from.
* * nWords The number of words to reserve
* *
* * RETURNS:
* * Pointer to 'nWords' of data
* *
* * DESCRIPTION:
* * Return a pointer to 'nWords' of data located in the output command
* * which is currently in progress. 'PEXInitOC
must be called prior
* * to this. NULL will be returned if an attempt is made to grab more
* * words than were reserved when `PEXInitOC was called or if an attempt
* * is made to grab more words than specified in 'PEXGetMaxOCChunkSize
.
* *
* * The code below is implemented as a macro since it will be called
* * often and it is critical that it performs well. The basic
* * algorithm is
* *
* * if ( (A && B) || C )
* * return ( (curPtr += nWords) - nWords);
* * else
* * return NULL;
* *
* * where A =
* * (the words requested dont overflow the request which is being built)
* *
* * B =
* * (there is room in the current Xlib buffer) OR
* * (we can get room in the current Xlib buffer)
* *
* * C =
* * (the current request is a large request) AND
* * (the words requested dont overflow the large request) AND
* * (a new large request packet was successfully started )
* *
* *
* * ERRORS:
* * None
* *
* * SEE ALSO:
* * `PEXInitOC, `PEXFinishOC
* *
* */
* #define RoomInThisRequest(_oc_,_nWords_) \
* ( ((_oc_)->ocWordsLeft -= (_nWords_)) >= 0 )
*
* #define RoomInXBuffer(_oc_,_nWords_) \
* ( ((_nWords_) <= ((_oc_)->bufMax - (_oc_)->curPtr)) || \
* (( *(_oc_)->GetOCWords)((_oc_), (_nWords_))) )
*
* #define NewLargeRequestPacket(_oc_,_nWords_) \
* ( ((_oc_)->lrSequenceNum) && \
* (((_oc_)->lrBufferLeft -= (_nWords_)) >= 0) && \
* (((_oc_)->ocWordsLeft= ( *(_oc_)->StartLargeRequest)(_oc_)-(_nWords_)) >= 0) )
*
* #define PEXGetOCWords(_oc_,_nWords_) \
* ( (( RoomInThisRequest(_oc_,_nWords_) && RoomInXBuffer(_oc_,_nWords_) ) || \
* NewLargeRequestPacket(_oc_,_nWords_)) ? \
* (((_oc_)->curPtr += (_nWords_)) - (_nWords_)) \
* : \
* (NULL) )
* #endif /* DEBUG not defined */
*
* #ifndef DEBUG
* /*+
* * NAME:
* * PEXAddOC
* *
* * FORMAT:
* * void PEXAddOC (ocbuf, ocType, size, data)
* * pxlOCBuf *ocbuf;
* * unsigned int ocType;
* * int size;
* * char *data;
* *
* * ARGUMENTS:
* * ocbuf The OC buffer to which the output command
* * is to be added.
* *
* * ocType The type of output command to be added
* * to the OC buffer.
* *
* * size The size (in bytes) of the output command.
* *
* * data A pointer to the data for the output command.
* *
* * RETURNS:
* * None
* *
* * DESCRIPTION:
* * This routine adds an output command to `ocbuf'. The `ocType'
* * argument indicates the type of output command being passed.
* * The `PEX.h' include file contains possible values for `octype',
* * for example, `PEXOCMarkerType' and `PEXOCNurbCurve'.
* *
* * `Data' points to the actual data for the output command.
* *
* * `Size' specifies the length of `data' (in bytes).
* *
* * Client programs should call the individual output
* * command functions or use the output command macros
* * defined in `PEXoc.h' or `MPEXoc.h' instead of calling this routine
* * directly.
* *
* * ERRORS:
* * Renderer Specified renderer resource identifier is
* * invalid.
* *
* * Structure Specified structure resource identifier is
* * invalid.
* *
* * FloatingPointFormat Device does not support the specified floating
* * point format.
* *
* * OutputCommand A value in an output command is illegal,
* * out of range, or otherwise inappropriate.
* *
* * SEE ALSO:
* * `PEXAllocateRetainedOCBuffer, `PEXAllocateTransientOCBuffer
* *
* */
*
* #define PEXAddOC(_ocbuf_,_ocType_,_size_,_OCData_) \
* { \
* int _ocLength = ((_size_) + Pad(_size_) + sizeof(pexElementInfo))>>2;\
* if ( ( *(_ocbuf_)->StartOC)((_ocbuf_),_ocLength) == Success )\
* { \
* STORE_ELEMENT_INFO((_ocbuf_)->curPtr, _ocType_, _ocLength);\
* (_ocbuf_)->curPtr += LENOF(pexElementInfo); \
* if (_size_ > 0) COPY_AREA(_OCData_, (_ocbuf_)->curPtr, _size_);\
* (_ocbuf_)->curPtr += NUMWORDS(_size_); \
* ( *(_ocbuf_)->FinishOC)((_ocbuf_)); \
* } \
* else \
* ( *(_ocbuf_)->OCError)((_ocbuf_), _ocLength); \
* }
* #endif /* DEBUG not defined */
*
* #ifndef DEBUG
* /*+
* * NAME:
* * PEXAddListOC
* *
* * FORMAT:
* * void PEXAddListOC (ocbuf, ocType, countNeeded, count, elementSize,
* * elementList)
* * pxlOCBuf *ocbuf;
* * unsigned int ocType;
* * int countNeeded;
* * int count;
* * int elementSize;
* * char *elementList;
* *
* * ARGUMENTS:
* * ocbuf The OC buffer to which the output command is to be
* * added.
* *
* * ocType The type of output command to be added to the OC
* * buffer.
* *
* * countNeeded True if the list to be added requires a count to
* * precede it; False otherwise
* *
* * count The number of items in the list to be placed
* * in the output command.
* *
* * elementSize The size (in bytes) of each item in the list.
* *
* * elementList A pointer to the data for the list.
* *
* * RETURNS:
* * None
* *
* * DESCRIPTION:
* * This routine adds an output command of type `ocType' to the oc
* * buffer. The `PEX.h' include file contains possible values of `ocType'.
* *
* * The last part of the command is a list of `count' items. Each item is
* * `elementSize' bytes long. The list is padded if necessary. If
* * `countNeeded` is True the list created in `ocbuf' is preceded by a
* * count. `elementList' points to the data for the list.
* *
* * ERRORS:
* * Renderer Specified renderer resource identifier is
* * invalid.
* *
* * Structure Specified structure resource identifier is
* * invalid.
* *
* * FloatingPointFormat Device does not support the specified floating
* * point format.
* *
* * OutputCommand A value in an output command is illegal,
* * out of range, or otherwise inappropriate.
* *
* * SEE ALSO:
* * `PEXAllocateRetainedOCBuffer, `PEXAllocateTransientOCBuffer
,
* * `PEXAddOC
* *
* */
* #define PEXAddListOC(_ocbuf_,_ocType_,_countNeeded_,_count_,_elSize_,_elList_)\
* { \
* int _ocListSize = (_count_) * (_elSize_); \
* char *_pReq; \
* PEXInitOC(_ocbuf_,_ocType_, \
* (_countNeeded_) ? LENOF( pexOCcListHeader) :\
* LENOF( pexOCListHeader),\
* NUMWORDS( _ocListSize), &_pReq); \
* if (_pReq == NULL) return; \
* if (_countNeeded_) ((pexOCcListHeader * )_pReq)->length = (_count_);\
* PEXCopyBytesToOC(_ocbuf_, _ocListSize, _elList_); \
* PEXFinishOC(_ocbuf_); \
* }
*
more picks ***/
* #define MPEXNoMorePicks 0
* #define MPEXMorePicks 1
* #define MPEXMaybeMorePicks 2
*
* /*** user-settable Dash Patterns ***/
* #define MPEXDashPattern1 -1
* #define MPEXDashPattern2 -2
* #define MPEXDashPattern3 -3
* #define MPEXDashPattern4 -4
* #define MPEXDashPattern5 -5
* #define MPEXDashPattern6 -6
* #define MPEXDashPattern7 -7
* #define MPEXDashPattern8 -8
* #define MPEXDashPattern9 -9
* #define MPEXDashPattern10 -10
* #define MPEXDashPattern11 -11
* #define MPEXDashPattern12 -12
* #define MPEXDashPattern13 -13
* #define MPEXDashPattern14 -14
* #define MPEXDashPattern15 -15
* #define MPEXDashPattern16 -16
*
* /*** user-settable Marker Glyphs ***/
* #define MPEXMarkerGlyph1 -1
* #define MPEXMarkerGlyph2 -2
* #define MPEXMarkerGlyph3 -3
* #define MPEXMarkerGlyph4 -4
* #define MPEXMarkerGlyph5 -5
* #define MPEXMarkerGlyph6 -6
* #define MPEXMarkerGlyph7 -7
* #define MPEXMarkerGlyph8 -8
* #define MPEXMarkerGlyph9 -9
* #define MPEXMarkerGlyph10 -10
* #define MPEXMarkerGlyph11 -11
* #define MPEXMarkerGlyph12 -12
* #define MPEXMarkerGlyph13 -13
* #define MPEXMarkerGlyph14 -14
* #define MPEXMarkerGlyph15 -15
* #define MPEXMarkerGlyph16 -16
*
* /*** Bit Numbers for Change/Get/CopyNewPipelineContext ***/
* #define MPEXNPCHighlightIndex 0
* #define MPEXNPCEchoIndex 1
* #define MPEXNPCTextSkew 2
* #define MPEXNPCAnnotationTextSkew 3
* #define MPEXMaxNPCIndex 3
CONST
MPEXNRALogicalOpBit = 0;
MPEXNRAPlaneMaskBit = 1;
MPEXNRABackgroundPixelBit = 2;
MPEXNRAClearIBit = 3;
MPEXNRAClearZBit = 4;
MPEXNRAOverlapModeBit = 5;
MPEXNRAAaSwitchBit = 6;
MPEXNRAHighlightTableBit = 7;
MPEXNRAEchoTableBit = 8;
MPEXNRAEchoSwitchBit = 9;
MPEXNRAPickPositionBit = 10;
MPEXNRAPickDistanceBit = 11;
MPEXNRAPickInclusionBit = 12;
MPEXNRAPickExclusionBit = 13;
MPEXNRAPickMaxHitsBit = 14;
MPEXNRAPickStartPathBit = 15;
MPEXNRACullSwitchBit = 16;
MPEXNRAPixmapTableBit = 17;
MPEXNRAErrorCheckBit = 18;
MPEXNRATextureTableBit = 19;
MaxNRAShift = 20;
FirstNRABit = 0;
LastNRABit = 19;
** Bit masks for Change/GetNewRendererAttributes **
MPEXNRALogicalOp = Word.LeftShift(1,MPEXNRALogicalOpBit);
MPEXNRAPlaneMask = Word.LeftShift(1,MPEXNRAPlaneMaskBit);
MPEXNRABackgroundPixel = Word.LeftShift(1,MPEXNRABackgroundPixelBit);
MPEXNRAClearI = Word.LeftShift(1,MPEXNRAClearIBit);
MPEXNRAClearZ = Word.LeftShift(1,MPEXNRAClearZBit);
MPEXNRAOverlapMode = Word.LeftShift(1,MPEXNRAOverlapModeBit);
MPEXNRAAaSwitch = Word.LeftShift(1,MPEXNRAAaSwitchBit);
MPEXNRAHighlightTable = Word.LeftShift(1,MPEXNRAHighlightTableBit);
MPEXNRAEchoTable = Word.LeftShift(1,MPEXNRAEchoTableBit);
MPEXNRAEchoSwitch = Word.LeftShift(1,MPEXNRAEchoSwitchBit);
MPEXNRAPickPosition = Word.LeftShift(1,MPEXNRAPickPositionBit);
MPEXNRAPickDistance = Word.LeftShift(1,MPEXNRAPickDistanceBit);
MPEXNRAPickInclusion = Word.LeftShift(1,MPEXNRAPickInclusionBit);
MPEXNRAPickExclusion = Word.LeftShift(1,MPEXNRAPickExclusionBit);
MPEXNRAPickMaxHits = Word.LeftShift(1,MPEXNRAPickMaxHitsBit);
MPEXNRAPickStartPath = Word.LeftShift(1,MPEXNRAPickStartPathBit);
MPEXNRACullSwitch = Word.LeftShift(1,MPEXNRACullSwitchBit);
MPEXNRAPixmapTable = Word.LeftShift(1,MPEXNRAPixmapTableBit);
MPEXNRAErrorCheck = Word.LeftShift(1,MPEXNRAErrorCheckBit);
MPEXNRATextureTable = Word.LeftShift(1,MPEXNRATextureTableBit);
/*** Output Command Opcodes ***/
* #define MPEXOCHighlightIndex (MPEX_OC+0)
* #define MPEXOCEchoIndex (MPEX_OC+1)
* #define MPEXOCNoop (MPEX_OC+2)
* #define MPEXOCAnnoPixmap (MPEX_OC+3)
* #define MPEXOCCircle (MPEX_OC+4)
* #define MPEXOCArc (MPEX_OC+5)
* #define MPEXOCIndexedPolygons (MPEX_OC+6)
* #define MPEXOCEllipticalArc2D (MPEX_OC+7)
* #define MPEXOCEllipticalArc3D (MPEX_OC+8)
* #define MPEXOCEllipse2D (MPEX_OC+9)
* #define MPEXOCEllipse3D (MPEX_OC+10)
* #define MPEXOCGridRectangular (MPEX_OC+11)
* #define MPEXOCGridRadial (MPEX_OC+12)
* #define MPEXOCTextSkew (MPEX_OC+13)
* #define MPEXOCAnnotationTextSkew (MPEX_OC+14)
* #define MPEXOCReferToStructure (MPEX_OC+15)
* #define MPEXOCFFTextureMapIndex (MPEX_OC+16)
* #define MPEXOCBFTextureMapIndex (MPEX_OC+17)
*
* #define MaxMPEXOC (MPEX_OC+18)
* #define FirstMPEXOC (MPEX_OC+0)
* #define LastMPEXOC (MPEX_OC+17)
*
* /*** Events ***/
* #define MPEXMaxHitsReached (MPEX_EVENT+0)
*
* /*** Requests ***/
* #define MPEX_ChangeNewRenderer (MPEX_REQ+0)
* #define MPEX_GetNewRendererAttributes (MPEX_REQ+1)
* #define MPEX_RenderElements (MPEX_REQ+2)
* #define MPEX_AccumulateState (MPEX_REQ+3)
* #define MPEX_BeginPickOne (MPEX_REQ+4)
* #define MPEX_EndPickOne (MPEX_REQ+5)
* #define MPEX_PickOne (MPEX_REQ+6)
* #define MPEX_BeginPickAll (MPEX_REQ+7)
* #define MPEX_EndPickAll (MPEX_REQ+8)
* #define MPEX_PickAll (MPEX_REQ+9)
* #define MPEX_SetElementPointerAtPickId (MPEX_REQ+10)
* #define MPEX_SetDashPattern (MPEX_REQ+11)
* #define MPEX_GetDashPattern (MPEX_REQ+12)
* #define MPEX_SetMarkerGlyph (MPEX_REQ+13)
* #define MPEX_GetMarkerGlyph (MPEX_REQ+14)
* #define MPEX_LargeRequest (MPEX_REQ+15)
* #define MPEX_BeginTransparencyRendering (MPEX_REQ+16)
* #define MPEX_EndTransparencyRendering (MPEX_REQ+17)
* #define MPEX_CopyNewPipelineContext (MPEX_REQ+18)
* #define MPEX_GetNewPipelineContext (MPEX_REQ+19)
* #define MPEX_ChangeNewPipelineContext (MPEX_REQ+20)
*
* #define MaxMPEXCommand (MPEX_REQ+21)
* #define FirstMPEXCommand (MPEX_REQ+0)
* #define LastMPEXCommand (MPEX_REQ+20)
*
* /* dummied in because Pete doesn't know any better (used in pl_startup.c) */
*
* #define PEXMinError 0
*
* #define Texture Information */
*
* #define MPEXGATexture 0x0008
* #define MPEXInteriorStyleTexture 6
*
* /* Texture Mapping Definition */
*
* #define MPEXTextureMapWrap 0
* #define MPEXTextureMapClamp 1
* #define MPEXTextureMapNone 2
*
* #endif /* MPEX_H */
MPEX.h
* #endif
* #ifndef MPEXPROTO_H
* # include MPEXproto.h
* #endif
* #ifndef MPEXPROTOSTR_H
* # include MPEXprotostr.h
* #endif
TYPE
mpxlAnnoPixmap = mpexAnnoPixmap;
mpxlArc = mpexArc;
mpxlCircle = mpexCircle;
mpxlIndexedPolygon = mpexIndexedPolygon;
mpxlEllipticalArc2D = mpexEllipticalArc2D;
mpxlEllipticalArc3D = mpexEllipticalArc3D;
mpxlEllipse2D = mpexEllipse2D;
mpxlEllipse3D = mpexEllipse3D;
mpxlGridRectangular = mpexGridRectangular;
mpxlGridRadial = mpexGridRadial;
mpxlEchoIndex = mpexEchoIndex;
mpxlHighlightIndex = mpexHighlightIndex;
mpxlNoop = mpexNoop;
TYPE
mpxlHighlightEntry = RECORD
method : pxlEnumTypeIndex;
pad : CARD16;
colour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier;
END;
mpxlEchoEntry = RECORD
method : pxlEnumTypeIndex;
pad : CARD16;
colour : BITS BITSIZE (pxlColourSpecifier) FOR pxlColourSpecifier;
END;
mpxlPixmapEntry = mpexPixmapEntry;
mpxlPickAllPath = RECORD
pathLength : Ctypes.int;
elementRefs : pxlPickPathStar;
END;
mpxlPickAllPathStar = UNTRACED REF mpxlPickAllPath;
mpxlPickAllPathStarStar = UNTRACED REF mpxlPickAllPathStar;
mpxlPCAttributes = RECORD
highlightIndex : Ctypes.unsigned_short;
echoIndex : Ctypes.unsigned_short;
textSkew : Ctypes.float;
annotationTextSkew : Ctypes.float;
textureMapIndex : Ctypes.unsigned_short; (* Only in AOSF version *)
textureMapState : Ctypes.unsigned_short; (* Only in AOSF version *)
END;
mpxlPCAttributesStar = UNTRACED REF mpxlPCAttributes;
mpxlPCAttributesStarStar = UNTRACED REF mpxlPCAttributesStar;
** macro for setting bits in a new PC value mask **
TYPE
mpxlRendererAttributes = RECORD
logicalOp : Ctypes.short;
overlapMode : Ctypes.short;
planeMask : Ctypes.unsigned_long;
backgroundPixel : Ctypes.unsigned_long;
clearI : Ctypes.unsigned_char;
clearZ : Ctypes.unsigned_char;
errorCheck : Ctypes.unsigned_char;
aaSwitch : Ctypes.unsigned_char;
echoSwitch : Ctypes.unsigned_char;
cullSwitch : Ctypes.unsigned_char;
highlightTable : pxlLookupTable;
echoTable : pxlLookupTable;
pixmapTable : pxlLookupTable;
textureTable : pxlLookupTable;
pickPosition : pxlDeviceCoord2D;
pickDistance : Ctypes.float;
pickInclusion : pxlNameSet;
pickExclusion : pxlNameSet;
pickMaxHits : Ctypes.unsigned_long;
pickStartPath : pxlStructurePath;
END; (* mpxlRendererAttributes *)
mpxlRendererAttributesStar = UNTRACED REF mpxlRendererAttributes;
mpxlRendererAttributesStarStar = UNTRACED REF mpxlRendererAttributesStar;
** Event Structures **
TYPE
mpexAnnoPixmap = RECORD
head : pexElementInfo;
origin : pexCoord3D;
index : pexTableIndex;
pad : CARD16;
END;
mpexArc = RECORD
head : pexElementInfo;
center : pexCoord3D;
radius : Ctypes.float;
startAngle : Ctypes.float;
endAngle : Ctypes.float;
END;
mpexCircle = RECORD
head : pexElementInfo;
center : pexCoord3D;
radius : Ctypes.float;
END;
mpexEllipticalArc2D = RECORD
head : pexElementInfo;
center : BITS BITSIZE (pexCoord2D) FOR pexCoord2D;
majorAxis : BITS BITSIZE (pexCoord2D) FOR pexCoord2D;
minorAxis : BITS BITSIZE (pexCoord2D) FOR pexCoord2D;
startAngle : Ctypes.float;
endAngle : Ctypes.float;
END;
mpexEllipticalArc3D = RECORD
head : pexElementInfo;
center : pexCoord3D;
majorAxis : pexCoord3D;
minorAxis : pexCoord3D;
startAngle : Ctypes.float;
endAngle : Ctypes.float;
END;
mpexEllipse2D = RECORD
head : pexElementInfo;
center : BITS BITSIZE (pexCoord2D) FOR pexCoord2D;
majorAxis : BITS BITSIZE (pexCoord2D) FOR pexCoord2D;
minorAxis : BITS BITSIZE (pexCoord2D) FOR pexCoord2D;
END;
mpexEllipse3D = RECORD
head : pexElementInfo;
center : pexCoord3D;
majorAxis : pexCoord3D;
minorAxis : pexCoord3D;
END;
mpexIndexedPolygon = RECORD
head : pexElementInfo;
shape : CARD16;
colourType : pexColourType;
facetAttribs : pexBitmaskShort;
vertexAttribs : pexBitmaskShort;
edgeAttribs : CARD16;
numFacets : CARD16;
numEdges : CARD16;
numVertices : CARD16;
(* LISTof CARD16(numFacets) *)
(* LISTof OptData(numFacets, facetAttribs, colourType) *)
(* LISTof VertexIndex(numEdges, edgeAttribs) *)
(* LISTof Vertex(numVertices, vertexAttribs, colourType) *)
END;
mpexGridRectangular = RECORD
head : pexElementInfo;
origin : pexCoord3D;
xdist : Ctypes.float;
ydist : Ctypes.float;
END;
mpexGridRadial = RECORD
head : pexElementInfo;
center : pexCoord3D;
startAngle : Ctypes.float;
endAngle : Ctypes.float;
angDist : Ctypes.float;
radDist : Ctypes.float;
END;
mpexEchoIndex = RECORD
head : pexElementInfo;
index : pexTableIndex;
pad : CARD16;
END;
mpexHighlightIndex = RECORD
head : pexElementInfo;
index : pexTableIndex;
pad : CARD16;
END;
mpexNoop = RECORD
head : pexElementInfo;
END;
TYPE
mpexHighlightEntry = RECORD
method : pexEnumTypeIndex;
pad : CARD16;
colour : pexColourSpecifier;
END;
mpexEchoEntry = RECORD
method : pexEnumTypeIndex;
pad : CARD16;
colour : pexColourSpecifier;
END;
mpexPixmapEntry = RECORD
pixmapId : CARD32; (* used to be X.Pixmap *)
xOffset : INT16;
yOffset : INT16;
END;
END PEX.