The DesignXML Schema

DesignXML defines a structure that enables efficient delivery of geometric model information over the World Wide Web. DesignXML also defines a common vocabulary for 3D geometry and graphics representation.

Topics in this document:

  • Introduction
  • DesignXML Document Structure
  • Fundamental Types of Geometry and Graphics
  • Linear Geometry Elements
  • Nonlinear Geometry Elements
  • DesignXML Reference


Introduction

This document is intended for design professionals who are interested in reading and writing geometric model information specified in XML according to the rules of the DesignXML schema. For example, software application developers can use this information to determine the design and implementation of their applications that read and write models in DesignXML-conformant XML.

Sections in this topic:

  • About DesignXML
  • Terminology

About DesignXML

DesignXML is a schema for representing geometry-oriented models in XML. Specifically, DesignXML

  • Defines a vocabulary for representing high-precision geometric models
  • Leverages existing schemas, such as SVG, and standard raster image formats such as JPEG, GIF, and BMP
  • Provides a low barrier to entry without sacrificing the potential for richness of expression
  • Holds its own set of design elements, as well as data from other schemas
  • Defines constructs in a modular manner to promote reuse of utility definitions between different schema
  • Represents complete model state, partial model state, and abstract views of the model
  • Facilitates processing by standard XML tools, such as XSL and XSLT

Terminology

Data Channel
A view of a particular geometric model. Each channel is one way of looking at the data; each channel represents a different level of complexity and detail with respect to the actual model information in the design. For example, the Administrative data channel describes only the document summary information, such as title, author, and keywords; the Facetted3D data channel provides a way to describe the model using linear geometry only.
SVG
SVG (Scalable Vector Graphics) is a language for describing two-dimensional graphics in XML. See the W3C (World Wide Web Consotium, http://www.w3c.org) SVG specification for details.
URI, URL, URN
A Uniform Resource Identifier (URI) is either a locator, a name, or both. Uniform Resource Locator (URL) refers to the subset of URI that identifies resources via a representation of their primary access mechanism (for example, their network "location"). Uniform Resource Name (URN) refers to the subset of URI that serves as persistent, location-independent, resource identifiers.


DesignXML Document Structure

A DesignXML document consists of an object element containing zero or more data channel elements.

Sections in this topic:

  • DesignXML Document
  • Objects and Channels
  • Administrative, Raster2D, and Vector2D Channels
  • Facetted3D Channel
  • Geometry3D Channel
  • Model Channel
  • Geometry and Graphics Elements

DesignXML Document

A DesignXML document, at the hightest level, consists of a dxml:Object element.
<?xml version="1.0" encoding="UTF-8"?>
<!-- edited with XML Spy v2.5 NT  - http://www.xmlspy.com -->
        <dxml:Object
                        xmlns="urn:schemas-microsoft-com:xml-data"
                        xmlns:dt="urn:schemas-microsoft-com:datatypes"
                        xmlns:dxml="x-schema:\\AutodeskXML\DesignXML.xml">
        </dxml:Object>
A dxml:Object element contains one or more representations of the geometric model. Each such representation is called a data channel.

The key constructs of DesignXML are the following:

  • Objects, which represent a geometric model, composed of redundant data channels
  • Double-precision 3D/2D geometry and graphics elements

Objects and Channels

A DesignXML object is logically equivalent to a geometric model or drawing. The object's channels appear as sections of a DesignXML file, or as a set of files (a DesignXML file or set of files is called a DesignXML "stream"). A DesignXML stream need not have all of the available channels present. More channels mean more information for the stream's client to use.

DesignXML Channels

While each channel is optional, when they appear at all in a DesignXML file, they must appear in the top-to-bottom sequence shown in the illustration of the DesignXML channels. Simpler, lower-resolution, but more universally readable channels come first, and subsequent channels add successively greater fidelity to the original model, ending with an application Model channel, or possibly multiple Model channels that define the model data exactly.

A summary of the DesignXML data channels follows.

Administrative | Document summary information, such as title, author, and keywords. Any application-specific extensions to this information should be part of a Model channel
Raster2D | Consists of a URI reference to a file containing a 2D raster image. The referenced file's suffix indicates its type (i.e. .jpg, .bmp, etc.). An optional view specification of the model that the image represents can be included as well. Multiple instances of this channel are permitted, under the assumption that they represent different views or rendering modes of the model (for example, top, bottom, wireframe, photorealistic).
Vector2D | Consists of a URI reference to an SVG file containing a scalable 2D view of the model (which may itself be 2D or 3D). As with the Raster2D channel, a view specification may be provided, and multiple instances of this channel corresponding to different views can appear in the same DesignXML Object element.
Facetted3D | Represents a double-precision 2D or 3D geometric model as a facetted model. A facetted model consists entirely of linear geometry elements, such as line segments and meshes, plus text geometry and raster data. This channel can also consist of a forwarding URI reference to another XML file that contains Facetted3D channel data.
Geometry3D | A superset of the Facetted3D channel with an additional vocabulary of non-linear geometry constructs. As with the Facetted3D channel, this channel can consist of a forwarding URI reference to another XML file that contains Geometry3D channel data.
Model | An open model channel with an app="appname" attribute and an associated schema that defines the content on the application's terms. Publication and support of the data format is the responsibility of the application vendor, not of DesignXML. There can be multiple Model channels in a DesignXML file, or no model channel at all. This channel can also consist of a forwarding URI reference to another XML file that contains the actual Model channel data.

DesignXML specifies the file formats to be used for the 2D channels and completely defines the formats used in the 2D/3D channels.

Administrative, Raster2D, and Vector2D Channels

The definitions for the Administrative, Raster2D, and Vector2D channels are simple and self-descriptive. The Administrative channel defines summary information. The Raster2D and Vector2D channels are simply containers for a systemId attribute that holds the URI or file path to a raster format file and SVG file, respectively.

Administrative

<ElementType name="Administrative" content="eltOnly" order="seq" model="closed">
    <element type="Title"/>
    <element type="Subject"/>
    <element type="Author"/>
    <element type="Manager"/>
    <element type="Company"/>
    <element type="Category"/>
    <element type="Keywords"/>
    <element type="Comments"/>
    <element type="HyperlinkBase"/>
</ElementType>

Raster2D

<ElementType name="Raster2D" content="eltOnly" order="seq" model="closed">
    <attribute type="systemId"/>
    <element type="RenderSpecification" minOccurs="0" maxOccurs="1"/>
</ElementType>

Vector2D

<ElementType name="Vector2D" content="eltOnly" order="seq" model="closed">
    <attribute type="systemId"/>
    <attribute type="lengthUnits"/>
    <attribute type="angleUnits"/>
    <element type="RenderSpecification" minOccurs="0" maxOccurs="1"/>
</ElementType>

Facetted3D Channel

The Facetted3D channel supports a model representation using only a reduced set of 2D geometric constructs. For example, a 3D wireframe representation of the model can be delivered in the Facetted3D channel.

Facetted3D Channel

The FacettedSubmodel element provides a means for grouping instances of the other geometry elements in the Facetted3D channel and referencing them as needed, while applying an independent linear transform to each element.

Geometry3D Channel

The Geometry3D channel is essentially the Facetted3D channel plus additional, nonlinear geometric elements.

Geometry3D Channel
Model Channel

The Model channel is where geometric modeling software applications define the schemas for their particular model representations. For example, a DesignXML Object can contain or point to model channels created by AutoCAD software or Intergraph Microstation software. The <Model> element's app attribute distinguishes one application's model channel from another's. For example,

<Model app="acdb">

specifies a Model channel using the Autodesk AcDbXML schema.

Geometry and Graphics Elements

In addition to the channel structures, DesignXML provides definitions for reusable graphical objects and their properties, primarily for use in Model channel schemas. The DesignXML graphical elements and their properties are the following:

  • Linear geometry, quadratic curves, and solid elements.
  • Text geometry with associated fonts and properties
  • Raster image data, bound to geometric faces and surfaces
  • Double-precision for all relevant values
  • Quantities with built-in units relevant to geometric model elements, namely length and angle
  • 3D View and rendering specifications, such as view direction, clip boundaries, Model Z axis display angle, perspective viewing angle, and rendering mode.

These elements can have color—either presentational (LUT indices) or material (32-bit color space).


Fundamental Types of Geometry and Graphics

The DesignXML elements and attributes that model such fundamental properties as angle, distance, transformation, view, rendering, and color are described in the following.

Sections in this topic:

  • Basic Measure Elements
  • Linear Transforms
  • View and Rendering Model
  • Color
  • The Link Element

Basic Measure Elements

Fundamental to any geometric modeling system is the specification of distance and angle. What differentiates distances and angles from scalar values is that distance and angle have dimension or units. Length is usually defined using points and vectors, which represent locations, directions, and directed distances. Modeling systems have widely differing representations for, and assumptions concerning, units.

DesignXML specifies units as follows:

<AttributeType name="lengthUnits" dt:type="enumeration" required="no" dt:values="none A nm mic mm cm dm m dam hm km Gm microinch mil in ft yd mi au
                    lightyear parsec" default="none"/>
<AttributeType name="angleUnits" dt:type="enumeration" required="no" dt:values="rad degree grads" default="rad"/>

These unit types represent the quantities covered in the International Metric System (SI), plus other quantities of interest. All values are represented as single, real numbers. All real numbers in the geometric model are stored and manipulated as double precision floating point values, as specified in the Microsoft XML Schema dt:r8 extended data type.

The DesignXML attributes used to denote the X, Y, and Z Cartesian coordinates are x, y, and z but note that x is also used for scalar length values:

<AttributeType name="x" dt:type="r8" required="yes"/>
<AttributeType name="y" dt:type="r8" required="yes"/>
<AttributeType name="z" dt:type="r8" required="no" default="0.0"/>

The t (theta) attribute is used for angle values:

<AttributeType name="t" dt:type="r8" required="yes"/>

The basic DesignXML measure elements are the following:

  • DataString
  • Length
  • Angle
  • Point
  • Vector

DataString

DataString is a container for a Microsoft XML Schema dt:r8 string attribute type.

The following table shows the characters that must be represented by an entity sequence when they appear in DataString elements:
Character | Entity
" | &quot;
< | &lt;
> | &gt;
' | &apos;

Length

Length is a scalar real number "x" combined with applicable units.

Angle

Angle is a scalar real number "t" combined with applicable units.

Point

The DesignXML Point represents a 3D, right-handed Cartesian coordinate point, but permits the absence (an implied 0.0 value) of a Z coordinate to represent 2D points.

Vector

The DesignXML Vector represents a 3D, right-handed Cartesian coordinate vector, but permits the absence (an implied 0.0 value) of a Z coordinate to represent 2D vectors.

Linear Transforms

Every channel is assumed to be in a single coordinate system. SubmodelReference elements apply a 2D or 3D linear transform to their respective submodel elements. The constructs described in this section are used to produce linear transformations.

Linear transform elements are as follows:

  • Normal
  • Matrix3x3
  • Orientation
  • Translation
  • LinearCoordinateTransform

Normal

A DesignXML Normal is a vector used to define the orientation of a 2D plane in 3D space. A Normal vector represents the Z axis of planar geometry such as circles, arcs, and text strings.

Matrix3x3

The DesignXML Matrix3x3 element represents 3D orientation and scale. Each coordinate name uses two letters (for example "xz"). The first letter represents an input vector coordinate, and the second letter represents an output vector coordinate. One can also represent a 2x2 matrix for 2D rotation transforms by omitting all attributes with a name containning "z" (the omitted attribute values default to 0.0).

Orientation

See LinearCoordinateTransform.

Translation

See LinearCoordinateTransform.

LinearCoordinateTransform

A LinearCoordinateTransform represents a 3D linear transform from a linear coordinate system to another coordinate system. The LinearCoordinateTransform is defined by its contained Orientation (Matrix3x3) and Translation (Vector) elements. A LinearCoordinateTransform can also represent a 3x2 matrix for 2D transforms by omitting "z" elements and attributes. In fact, all elements are optional, with an empty matrix corresponding to an identity matrix. Planar entities such as text strings have a non-identity coordinate system to reflect an orientation that is not in the XY plane of the host coordinate system.

View and Rendering Model

The 2D channels as well as some model channel elements can benefit from specifying a 2D projection onto a 3D model.

View and rendering elements are as follows:

  • ViewHeight
  • ViewDirection
  • TargetPoint
  • FrontClip
  • BackClip
  • PerspectiveViewingAngle
  • WorldZDisplayAngle
  • View
  • RenderSpecification

ViewHeight

ViewHeight is the vertical view size in model units, defined by the contained Length element. For perspective views, the size applies to the view plane that intercepts the target point.

ViewDirection

ViewDirection is the point of view, defined by two angles relative to the X axis and XY plane of the WCS. The contained Vector element describes the ViewDirection.

TargetPoint

TargetPoint is the focal point of a 3D view.

FrontClip

FrontClip represents the front clipping plane in a 3D view. The front clipping plane is a plane perpendicular to the line of sight; objects between the point of view and the front clipping plane are clipped from view. The contained Length element defines the location of the FrontClip plane as a distance from the target point.

BackClip

BackClip represents the back clipping plane in a 3D view. The back clipping plane is a plane perpendicular to the line of sight; objects behind the back clipping plane are clipped from view. The contained Length element defines the location of the BackClip plane as a distance from the target point.

PerspectiveViewingAngle

PerspectiveViewingAngle represents the visible field of view in a perspective projection. For example, a PerspectiveViewingAngle value of 0 approximates an orthographic (infinite distance) projection, a value of 180 approximates a fisheye view, and a value of 40-60 gives a noticeable perspective quality to the view.

WorldZDisplayAngle

WorldZDisplayAngle is the angle (the twist) from vertical that the model's Z axis (or Y axis for 2D views) appears. An upside-down view is 180 degrees.

View

Every View specification must have a height in model units and a model target point, which is centered in the view. After that, however, Boolean attributes indicate the need for the other contained elements. For example, the value of the isTwisted attribute determines whether a WorldZDisplayAngle element is needed.

RenderSpecification

A RenderSpecification identifies a RenderMode (Plan, Wireframe, Hidden, FlatShade, Gouraud, FlatShadeWithWireframe, GouraudWithWireframe) and View.

Color

There are two principal ways you can specify color: as an index into a lookup table, or palette, or as a true color, specified as a 3D point in a specified color space. The dxml:Color element allows either color mode to be used, the former in conjunction with a dxml:ColorPalette. Only one ColorPalette per object data channel is allowed.

In general, Color can be specified, or omitted, at any level of composition of a model. For dxml channels, the color specified at the level closest to an element (or, lowest level above its element in a DOM tree) dictates its color

Color elements are as follows:

  • ColorPalette
  • ColorIndex
  • TrueColor
  • Color

ColorPalette

ColorPalette is the color lookup table definition.

ColorIndex

ColorIndex represents an index into a ColorPalette element.

TrueColor

TrueColor is the 24-bit color plus 8-bits for the alpha channel with choice of color space.

Color

Color is either a color index, or a true color, but not both.

The Link Element

The Link element is used to associate elements in the common DesignXML channels with other bodies of information, including elements in other common channels, elements in a model channel, or even records in an external database. The most obvious usage is to indicate which application model element a Geometry3D or Facetted3D element corresponds to. For example, a Link might associate a Facetted3D Line with its AcDbXML Entity handle. Any number of Link elements can exist in a DXML file, so each application should add a unique prefix to the link name in order to distinguish it from links created by other applications. Autodesk Developer Network members should use their registered developer symbols in the Link name. Interpretation of links is the responsibility of the applications implementing them.


Linear Geometry Elements

The following linear geometry elements can be used in both the Facetted3D and Geometry3D channels. These are the only elements that can be used in the Facetted3D channel.

The following are building blocks used by the linear geometry elements.

Vertices

Vertices are the (minimum of two) points defining Polyline, Mesh, FacettedShell, and Body. The Vertices element effectively declares Point twice, which is necessary so that an XDR validating parser can enforce a minimum of two vertices.

<ElementType name="Vertices" content="eltOnly" order="seq" model="closed">

    <element type="Point" minOccurs="1" maxOccurs="1"/>
    <element type="Point" minOccurs="1" maxOccurs="*"/>
</ElementType>

Linear geometry elements are the following:

  • LineSegment
  • Line
  • Ray
  • Polyline
  • RasterImage
  • Mesh
  • FacettedShell
  • Text
  • FacettedSubmodel
  • FacettedSubmodelReference

LineSegment

Line segments are the set of points that lie directly between the two specified endpoints.

Line

An infinite line in space as defined by a point and a direction vector.

Ray

A half line bounded by a point and extending in the direction of the vector.

Polyline

A Polyline is composed of linear segments with shared endpoints.

RasterImage

Raster images are specified in separate files or URIs. A DesignXML Mesh element serves as the geometric frame for a RasterImage. A flat raster image is most easily attached to a 2x2 unclosed mesh. Raster image X and Y pixels are uniformly scaled to the Mesh's U and V coordinates, respectively.

Mesh

MxN quad polygon face meshes are specified as a matrix of vertices, optional vertex normals, and face and edge properties. The implicit ordering is M groups of N vertices, so that there are M rows and N columns. The corresponding parametric dimensions are U and V, which both have ranges of 0.0 to 1.0. The U dimension is 0.0 at the first vertex in each row, and is 1.0 at either the N-1 vertex (if unclosed in the N direction) or the first vertex (if closed in the N direction). The same relationship applies to the V coordinate along the M rows of vertices.

The number of Mesh Vertices must equal mSize * nSize.

The rest of the contained Mesh elements are optional and independent from one another, but if present, must be present in the numbers indicated.

Raster images are always applied to a mesh.

The number of NormalVectors must equal (mSize * nSize).

The number of EdgeProperties must equal (mSize - isClosedM + 1) * (nSize - isClosedN + 1)

The number of FaceProperties must equal (mSize - isClosedM) * (nSize - isClosedN)

FacettedShell

A FacettedShell consists of arrays of face elements that are closed boundary paths specified as an array of indices into an array of shared vertex locations. Shared vertex normals can be optionally specified. Overriding edge element properties can also be specified. The same index refers to a vertex, and the edge that starts with the vertex. The final edge goes from the final vertex to vertex 0 (the first vertex). All specified faces are visible; holes exist where there are no faces.

If this shell represents nonlinear geometry, MaximumDeviation specifies the maximum distance the shell geometry can displace from the actual geometry. If the shell represents linear geometry, 0.0 is a viable length value.

The FacettedFace element contains a group of VertexIndex and ElementPropertyIndex elements that define a closed loop of linear edges, with optional overriding properties. Both VertexIndex and ElementPropertyIndex have valid ranges of 0 through (n-1) where n is the number of corresponding elements.

The number of Vertices points must be at least ((the maximum VertexIndex used in any FacettedFace element) + 1).

The remaining arrays NormalVectors and ElementProperties are optional and independent from one another, but if present, must have the same size as the Vertices element.

The number of NormalVectors must equal the number of vertices.

The number of ElementProperties must be at least ((the maximum ElementPropertyIndex used in any FacettedFace element) + 1).

Text

Text is strings with size, orientation and font information.

The default coordinate system for text is defined by the following: start position (origin), oblique angle (italicized clockwise from orthogonal Y axis), height (Y Axis Scale factor), baseline direction (X Axis), and normal (Z Axis).

FacettedSubmodel

The FacettedSubmodel is a building block used to apply transforms to other geometry. You use a FacettedSubmodel by referencing it via a FacettedSubmodelReference. A FacettedSubmodel transform can be applied to every Facetted3D channel object (not including FacettedSubmodel elements themselves), plus Color and Link.

The name attribute is a unique id that will be referenced.

The Color element specifies the default color for the geometry.

FacettedSubmodelReference

FacettedSubmodelReference references a FacettedSubmodel via the submodel idref identifier.


Nonlinear Geometry Elements

The nonlinear geometry elements can be used in the Geometry3D channel only. The advantage of this set of geometric constructs is that they require far less data to specify a nonlinear surface to a specific tolerance than corresponding Facetted3D elements would. The disadvantage is that the software supporting nonlinear geometry is more complex and difficult to write or procure. Multiple DesignXML channels give developers a choice for accomplishing what they want, or need, to do.

Nonlinear geometry elements are a follows:

  • Circle
  • Arc
  • Ellipse
  • BSplineCurve
  • Cylinder
  • Cone
  • Sphere
  • Torus
  • Plane
  • BSplineSurface
  • BoundaryRep
  • Submodel
  • SubmodelReference

Circle

Circle is defined by Radius (a Length) and CenterPoint (a Point), both required:

<ElementType name="Radius" content="eltOnly" order="seq" model="closed">
    <element type="Length"/>
</ElementType>

<ElementType name="CenterPoint" content="eltOnly" order="seq" model="closed">
    <element type="Point"/>
</ElementType>

Arc

The quadraticCurveType attribute defines whether the arc represents the outer edge arc curve segment, the chord segment between the two arc endpoints, or a sector.

The contained Circle element defines the Arc center and radius.

The StartVector's initial point is the Circle's center point. The Arc startpoint is defined by the StartVector's intercept with the Circle.

The SweepAngle defines the inclusive arc angle difference between the startpoint (and angle), and the endpoint (and angle). For example, a sweep angle of 90 degrees defines a quarter of a full circle.

Ellipse

The Ellipse is 3D or 2D, depending on the value of the Normal element.

BSplineCurve

The defining elements of BSplineCurve are the zero or more ControlPoints:

<ElementType name="ControlPoint" content="eltOnly" order="seq" model="closed">
    <AttributeType name="weight" dt:type="r8" required="no"/>
    <attribute type="weight"/>
    <element type="Point"/>
</ElementType>

Rational B-Spline control points have weights, non-rational do not.

Cylinder

See Cylinder in the DesignXML Reference.

Cone

See Cone in the DesignXML Reference.

Sphere

See Sphere in the DesignXML Reference.

Torus

See Torus in the DesignXML Reference.

Plane

See Plane in the DesignXML Reference.

BSplineSurface

The number of control points should equal (numberOfControlPointsU * numberOfControlPointsV).

The number of Knot occurrences should equal (numberOfKnotsU * numberOfKnotsV).

BoundaryRep

BRep topology is defined externally. The systemId attribute points to a file containing ACIS Brep data.

Submodel

A Submodel is a building block used to apply transforms to other geometry. You use a Submodel by referencing it via a SubmodelReference. A Submodel transform can be applied to every Geometry3D channel object (not including Submodel elements themselves), plus Color and Link.

The name attribute is a unique id that can be referenced.

The value of the Color element defines the default color for the geometry.

SubmodelReference

SubmodelReference references a Submodel via the submodel idref identifier.


DesignXML Reference

The following sections contain descriptions of the elements and attributes defined in the DesignXML schema.

Sections in this topic:

  • DesignXML Schema Elements
  • DesignXML Schema Attributes
  • DesignXML Schema Element-specific Attributes
  • DesignXml_V_beta1.xdr Source
  • Schema Attributes Reference
  • Datatypes Reference

DesignXML Elements

The following is a list of all elements defined in the DesignXML schema.

Elements
<Administrative>
<Angle>
<Arc>
<AspectRatio>
<Author>
<BackClip>
<BaseAndDirection>
<BaselineDirection>
<BoundaryRep>
<BSplineCurve>
<BSplineSurface>
<Category>
<CenterPoint>
<Circle>
<Color>
<ColorIndex>
<ColorPalette>
<Comments>
<Company>
<Cone>
<ControlPoint>
<Cylinder>
<DataString>
<Direction>
<EdgeProperties>
<ElementProperty>
<ElementPropertyIndex>
<Ellipse>
<EndPoint>
<FaceProperties>
<Facetted3D>
<FacettedFace>
<FacettedShell>
<FacettedSubmodel>
<FacettedSubmodelReference>
<ForwardReference>
<FrontClip>
<Geometry3D>
<Height>
<HyperlinkBase>
<Keywords>
<Knot>
<Length>
<Line>
<LinearCoordinateTransform>
<LineSegment>
<Link>
<LocalModel>
<MajorAxis>
<MajorRadius>
<Manager>
<Matrix3x3>
<MaximumDeviation>
<Mesh>
<MinorRadius>
<Model>
<Normal>
<NormalVectors>
<Object> (document element)
<Obliquing>
<Orientation>
<PerspectiveViewingAngle>
<Plane>
<Point>
<PointOnLine>
<Polyline>
<Position>
<Radius>
<Raster2D>
<RasterImage>
<Ray>
<RenderSpecification>
<Sphere>
<StartPoint>
<StartVector>
<Subject>
<Submodel>
<SubmodelReference>
<SweepAngle>
<TargetPoint>
<Text>
<Title>
<TopRadius>
<Torus>
<Translation>
<TrueColor>
<Vector>
<Vector2D>
<VertexIndex>
<Vertices>
<View>
<ViewDirection>
<ViewHeight>
<WorldZDisplayAngle>

DesignXML Attributes

The following is a list of all attributes defined in the DesignXML schema.

Attributes
angleUnits
colorSpace
lengthUnits
quadraticCurveType
renderMode
systemId
t
x
y
z

DesignXML Element-specific Attributes

The following is a list of all element-specific attributes defined in the DesignXML schema.

Element-specific Attributes
<BSplineCurve isClosed>
<BSplineCurve isPeriodic>
<BSplineCurve isRational>
<BSplineCurve degree>
<BSplineCurve numberOfControlPoints>
<BSplineCurve numberOfKnots>
<BSplineCurve knotTolerance>
<BSplineCurve controlPointTolerance>
<BSplineCurve fitTolerance>
<BSplineSurface isClosedU>
<BSplineSurface isClosedV>
<BSplineSurface isPeriodicU>
<BSplineSurface isPeriodicV>
<BSplineSurface isRational>
<BSplineSurface degreeU>
<BSplineSurface degreeV>
<BSplineSurface numberOfControlPointsU>
<BSplineSurface numberOfControlPointsV>
<BSplineSurface numberOfKnotsU>
<BSplineSurface numberOfKnotsV>
<BSplineSurface knotTolerance>
<BSplineSurface controlPointTolerance>
<BSplineSurface fitTolerance>
<ColorIndex i>
<ControlPoint weight>
<DataString s>
<ElementProperty isVisible>
<ElementPropertyIndex i>
<Ellipse minorMajorRatio>
<Ellipse startParameter>
<Ellipse endParameter>
<FacettedSubmodel name>
<FacettedSubmodelReference submodel>
<Knot r>
<Matrix3x3 xx>
<Matrix3x3 yx>
<Matrix3x3 zx>
<Matrix3x3 xy>
<Matrix3x3 yy>
<Matrix3x3 zy>
<Matrix3x3 xz>
<Matrix3x3 yz>
<Matrix3x3 zz>
<Mesh mSize>
<Mesh nSize>
<Mesh isClosedM>
<Mesh isClosedN>
<Model app>
<Polyline isClosed>
<Submodel name>
<SubmodelReference submodel>
<Text fontName>
<Text fontType>
<Text isBold>
<Text isUnderlined>
<Text isOverlined>
<Text isHorizontallyMirrored>
<Text isVerticallyMirrored>
<TrueColor v1>
<TrueColor v2>
<TrueColor v3>
<TrueColor hasAlpha>
<TrueColor alpha>
<VertexIndex i>
<View isPlanView>
<View isPerspective>
<View isFrontClipped>
<View isBackClipped>
<View isTwisted>


DesignXml_V_beta1.xdr Elements

The following tables describe the DesignXML element types.

Document conventions:

  • [] - optional
  • []* - zero or more times
  • + - one or more times

<Administrative>
syntax: <Administrative >
seq
<Title>
<Subject>
<Author>
<Manager>
<Company>
<Category>
<Keywords>
<Comments>
<HyperlinkBase>
</Administrative>
content: eltOnly
order: seq
parents: Object
childen: Author, Category, Comments, Company, HyperlinkBase, Keywords, Manager, Subject, Title
attributes: (none)
model: closed
source:
<ElementType name="Administrative" content="eltOnly" order="seq" model="closed">
    <element type="Title"/>
    <element type="Subject"/>
    <element type="Author"/>
    <element type="Manager"/>
    <element type="Company"/>
    <element type="Category"/>
    <element type="Keywords"/>
    <element type="Comments"/>
    <element type="HyperlinkBase"/>
</ElementType>
<Angle>
syntax: <Angle
[ | angleUnits = enumeration: rad | degree | grads ]
 | t = r8
/>
content: empty
order: many (default)
parents: Obliquing, PerspectiveViewingAngle, SweepAngle, WorldZDisplayAngle
childen: (none)
attributes: angleUnits, t
model: closed
source:
<ElementType name="Angle" content="empty" model="closed">

    <attribute type="t"/>
    <attribute type="angleUnits"/>
</ElementType>
<Arc>
syntax: <Arc
[ quadraticCurveType = enumeration: Simple | Sector | Chord ]
>
seq
<Circle>
<StartVector>
<SweepAngle>
</Arc>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: Circle, StartVector, SweepAngle
attributes: quadraticCurveType
model: closed
source:
<ElementType name="Arc" content="eltOnly" order="seq" model="closed">

    <element type="SweepAngle"/>
</ElementType>
<AspectRatio>
syntax: <AspectRatio >
seq
<Length>
</AspectRatio>
content: eltOnly
order: seq
parents: View
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="AspectRatio" content="eltOnly" order="seq" model="closed">

    <element type="Length"/>
</ElementType>
<Author>
syntax: <Author >
seq
<DataString>
</Author>
content: eltOnly
order: seq
parents: Administrative
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="Author" content="eltOnly" order="seq" model="closed">
    <element type="DataString"/>
</ElementType>
<BackClip>
syntax: <BackClip >
seq
<Length>
</BackClip>
content: eltOnly
order: seq
parents: View
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="BackClip" content="eltOnly" order="seq" model="closed">

    <element type="Length"/>
</ElementType>
<BaseAndDirection>
syntax: <BaseAndDirection >
seq
<Circle>
</BaseAndDirection>
content: eltOnly
order: seq
parents: Cone, Cylinder
childen: Circle
attributes: (none)
model: closed
source:
<ElementType name="BaseAndDirection" content="eltOnly" order="seq" model="closed">
    <element type="Circle"/>
</ElementType>
<BaselineDirection>
syntax: <BaselineDirection >
seq
<Vector>
</BaselineDirection>
content: eltOnly
order: seq
parents: Text
childen: Vector
attributes: (none)
model: closed
source:
<ElementType name="BaselineDirection" content="eltOnly" order="seq" model="closed">
    <element type="Vector"/>
</ElementType>
<BoundaryRep>
syntax: <BoundaryRep
systemId = uri
>
seq
[ | <Color> ]
[ | <Link> ] *
</BoundaryRep>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: Color, Link
attributes: systemId
model: closed
source:
<ElementType name="BoundaryRep" content="eltOnly" order="seq" model="closed">

    <attribute type="systemId"/>
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
</ElementType>
<BSplineCurve>
syntax: <BSplineCurve
controlPointTolerance = r8
degree = i2
fitTolerance = r8
isClosed = boolean
isPeriodic = boolean
isRational = boolean
knotTolerance = r8
numberOfControlPoints = i2
numberOfKnots = i2
>
seq
[ | <Color> ]
[ | <Link> ] *
[ | <ControlPoint> ] *
[ | <Knot> ] *
</BSplineCurve>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: Color, ControlPoint, Knot, Link
attributes: controlPointTolerance, degree, fitTolerance, isClosed, isPeriodic, isRational, knotTolerance, numberOfControlPoints, numberOfKnots
model: closed
source:
<ElementType name="BSplineCurve" content="eltOnly" order="seq" model="closed">
    <AttributeType name="isClosed" dt:type="boolean" required="yes"/>
    <AttributeType name="isPeriodic" dt:type="boolean" required="yes"/>
    <AttributeType name="isRational" dt:type="boolean" required="yes"/>
    <AttributeType name="degree" dt:type="i2" required="yes"/>
    <AttributeType name="numberOfControlPoints" dt:type="i2" required="yes"/>
    <AttributeType name="numberOfKnots" dt:type="i2" required="yes"/>
    <AttributeType name="knotTolerance" dt:type="r8" required="yes"/>
    <AttributeType name="controlPointTolerance" dt:type="r8" required="yes"/>
    <AttributeType name="fitTolerance" dt:type="r8" required="yes"/>
    <attribute type="isClosed"/>
    <attribute type="isPeriodic"/>
    <attribute type="isRational"/>
    <attribute type="degree"/>
    <attribute type="numberOfControlPoints"/>
    <attribute type="numberOfKnots"/>
    <attribute type="knotTolerance"/>
    <attribute type="controlPointTolerance"/>
    <attribute type="fitTolerance"/>
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="ControlPoint" minOccurs="0" maxOccurs="*"/>
    <element type="Knot" minOccurs="0" maxOccurs="*"/>
</ElementType>
<BSplineSurface>
syntax: <BSplineSurface
controlPointTolerance = r8
degreeU = i2
degreeV = i2
fitTolerance = r8
isClosedU = boolean
isClosedV = boolean
isPeriodicU = boolean
isPeriodicV = boolean
isRational = boolean
knotTolerance = r8
numberOfControlPointsU = i2
numberOfControlPointsV = i2
numberOfKnotsU = i2
numberOfKnotsV = i2
>
seq
[ | <Color> ]
[ | <Link> ] *
[ | <ControlPoint> ] *
[ | <Knot> ] *
</BSplineSurface>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: Color, ControlPoint, Knot, Link
attributes: controlPointTolerance, degreeU, degreeV, fitTolerance, isClosedU, isClosedV, isPeriodicU, isPeriodicV, isRational, knotTolerance, numberOfControlPointsU, numberOfControlPointsV, numberOfKnotsU, numberOfKnotsV
model: closed
source:
<ElementType name="BSplineSurface" content="eltOnly" order="seq" model="closed">
    <AttributeType name="isClosedU" dt:type="boolean" required="yes"/>
    <AttributeType name="isClosedV" dt:type="boolean" required="yes"/>
    <AttributeType name="isPeriodicU" dt:type="boolean" required="yes"/>
    <AttributeType name="isPeriodicV" dt:type="boolean" required="yes"/>
    <AttributeType name="isRational" dt:type="boolean" required="yes"/>
    <AttributeType name="degreeU" dt:type="i2" required="yes"/>
    <AttributeType name="degreeV" dt:type="i2" required="yes"/>
    <AttributeType name="numberOfControlPointsU" dt:type="i2" required="yes"/>
    <AttributeType name="numberOfControlPointsV" dt:type="i2" required="yes"/>
    <AttributeType name="numberOfKnotsU" dt:type="i2" required="yes"/>
    <AttributeType name="numberOfKnotsV" dt:type="i2" required="yes"/>
    <AttributeType name="knotTolerance" dt:type="r8" required="yes"/>
    <AttributeType name="controlPointTolerance" dt:type="r8" required="yes"/>
    <AttributeType name="fitTolerance" dt:type="r8" required="yes"/>
    <attribute type="isClosedU"/>
    <attribute type="isClosedV"/>
    <attribute type="isPeriodicU"/>
    <attribute type="isPeriodicV"/>
    <attribute type="isRational"/>
    <attribute type="degreeU"/>
    <attribute type="degreeV"/>
    <attribute type="numberOfControlPointsU"/>
    <attribute type="numberOfControlPointsV"/>
    <attribute type="numberOfKnotsU"/>
    <attribute type="numberOfKnotsV"/>
    <attribute type="knotTolerance"/>
    <attribute type="controlPointTolerance"/>
    <attribute type="fitTolerance"/>
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>

    <element type="Knot" minOccurs="0" maxOccurs="*"/>
</ElementType>
<Category>
syntax: <Category >
seq
<DataString>
</Category>
content: eltOnly
order: seq
parents: Administrative
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="Category" content="eltOnly" order="seq" model="closed">
    <element type="DataString"/>
</ElementType>
<CenterPoint>
syntax: <CenterPoint >
seq
<Point>
</CenterPoint>
content: eltOnly
order: seq
parents: Circle, Ellipse, Sphere, Torus
childen: Point
attributes: (none)
model: closed
source:
<ElementType name="CenterPoint" content="eltOnly" order="seq" model="closed">
    <element type="Point"/>
</ElementType>
<Circle>
syntax: <Circle >
seq
[ | <Color> ]
[ | <Link> ] *
 | <CenterPoint>
 | <Radius>
[ | <Normal> ]
</Circle>
content: eltOnly
order: seq
parents: Arc, BaseAndDirection, Geometry3D, Submodel
childen: CenterPoint, Color, Link, Normal, Radius
attributes: (none)
model: closed
source:
<ElementType name="Circle" content="eltOnly" order="seq" model="closed">
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="CenterPoint"/>
    <element type="Radius"/>
    <element type="Normal" minOccurs="0" maxOccurs="1"/>
</ElementType>
<Color>
syntax: <Color >
one
<TrueColor>
<ColorIndex>
</Color>
content: eltOnly
order: one
parents: BoundaryRep, BSplineCurve, BSplineSurface, Circle, ElementProperty, Ellipse, FacettedFace, FacettedShell, FacettedSubmodel, FacettedSubmodelReference, Line, LineSegment, Mesh, Plane, Polyline, Ray, Sphere, Submodel, SubmodelReference, Text, Torus
childen: ColorIndex, TrueColor
attributes: (none)
model: closed
source:
<ElementType name="Color" content="eltOnly" order="one" model="closed">

    <element type="TrueColor"/>
    <element type="ColorIndex"/>
</ElementType>
<ColorIndex>
syntax: <ColorIndex
i = ui1
/>
content: empty
order: many (default)
parents: Color
childen: (none)
attributes: i
model: closed
source:
<ElementType name="ColorIndex" content="empty" model="closed">

    <AttributeType name="i" dt:type="ui1" required="yes"/>
    <attribute type="i"/>
</ElementType>
<ColorPalette>
syntax: <ColorPalette >
seq
<TrueColor> +
</ColorPalette>
content: eltOnly
order: seq
parents: Facetted3D, Geometry3D
childen: TrueColor
attributes: (none)
model: closed
source:
<ElementType name="ColorPalette" content="eltOnly" order="seq" model="closed">

    <!-- The real upper limit should be 256. -->
    <element type="TrueColor" minOccurs="1" maxOccurs="*"/>
</ElementType>
<Comments>
syntax: <Comments >
seq
<DataString>
</Comments>
content: eltOnly
order: seq
parents: Administrative
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="Comments" content="eltOnly" order="seq" model="closed">
    <element type="DataString"/>
</ElementType>
<Company>
syntax: <Company >
seq
<DataString>
</Company>
content: eltOnly
order: seq
parents: Administrative
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="Company" content="eltOnly" order="seq" model="closed">
    <element type="DataString"/>
</ElementType>
<Cone>
syntax: <Cone >
seq
 | <BaseAndDirection>
 | <Height>
[ | <TopRadius> ] *
</Cone>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: BaseAndDirection, Height, TopRadius
attributes: (none)
model: closed
source:
<ElementType name="Cone" content="eltOnly" order="seq" model="closed">
    <element type="BaseAndDirection"/>
    <element type="Height"/>
    <element type="TopRadius" minOccurs="0" maxOccurs="*"/>
</ElementType>
<ControlPoint>
syntax: <ControlPoint
[ weight = r8 ]
>
seq
<Point>
</ControlPoint>
content: eltOnly
order: seq
parents: BSplineCurve, BSplineSurface
childen: Point
attributes: weight
model: closed
source:
<ElementType name="ControlPoint" content="eltOnly" order="seq" model="closed">
    <AttributeType name="weight" dt:type="r8" required="no"/>
    <attribute type="weight"/>
    <element type="Point"/>
</ElementType>
<Cylinder>
syntax: <Cylinder >
seq
<BaseAndDirection>
<Height>
</Cylinder>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: BaseAndDirection, Height
attributes: (none)
model: closed
source:
<ElementType name="Cylinder" content="eltOnly" order="seq" model="closed">
    <element type="BaseAndDirection"/>
    <element type="Height"/>
</ElementType>
<DataString>
syntax: <DataString
[ s = string ]
/>
content: empty
order: many (default)
parents: Author, Category, Comments, Company, HyperlinkBase, Keywords, Link, Manager, Subject, Text, Title
childen: (none)
attributes: s
model: closed
source:
<ElementType name="DataString" content="empty" model="closed">

    <AttributeType name="s" dt:type="string"/>
    <attribute type="s"/>
</ElementType>
<Direction>
syntax: <Direction >
seq
<Vector>
</Direction>
content: eltOnly
order: seq
parents: Line, Ray
childen: Vector
attributes: (none)
model: closed
source:
<ElementType name="Direction" content="eltOnly" order="seq" model="closed">
    <element type="Vector"/>
</ElementType>
<EdgeProperties>
syntax: <EdgeProperties >
seq
<ElementProperty> +
</EdgeProperties>
content: eltOnly
order: seq
parents: Mesh
childen: ElementProperty
attributes: (none)
model: closed
source:
<ElementType name="EdgeProperties" content="eltOnly" order="seq" model="closed">
    <element type="ElementProperty" minOccurs="1" maxOccurs="*"/>
</ElementType>
<ElementProperty>
syntax: <ElementProperty
[ isVisible = boolean ]
>
seq
[ | <Color> ]
[ | <Link> ] *
</ElementProperty>
content: eltOnly
order: seq
parents: EdgeProperties, FaceProperties, FacettedShell
childen: Color, Link
attributes: isVisible
model: closed
source:
<ElementType name="ElementProperty" content="eltOnly" order="seq" model="closed">
    <AttributeType name="isVisible" dt:type="boolean" required="no" default="1"/>
    <attribute type="isVisible"/>
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
</ElementType>
<ElementPropertyIndex>
syntax: <ElementPropertyIndex
i = i4
/>
content: empty
order: many (default)
parents: FacettedFace
childen: (none)
attributes: i
model: closed
source:
<ElementType name="ElementPropertyIndex" content="empty" model="closed">
    <AttributeType name="i" dt:type="i4" required="yes"/>
    <attribute type="i"/>
</ElementType>
<Ellipse>
syntax: <Ellipse
 | endParameter = r8
 | minorMajorRatio = r8
[ | quadraticCurveType = enumeration: Simple | Sector | Chord ]
 | startParameter = r8
>
seq
[ | <Color> ]
[ | <Link> ] *
 | <CenterPoint>
 | <MajorAxis>
[ | <Normal> ]
</Ellipse>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: CenterPoint, Color, Link, MajorAxis, Normal
attributes: endParameter, minorMajorRatio, quadraticCurveType, startParameter
model: closed
source:
<ElementType name="Ellipse" content="eltOnly" order="seq" model="closed">

    <AttributeType name="minorMajorRatio" dt:type="r8" required="yes"/>
    <AttributeType name="startParameter" dt:type="r8" required="yes"/>
    <AttributeType name="endParameter" dt:type="r8" required="yes"/>
    <attribute type="minorMajorRatio"/>
    <attribute type="startParameter"/>
    <attribute type="endParameter"/>
    <attribute type="quadraticCurveType"/>
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="CenterPoint"/>
    <element type="MajorAxis"/>
    <element type="Normal" minOccurs="0" maxOccurs="1"/>
</ElementType>
<EndPoint>
syntax: <EndPoint >
seq
<Point>
</EndPoint>
content: eltOnly
order: seq
parents: LineSegment
childen: Point
attributes: (none)
model: closed
source:
<ElementType name="EndPoint" content="eltOnly" order="seq" model="closed">
    <element type="Point"/>
</ElementType>
<FaceProperties>
syntax: <FaceProperties >
seq
<ElementProperty> +
</FaceProperties>
content: eltOnly
order: seq
parents: Mesh
childen: ElementProperty
attributes: (none)
model: closed
source:
<ElementType name="FaceProperties" content="eltOnly" order="seq" model="closed">
    <element type="ElementProperty" minOccurs="1" maxOccurs="*"/>
</ElementType>
<Facetted3D>
syntax: <Facetted3D
[ | angleUnits = enumeration: rad | degree | grads ]
[ | lengthUnits = enumeration: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec ]
>
seq
one
<ForwardReference>
seq
many
<Point>
<LineSegment>
<Line>
<Ray>
<Polyline>
<Mesh>
<FacettedShell>
<Text>
<FacettedSubmodel>
<FacettedSubmodelReference>
[ <ColorPalette> ]
</Facetted3D>
content: eltOnly
order: seq
parents: Object
childen: ColorPalette, FacettedShell, FacettedSubmodel, FacettedSubmodelReference, ForwardReference, Line, LineSegment, Mesh, Point, Polyline, Ray, Text
attributes: angleUnits, lengthUnits
model: closed
source:
<ElementType name="Facetted3D" content="eltOnly" order="seq" model="closed">
    <attribute type="lengthUnits"/>
    <attribute type="angleUnits"/>
    <!-- Contents may be either:
                1. A set of geometric elements plus an optional color pallette.
                or
                2. A URI to another XML file that has a Facetted3D element  -->
    <group order="one">
        <element type="ForwardReference"/>
        <group order="seq">
            <group order="many">
                <element type="Point"/>
                <element type="LineSegment"/>
                <element type="Line"/>
                <element type="Ray"/>
                <element type="Polyline"/>
                <element type="Mesh"/>
                <element type="FacettedShell"/>
                <element type="Text"/>
                <element type="FacettedSubmodel"/>
                <element type="FacettedSubmodelReference"/>
            </group>
            <element type="ColorPalette" minOccurs="0" maxOccurs="1"/>
        </group>
    </group>
</ElementType>
<FacettedFace>
syntax: <FacettedFace >
seq
[ <Color> ]
[ <Link> ] *
[ <Normal> ]
many
 | <VertexIndex>
[ | <ElementPropertyIndex> ]
</FacettedFace>
content: eltOnly
order: seq
parents: FacettedShell
childen: Color, ElementPropertyIndex, Link, Normal, VertexIndex
attributes: (none)
model: closed
source:
<ElementType name="FacettedFace" content="eltOnly" order="seq" model="closed">
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="Normal" minOccurs="0" maxOccurs="1"/>
    <!-- The following group defines a closed loop of linear edges,
                with optional overriding properties. -->
    <group order="many">
        <element type="VertexIndex"/>
        <element type="ElementPropertyIndex" minOccurs="0" maxOccurs="1"/>
    </group>
</ElementType>
<FacettedShell>
syntax: <FacettedShell >
seq
[ | <Color> ]
[ | <Link> ] *
 | <MaximumDeviation>
[ | <FacettedFace> ] *
 | <Vertices>
[ | <NormalVectors> ]
[ | <ElementProperty> ] *
</FacettedShell>
content: eltOnly
order: seq
parents: Facetted3D, FacettedSubmodel, Geometry3D, Submodel
childen: Color, ElementProperty, FacettedFace, Link, MaximumDeviation, NormalVectors, Vertices
attributes: (none)
model: closed
source:
<ElementType name="FacettedShell" content="eltOnly" order="seq" model="closed">

    <element type="ElementProperty" minOccurs="0" maxOccurs="*"/>
</ElementType>
<FacettedSubmodel>
syntax: <FacettedSubmodel
[ | angleUnits = enumeration: rad | degree | grads ]
[ | lengthUnits = enumeration: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec ]
 | name = id
>
seq
[ <Color> ]
[ <Link> ] *
many
<Point>
<LineSegment>
<Line>
<Ray>
<Polyline>
<Mesh>
<FacettedShell>
<Text>
<FacettedSubmodelReference>
</FacettedSubmodel>
content: eltOnly
order: seq
parents: Facetted3D, Geometry3D
childen: Color, FacettedShell, FacettedSubmodelReference, Line, LineSegment, Link, Mesh, Point, Polyline, Ray, Text
attributes: angleUnits, lengthUnits, name
model: closed
source:
<ElementType name="FacettedSubmodel" content="eltOnly" order="seq" model="closed">

    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <group order="many">
        <element type="Point"/>
        <element type="LineSegment"/>
        <element type="Line"/>
        <element type="Ray"/>
        <element type="Polyline"/>
        <element type="Mesh"/>
        <element type="FacettedShell"/>
        <element type="Text"/>
        <element type="FacettedSubmodelReference"/>
    </group>
</ElementType>
<FacettedSubmodelReference>
syntax: <FacettedSubmodelReference
submodel = idref
>
seq
[ | <Color> ]
[ | <Link> ] *
[ | <LinearCoordinateTransform> ]
</FacettedSubmodelReference>
content: eltOnly
order: seq
parents: Facetted3D, FacettedSubmodel, Geometry3D, Submodel
childen: Color, LinearCoordinateTransform, Link
attributes: submodel
model: closed
source:
<ElementType name="FacettedSubmodelReference" content="eltOnly" order="seq" model="closed">

    <AttributeType name="submodel" dt:type="idref" required="yes"/>
    <attribute type="submodel"/>
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="LinearCoordinateTransform" minOccurs="0" maxOccurs="1"/>
</ElementType>
<ForwardReference>
syntax: <ForwardReference
systemId = uri
/>
content: empty
order: many (default)
parents: Facetted3D, Geometry3D, Model
childen: (none)
attributes: systemId
model: closed
source:
<ElementType name="ForwardReference" content="empty" model="closed">
    <attribute type="systemId"/>
</ElementType>
<FrontClip>
syntax: <FrontClip >
seq
<Length>
</FrontClip>
content: eltOnly
order: seq
parents: View
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="FrontClip" content="eltOnly" order="seq" model="closed">

    <element type="Length"/>
</ElementType>
<Geometry3D>
syntax: <Geometry3D
[ | angleUnits = enumeration: rad | degree | grads ]
[ | lengthUnits = enumeration: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec ]
>
seq
one
<ForwardReference>
seq
many
<Point>
<LineSegment>
<Line>
<Ray>
<Polyline>
<Mesh>
<FacettedShell>
<Text>
<FacettedSubmodel>
<FacettedSubmodelReference>
<Arc>
<Circle>
<Ellipse>
<BSplineCurve>
<Cylinder>
<Cone>
<Sphere>
<Torus>
<Plane>
<BSplineSurface>
<BoundaryRep>
<Submodel>
<SubmodelReference>
[ <ColorPalette> ]
</Geometry3D>
content: eltOnly
order: seq
parents: Object
childen: Arc, BoundaryRep, BSplineCurve, BSplineSurface, Circle, ColorPalette, Cone, Cylinder, Ellipse, FacettedShell, FacettedSubmodel, FacettedSubmodelReference, ForwardReference, Line, LineSegment, Mesh, Plane, Point, Polyline, Ray, Sphere, Submodel, SubmodelReference, Text, Torus
attributes: angleUnits, lengthUnits
model: closed
source:
<ElementType name="Geometry3D" content="eltOnly" order="seq" model="closed">
    <attribute type="lengthUnits"/>
    <attribute type="angleUnits"/>
    <!-- Contents may be either:
                1. A set of geometric elements plus an optional color pallette.
                or
                2. A URI to another XML file that has a Facetted3D element  -->
    <group order="one">
        <element type="ForwardReference"/>
        <group order="seq">
            <group order="many">
                <element type="Point"/>
                <element type="LineSegment"/>
                <element type="Line"/>
                <element type="Ray"/>
                <element type="Polyline"/>
                <element type="Mesh"/>
                <element type="FacettedShell"/>
                <element type="Text"/>
                <element type="FacettedSubmodel"/>
                <element type="FacettedSubmodelReference"/>
                <element type="Arc"/>
                <element type="Circle"/>
                <element type="Ellipse"/>
                <element type="BSplineCurve"/>
                <element type="Cylinder"/>
                <element type="Cone"/>
                <element type="Sphere"/>
                <element type="Torus"/>
                <element type="Plane"/>
                <element type="BSplineSurface"/>
                <element type="BoundaryRep"/>
                <element type="Submodel"/>
                <element type="SubmodelReference"/>
            </group>
            <element type="ColorPalette" minOccurs="0" maxOccurs="1"/>
        </group>
    </group>
</ElementType>
<Height>
syntax: <Height >
seq
<Length>
</Height>
content: eltOnly
order: seq
parents: Cone, Cylinder, Text
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="Height" content="eltOnly" order="seq" model="closed">
    <element type="Length"/>
</ElementType>
<HyperlinkBase>
syntax: <HyperlinkBase >
seq
<DataString>
</HyperlinkBase>
content: eltOnly
order: seq
parents: Administrative
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="HyperlinkBase" content="eltOnly" order="seq" model="closed">
    <element type="DataString"/>
</ElementType>
<Keywords>
syntax: <Keywords >
seq
<DataString>
</Keywords>
content: eltOnly
order: seq
parents: Administrative
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="Keywords" content="eltOnly" order="seq" model="closed">
    <element type="DataString"/>
</ElementType>
<Knot>
syntax: <Knot
[ r = r8 ]
/>
content: empty
order: many (default)
parents: BSplineCurve, BSplineSurface
childen: (none)
attributes: r
model: closed
source:
<ElementType name="Knot" content="empty" model="closed">
    <AttributeType name="r" dt:type="r8" required="no"/>
    <attribute type="r"/>
</ElementType>
<Length>
syntax: <Length
[ | lengthUnits = enumeration: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec ]
 | x = r8
/>
content: empty
order: many (default)
parents: AspectRatio, BackClip, FrontClip, Height, MajorRadius, MaximumDeviation, MinorRadius, Radius, TopRadius, ViewHeight
childen: (none)
attributes: lengthUnits, x
model: closed
source:
<ElementType name="Length" content="empty" model="closed">

    <attribute type="x"/>
    <attribute type="lengthUnits"/>
</ElementType>
<Line>
syntax: <Line >
seq
[ | <Color> ]
[ | <Link> ] *
 | <PointOnLine>
 | <Direction>
</Line>
content: eltOnly
order: seq
parents: Facetted3D, FacettedSubmodel, Geometry3D, Submodel
childen: Color, Direction, Link, PointOnLine
attributes: (none)
model: closed
source:
<ElementType name="Line" content="eltOnly" order="seq" model="closed">

    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="PointOnLine"/>
    <element type="Direction"/>
</ElementType>
<LinearCoordinateTransform>
syntax: <LinearCoordinateTransform >
seq
[ | <Orientation> ]
[ | <Translation> ]
</LinearCoordinateTransform>
content: eltOnly
order: seq
parents: FacettedSubmodelReference, SubmodelReference
childen: Orientation, Translation
attributes: (none)
model: closed
source:
<ElementType name="LinearCoordinateTransform" content="eltOnly" order="seq" model="closed">

    <element type="Orientation" minOccurs="0"/>
    <element type="Translation" minOccurs="0"/>
</ElementType>
<LineSegment>
syntax: <LineSegment >
seq
[ | <Color> ]
[ | <Link> ] *
 | <StartPoint>
 | <EndPoint>
</LineSegment>
content: eltOnly
order: seq
parents: Facetted3D, FacettedSubmodel, Geometry3D, Submodel
childen: Color, EndPoint, Link, StartPoint
attributes: (none)
model: closed
source:
<ElementType name="LineSegment" content="eltOnly" order="seq" model="closed">

    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="StartPoint"/>
    <element type="EndPoint"/>
</ElementType>
<Link>
syntax: <Link >
seq
<DataString>
</Link>
content: eltOnly
order: seq
parents: BoundaryRep, BSplineCurve, BSplineSurface, Circle, ElementProperty, Ellipse, FacettedFace, FacettedShell, FacettedSubmodel, FacettedSubmodelReference, Line, LineSegment, Mesh, Plane, Polyline, Ray, Sphere, Submodel, SubmodelReference, Text, Torus
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="Link" content="eltOnly" order="seq" model="closed">

    <element type="DataString"/>
</ElementType>
<LocalModel>
syntax: <LocalModel >
mixed content
</LocalModel>
content: mixed
order: many (default)
parents: Model
childen: (none)
attributes: (none)
model: open
source:
<ElementType name="LocalModel" content="mixed" model="open"/>
<MajorAxis>
syntax: <MajorAxis >
seq
<Vector>
</MajorAxis>
content: eltOnly
order: seq
parents: Ellipse
childen: Vector
attributes: (none)
model: closed
source:
<ElementType name="MajorAxis" content="eltOnly" order="seq" model="closed">
    <element type="Vector"/>
</ElementType>
<MajorRadius>
syntax: <MajorRadius >
seq
<Length>
</MajorRadius>
content: eltOnly
order: seq
parents: Torus
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="MajorRadius" content="eltOnly" order="seq" model="closed">
    <element type="Length"/>
</ElementType>
<Manager>
syntax: <Manager >
seq
<DataString>
</Manager>
content: eltOnly
order: seq
parents: Administrative
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="Manager" content="eltOnly" order="seq" model="closed">
    <element type="DataString"/>
</ElementType>
<Matrix3x3>
syntax: <Matrix3x3
 | xx = r8
 | xy = r8
[ | xz = r8 ]
 | yx = r8
 | yy = r8
[ | yz = r8 ]
[ | zx = r8 ]
[ | zy = r8 ]
[ | zz = r8 ]
/>
content: empty
order: seq
parents: Orientation
childen: (none)
attributes: xx, xy, xz, yx, yy, yz, zx, zy, zz
model: closed
source:
<ElementType name="Matrix3x3" content="empty" order="seq" model="closed">

    <AttributeType name="xx" dt:type="r8" required="yes"/>
    <AttributeType name="yx" dt:type="r8" required="yes"/>
    <AttributeType name="zx" dt:type="r8" required="no" default="0.0"/>
    <AttributeType name="xy" dt:type="r8" required="yes"/>
    <AttributeType name="yy" dt:type="r8" required="yes"/>
    <AttributeType name="zy" dt:type="r8" required="no" default="0.0"/>
    <AttributeType name="xz" dt:type="r8" required="no" default="0.0"/>
    <AttributeType name="yz" dt:type="r8" required="no" default="0.0"/>
    <AttributeType name="zz" dt:type="r8" required="no" default="0.0"/>
    <attribute type="xx"/>
    <attribute type="yx"/>
    <attribute type="zx"/>
    <attribute type="xy"/>
    <attribute type="yy"/>
    <attribute type="zy"/>
    <attribute type="xz"/>
    <attribute type="yz"/>
    <attribute type="zz"/>
</ElementType>
<MaximumDeviation>
syntax: <MaximumDeviation >
seq
<Length>
</MaximumDeviation>
content: eltOnly
order: seq
parents: FacettedShell
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="MaximumDeviation" content="eltOnly" order="seq" model="closed">
    <element type="Length"/>
</ElementType>
<Mesh>
syntax: <Mesh
[ | isClosedM = boolean ]
[ | isClosedN = boolean ]
 | mSize = i4
 | nSize = i4
>
seq
[ | <Color> ]
[ | <Link> ] *
 | <Vertices>
[ | <RasterImage> ]
[ | <NormalVectors> ]
[ | <EdgeProperties> ]
[ | <FaceProperties> ]
</Mesh>
content: eltOnly
order: seq
parents: Facetted3D, FacettedSubmodel, Geometry3D, Submodel
childen: Color, EdgeProperties, FaceProperties, Link, NormalVectors, RasterImage, Vertices
attributes: isClosedM, isClosedN, mSize, nSize
model: closed
source:
<ElementType name="Mesh" content="eltOnly" order="seq" model="closed">

    <element type="FaceProperties" minOccurs="0" maxOccurs="1"/>
</ElementType>
<MinorRadius>
syntax: <MinorRadius >
seq
<Length>
</MinorRadius>
content: eltOnly
order: seq
parents: Torus
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="MinorRadius" content="eltOnly" order="seq" model="closed">
    <element type="Length"/>
</ElementType>
<Model>
syntax: <Model
app = nmtoken
>
seq
one
<LocalModel>
<ForwardReference>
</Model>
content: eltOnly
order: seq
parents: Object
childen: ForwardReference, LocalModel
attributes: app
model: closed
source:
<ElementType name="Model" content="eltOnly" order="seq" model="closed">
    <AttributeType name="app" dt:type="nmtoken" required="yes"/>
    <attribute type="app"/>
    <!-- Contents may be either:
                1. An optional color palette plus a set of geometric elements.
                or
                2. A URI to another XML file that has a Facetted3D element  -->
    <group order="one">
        <element type="LocalModel"/>
        <element type="ForwardReference"/>
    </group>
</ElementType>
<Normal>
syntax: <Normal >
seq
<Vector>
</Normal>
content: eltOnly
order: seq
parents: Circle, Ellipse, FacettedFace, Plane, Text, Torus
childen: Vector
attributes: (none)
model: closed
source:
<ElementType name="Normal" content="eltOnly" order="seq" model="closed">

    <element type="Vector"/>
</ElementType>
<NormalVectors>
syntax: <NormalVectors >
seq
<Vector> +
</NormalVectors>
content: eltOnly
order: seq
parents: FacettedShell, Mesh
childen: Vector
attributes: (none)
model: closed
source:
<ElementType name="NormalVectors" content="eltOnly" order="seq" model="closed">
    <element type="Vector" minOccurs="1" maxOccurs="*"/>
</ElementType>
<Object>
syntax: <Object >
seq
[ | <Administrative> ]
[ | <Raster2D> ] *
[ | <Vector2D> ] *
[ | <Facetted3D> ]
[ | <Geometry3D> ]
[ | <Model> ] *
</Object>
content: eltOnly
order: seq
parents: No parents found. This is probably the document element.
childen: Administrative, Facetted3D, Geometry3D, Model, Raster2D, Vector2D
attributes: (none)
model: closed
source:
<ElementType name="Object" content="eltOnly" order="seq" model="closed">
    <element type="Administrative" minOccurs="0" maxOccurs="1"/>
    <element type="Raster2D" minOccurs="0" maxOccurs="*"/>
    <element type="Vector2D" minOccurs="0" maxOccurs="*"/>
    <element type="Facetted3D" minOccurs="0" maxOccurs="1"/>
    <element type="Geometry3D" minOccurs="0" maxOccurs="1"/>
    <element type="Model" minOccurs="0" maxOccurs="*"/>
</ElementType>
<Obliquing>
syntax: <Obliquing >
seq
<Angle>
</Obliquing>
content: eltOnly
order: seq
parents: Text
childen: Angle
attributes: (none)
model: closed
source:
<ElementType name="Obliquing" content="eltOnly" order="seq" model="closed">
    <element type="Angle"/>
</ElementType>
<Orientation>
syntax: <Orientation >
seq
<Matrix3x3>
</Orientation>
content: eltOnly
order: seq
parents: LinearCoordinateTransform
childen: Matrix3x3
attributes: (none)
model: closed
source:
<ElementType name="Orientation" content="eltOnly" order="seq" model="closed">

    <element type="Matrix3x3"/>
</ElementType>
<PerspectiveViewingAngle>
syntax: <PerspectiveViewingAngle >
seq
<Angle>
</PerspectiveViewingAngle>
content: eltOnly
order: seq
parents: View
childen: Angle
attributes: (none)
model: closed
source:
<ElementType name="PerspectiveViewingAngle" content="eltOnly" order="seq" model="closed">

    <element type="Angle"/>
</ElementType>
<Plane>
syntax: <Plane >
seq
[ | <Color> ]
[ | <Link> ] *
 | <Point>
 | <Normal>
</Plane>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: Color, Link, Normal, Point
attributes: (none)
model: closed
source:
<ElementType name="Plane" content="eltOnly" order="seq" model="closed">
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="Point"/>
    <element type="Normal"/>
</ElementType>
<Point>
syntax: <Point
[ | lengthUnits = enumeration: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec ]
 | x = r8
 | y = r8
[ | z = r8 ]
/>
content: empty
order: many (default)
parents: CenterPoint, ControlPoint, EndPoint, Facetted3D, FacettedSubmodel, Geometry3D, Plane, PointOnLine, Position, StartPoint, Submodel, TargetPoint, Vertices
childen: (none)
attributes: lengthUnits, x, y, z
model: closed
source:
<ElementType name="Point" content="empty" model="closed">

    <attribute type="x"/>
    <attribute type="y"/>
    <attribute type="z"/>
    <attribute type="lengthUnits"/>
</ElementType>
<PointOnLine>
syntax: <PointOnLine >
seq
<Point>
</PointOnLine>
content: eltOnly
order: seq
parents: Line, Ray
childen: Point
attributes: (none)
model: closed
source:
<ElementType name="PointOnLine" content="eltOnly" order="seq" model="closed">
    <element type="Point"/>
</ElementType>
<Polyline>
syntax: <Polyline
[ isClosed = boolean ]
>
seq
[ | <Color> ]
[ | <Link> ] *
 | <Vertices>
</Polyline>
content: eltOnly
order: seq
parents: Facetted3D, FacettedSubmodel, Geometry3D, Submodel
childen: Color, Link, Vertices
attributes: isClosed
model: closed
source:
<ElementType name="Polyline" content="eltOnly" order="seq" model="closed">

    <AttributeType name="isClosed" dt:type="boolean" required="no" default="0"/>
    <attribute type="isClosed"/>
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="Vertices" minOccurs="1" maxOccurs="1"/>
</ElementType>
<Position>
syntax: <Position >
seq
<Point>
</Position>
content: eltOnly
order: seq
parents: Text
childen: Point
attributes: (none)
model: closed
source:
<ElementType name="Position" content="eltOnly" order="seq" model="closed">
    <element type="Point"/>
</ElementType>
<Radius>
syntax: <Radius >
seq
<Length>
</Radius>
content: eltOnly
order: seq
parents: Circle, Sphere
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="Radius" content="eltOnly" order="seq" model="closed">
    <element type="Length"/>
</ElementType>
<Raster2D>
syntax: <Raster2D
systemId = uri
>
seq
[ <RenderSpecification> ]
</Raster2D>
content: eltOnly
order: seq
parents: Object
childen: RenderSpecification
attributes: systemId
model: closed
source:
<ElementType name="Raster2D" content="eltOnly" order="seq" model="closed">
    <attribute type="systemId"/>
    <element type="RenderSpecification" minOccurs="0" maxOccurs="1"/>
</ElementType>
<RasterImage>
syntax: <RasterImage
systemId = uri
/>
content: empty
order: seq
parents: Mesh
childen: (none)
attributes: systemId
model: closed
source:
<ElementType name="RasterImage" content="empty" order="seq" model="closed">

    <attribute type="systemId"/>
</ElementType>
<Ray>
syntax: <Ray >
seq
[ | <Color> ]
[ | <Link> ] *
 | <PointOnLine>
 | <Direction>
</Ray>
content: eltOnly
order: seq
parents: Facetted3D, FacettedSubmodel, Geometry3D, Submodel
childen: Color, Direction, Link, PointOnLine
attributes: (none)
model: closed
source:
<ElementType name="Ray" content="eltOnly" order="seq" model="closed">

    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="PointOnLine"/>
    <element type="Direction"/>
</ElementType>
<RenderSpecification>
syntax: <RenderSpecification
[ renderMode = enumeration: Plan | Wireframe | Hidden | FlatShade | Gouraud | FlatShadeWithWireframe | GouraudWithWireframe | Phong | Photo ]
>
seq
<View>
</RenderSpecification>
content: eltOnly
order: seq
parents: Raster2D, Vector2D
childen: View
attributes: renderMode
model: closed
source:
<ElementType name="RenderSpecification" content="eltOnly" order="seq" model="closed">

    <attribute type="renderMode"/>
    <element type="View" minOccurs="1" maxOccurs="1"/>
</ElementType>
<Sphere>
syntax: <Sphere >
seq
[ | <Color> ]
[ | <Link> ] *
 | <CenterPoint>
 | <Radius>
</Sphere>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: CenterPoint, Color, Link, Radius
attributes: (none)
model: closed
source:
<ElementType name="Sphere" content="eltOnly" order="seq" model="closed">
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="CenterPoint"/>
    <element type="Radius"/>
</ElementType>
<StartPoint>
syntax: <StartPoint >
seq
<Point>
</StartPoint>
content: eltOnly
order: seq
parents: LineSegment
childen: Point
attributes: (none)
model: closed
source:
<ElementType name="StartPoint" content="eltOnly" order="seq" model="closed">
    <element type="Point"/>
</ElementType>
<StartVector>
syntax: <StartVector >
seq
<Vector>
</StartVector>
content: eltOnly
order: seq
parents: Arc
childen: Vector
attributes: (none)
model: closed
source:
<ElementType name="StartVector" content="eltOnly" order="seq" model="closed">
    <element type="Vector"/>
</ElementType>
<Subject>
syntax: <Subject >
seq
<DataString>
</Subject>
content: eltOnly
order: seq
parents: Administrative
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="Subject" content="eltOnly" order="seq" model="closed">
    <element type="DataString"/>
</ElementType>
<Submodel>
syntax: <Submodel
[ | angleUnits = enumeration: rad | degree | grads ]
[ | lengthUnits = enumeration: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec ]
 | name = id
>
seq
[ <Color> ]
[ <Link> ] *
many
<Point>
<LineSegment>
<Line>
<Ray>
<Polyline>
<Mesh>
<FacettedShell>
<Text>
<FacettedSubmodelReference>
<Arc>
<Circle>
<Ellipse>
<BSplineCurve>
<Cylinder>
<Sphere>
<Cone>
<Torus>
<Plane>
<BSplineSurface>
<BoundaryRep>
<SubmodelReference>
</Submodel>
content: eltOnly
order: seq
parents: Geometry3D
childen: Arc, BoundaryRep, BSplineCurve, BSplineSurface, Circle, Color, Cone, Cylinder, Ellipse, FacettedShell, FacettedSubmodelReference, Line, LineSegment, Link, Mesh, Plane, Point, Polyline, Ray, Sphere, SubmodelReference, Text, Torus
attributes: angleUnits, lengthUnits, name
model: closed
source:
<ElementType name="Submodel" content="eltOnly" order="seq" model="closed">

    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <group order="many">
        <element type="Point"/>
        <element type="LineSegment"/>
        <element type="Line"/>
        <element type="Ray"/>
        <element type="Polyline"/>
        <element type="Mesh"/>
        <element type="FacettedShell"/>
        <element type="Text"/>
        <element type="FacettedSubmodelReference"/>
        <element type="Arc"/>
        <element type="Circle"/>
        <element type="Ellipse"/>
        <element type="BSplineCurve"/>
        <element type="Cylinder"/>
        <element type="Sphere"/>
        <element type="Cone"/>
        <element type="Torus"/>
        <element type="Plane"/>
        <element type="BSplineSurface"/>
        <element type="BoundaryRep"/>
        <element type="SubmodelReference"/>
    </group>
</ElementType>
<SubmodelReference>
syntax: <SubmodelReference
submodel = idref
>
seq
[ | <Color> ]
[ | <Link> ] *
[ | <LinearCoordinateTransform> ]
</SubmodelReference>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: Color, LinearCoordinateTransform, Link
attributes: submodel
model: closed
source:
<ElementType name="SubmodelReference" content="eltOnly" order="seq" model="closed">

    <AttributeType name="submodel" dt:type="idref" required="yes"/>
    <attribute type="submodel"/>
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="LinearCoordinateTransform" minOccurs="0" maxOccurs="1"/>
</ElementType>
<SweepAngle>
syntax: <SweepAngle >
seq
<Angle>
</SweepAngle>
content: eltOnly
order: seq
parents: Arc
childen: Angle
attributes: (none)
model: closed
source:
<ElementType name="SweepAngle" content="eltOnly" order="seq" model="closed">
    <element type="Angle"/>
</ElementType>
<TargetPoint>
syntax: <TargetPoint >
seq
<Point>
</TargetPoint>
content: eltOnly
order: seq
parents: View
childen: Point
attributes: (none)
model: closed
source:
<ElementType name="TargetPoint" content="eltOnly" order="seq" model="closed">

    <element type="Point"/>
</ElementType>
<Text>
syntax: <Text
 | fontName = string
[ | fontType = enumeration: TrueType | SHX ]
[ | isBold = boolean ]
[ | isHorizontallyMirrored = boolean ]
[ | isOverlined = boolean ]
[ | isUnderlined = boolean ]
[ | isVerticallyMirrored = boolean ]
>
seq
 | <DataString>
[ | <Color> ]
[ | <Link> ] *
 | <Position>
 | <Height>
[ | <Obliquing> ]
[ | <BaselineDirection> ]
[ | <Normal> ]
</Text>
content: eltOnly
order: seq
parents: Facetted3D, FacettedSubmodel, Geometry3D, Submodel
childen: BaselineDirection, Color, DataString, Height, Link, Normal, Obliquing, Position
attributes: fontName, fontType, isBold, isHorizontallyMirrored, isOverlined, isUnderlined, isVerticallyMirrored
model: closed
source:
<ElementType name="Text" content="eltOnly" order="seq" model="closed">

    <element type="Position"/>
    <element type="Height"/>
    <element type="Obliquing" minOccurs="0" maxOccurs="1"/>
    <element type="BaselineDirection" minOccurs="0" maxOccurs="1"/>
    <element type="Normal" minOccurs="0" maxOccurs="1"/>
</ElementType>
<Title>
syntax: <Title >
seq
<DataString>
</Title>
content: eltOnly
order: seq
parents: Administrative
childen: DataString
attributes: (none)
model: closed
source:
<ElementType name="Title" content="eltOnly" order="seq" model="closed">
    <element type="DataString"/>
</ElementType>
<TopRadius>
syntax: <TopRadius >
seq
<Length>
</TopRadius>
content: eltOnly
order: seq
parents: Cone
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="TopRadius" content="eltOnly" order="seq" model="closed">
    <element type="Length"/>
</ElementType>
<Torus>
syntax: <Torus >
seq
[ | <Color> ]
[ | <Link> ] *
 | <CenterPoint>
 | <MajorRadius>
 | <MinorRadius>
[ | <Normal> ]
</Torus>
content: eltOnly
order: seq
parents: Geometry3D, Submodel
childen: CenterPoint, Color, Link, MajorRadius, MinorRadius, Normal
attributes: (none)
model: closed
source:
<ElementType name="Torus" content="eltOnly" order="seq" model="closed">
    <element type="Color" minOccurs="0" maxOccurs="1"/>
    <element type="Link" minOccurs="0" maxOccurs="*"/>
    <element type="CenterPoint"/>
    <element type="MajorRadius"/>
    <element type="MinorRadius"/>
    <element type="Normal" minOccurs="0" maxOccurs="1"/>
</ElementType>
<Translation>
syntax: <Translation >
seq
<Vector>
</Translation>
content: eltOnly
order: seq
parents: LinearCoordinateTransform
childen: Vector
attributes: (none)
model: closed
source:
<ElementType name="Translation" content="eltOnly" order="seq" model="closed">

    <element type="Vector"/>
</ElementType>
<TrueColor>
syntax: <TrueColor
[ | alpha = ui1 ]
[ | colorSpace = enumeration: HSV | RGB | YIQ ]
[ | hasAlpha = boolean ]
 | v1 = ui1
 | v2 = ui1
 | v3 = ui1
/>
content: empty
order: many (default)
parents: Color, ColorPalette
childen: (none)
attributes: alpha, colorSpace, hasAlpha, v1, v2, v3
model: closed
source:
<ElementType name="TrueColor" content="empty" model="closed">

    <AttributeType name="v1" dt:type="ui1" required="yes"/>
    <AttributeType name="v2" dt:type="ui1" required="yes"/>
    <AttributeType name="v3" dt:type="ui1" required="yes"/>
    <AttributeType name="hasAlpha" dt:type="boolean" required="no" default="0"/>
    <AttributeType name="alpha" dt:type="ui1" required="no"/>
    <attribute type="v1"/>
    <attribute type="v2"/>
    <attribute type="v3"/>
    <attribute type="hasAlpha"/>
    <attribute type="alpha"/>
    <attribute type="colorSpace"/>
</ElementType>
<Vector>
syntax: <Vector
[ | lengthUnits = enumeration: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec ]
 | x = r8
 | y = r8
[ | z = r8 ]
/>
content: empty
order: seq
parents: BaselineDirection, Direction, MajorAxis, Normal, NormalVectors, StartVector, Translation, ViewDirection
childen: (none)
attributes: lengthUnits, x, y, z
model: closed
source:
<ElementType name="Vector" content="empty" order="seq" model="closed">

    <attribute type="x"/>
    <attribute type="y"/>
    <attribute type="z"/>
    <attribute type="lengthUnits"/>
</ElementType>
<Vector2D>
syntax: <Vector2D
[ | angleUnits = enumeration: rad | degree | grads ]
[ | lengthUnits = enumeration: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec ]
 | systemId = uri
>
seq
[ <RenderSpecification> ]
</Vector2D>
content: eltOnly
order: seq
parents: Object
childen: RenderSpecification
attributes: angleUnits, lengthUnits, systemId
model: closed
source:
<ElementType name="Vector2D" content="eltOnly" order="seq" model="closed">
    <attribute type="systemId"/>
    <attribute type="lengthUnits"/>
    <attribute type="angleUnits"/>
    <element type="RenderSpecification" minOccurs="0" maxOccurs="1"/>
</ElementType>
<VertexIndex>
syntax: <VertexIndex
i = i4
/>
content: empty
order: many (default)
parents: FacettedFace
childen: (none)
attributes: i
model: closed
source:
<ElementType name="VertexIndex" content="empty" model="closed">
    <AttributeType name="i" dt:type="i4" required="yes"/>
    <attribute type="i"/>
</ElementType>
<Vertices>
syntax: <Vertices >
seq
<Point>
<Point> +
</Vertices>
content: eltOnly
order: seq
parents: FacettedShell, Mesh, Polyline
childen: Point, Point
attributes: (none)
model: closed
source:
<ElementType name="Vertices" content="eltOnly" order="seq" model="closed">

    <element type="Point" minOccurs="1" maxOccurs="1"/>
    <element type="Point" minOccurs="1" maxOccurs="*"/>
</ElementType>
<View>
syntax: <View
isBackClipped = boolean
isFrontClipped = boolean
isPerspective = boolean
isPlanView = boolean
isTwisted = boolean
>
seq
 | <ViewHeight>
 | <AspectRatio>
 | <TargetPoint>
[ | <ViewDirection> ]
[ | <PerspectiveViewingAngle> ]
[ | <FrontClip> ]
[ | <BackClip> ]
[ | <WorldZDisplayAngle> ]
</View>
content: eltOnly
order: seq
parents: RenderSpecification
childen: AspectRatio, BackClip, FrontClip, PerspectiveViewingAngle, TargetPoint, ViewDirection, ViewHeight, WorldZDisplayAngle
attributes: isBackClipped, isFrontClipped, isPerspective, isPlanView, isTwisted
model: closed
source:
<ElementType name="View" content="eltOnly" order="seq" model="closed">

    <AttributeType name="isPlanView" dt:type="boolean" required="yes"/>
    <AttributeType name="isPerspective" dt:type="boolean" required="yes"/>
    <AttributeType name="isFrontClipped" dt:type="boolean" required="yes"/>
    <AttributeType name="isBackClipped" dt:type="boolean" required="yes"/>
    <AttributeType name="isTwisted" dt:type="boolean" required="yes"/>
    <attribute type="isPlanView"/>
    <attribute type="isPerspective"/>
    <attribute type="isFrontClipped"/>
    <attribute type="isBackClipped"/>
    <attribute type="isTwisted"/>
    <element type="ViewHeight"/>
    <element type="AspectRatio"/>
    <element type="TargetPoint"/>
    <element type="ViewDirection" minOccurs="0" maxOccurs="1"/>
    <element type="PerspectiveViewingAngle" minOccurs="0" maxOccurs="1"/>
    <element type="FrontClip" minOccurs="0" maxOccurs="1"/>
    <element type="BackClip" minOccurs="0" maxOccurs="1"/>
    <element type="WorldZDisplayAngle" minOccurs="0" maxOccurs="1"/>
</ElementType>
<ViewDirection>
syntax: <ViewDirection >
seq
<Vector>
</ViewDirection>
content: eltOnly
order: seq
parents: View
childen: Vector
attributes: (none)
model: closed
source:
<ElementType name="ViewDirection" content="eltOnly" order="seq" model="closed">

    <element type="Vector"/>
</ElementType>
<ViewHeight>
syntax: <ViewHeight >
seq
<Length>
</ViewHeight>
content: eltOnly
order: seq
parents: View
childen: Length
attributes: (none)
model: closed
source:
<ElementType name="ViewHeight" content="eltOnly" order="seq" model="closed">

    <element type="Length"/>
</ElementType>
<WorldZDisplayAngle>
syntax: <WorldZDisplayAngle >
seq
<Angle>
</WorldZDisplayAngle>
content: eltOnly
order: seq
parents: View
childen: Angle
attributes: (none)
model: closed
source:
<ElementType name="WorldZDisplayAngle" content="eltOnly" order="seq" model="closed">

    <element type="Angle"/>
</ElementType>


DesignXml_V_beta1.xdr Attributes

The following tables decribe the DesignXML attribute types.

Document conventions:

  • [] - optional
  • []* - zero or more times
  • + - one or more times

<TrueColor alpha>
syntax: [ alpha = ui1 ]
required: no
datatype: ui1
elements: TrueColor
source:
<AttributeType name="alpha" dt:type="ui1" required="no"/>
<angleUnits>
syntax: [ angleUnits = enumeration: rad | degree | grads ]
required: no
datatype: enumeration
values: rad | degree | grads
default value: rad
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="angleUnits" dt:type="enumeration" required="no" dt:values="rad degree grads" default="rad"/>
<Model app>
syntax: app = nmtoken
required: yes
datatype: nmtoken
elements: Model
source:
<AttributeType name="app" dt:type="nmtoken" required="yes"/>
<colorSpace>
syntax: [ colorSpace = enumeration: HSV | RGB | YIQ ]
required: no
datatype: enumeration
values: HSV | RGB | YIQ
default value: HSV
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="colorSpace" dt:type="enumeration" required="no" dt:values="HSV RGB YIQ" default="HSV"/>
<BSplineCurve controlPointTolerance>
syntax: controlPointTolerance = r8
required: yes
datatype: r8
elements: BSplineCurve
source:
<AttributeType name="controlPointTolerance" dt:type="r8" required="yes"/>
<BSplineSurface controlPointTolerance>
syntax: controlPointTolerance = r8
required: yes
datatype: r8
elements: BSplineSurface
source:
<AttributeType name="controlPointTolerance" dt:type="r8" required="yes"/>
<BSplineCurve degree>
syntax: degree = i2
required: yes
datatype: i2
elements: BSplineCurve
source:
<AttributeType name="degree" dt:type="i2" required="yes"/>
<BSplineSurface degreeU>
syntax: degreeU = i2
required: yes
datatype: i2
elements: BSplineSurface
source:
<AttributeType name="degreeU" dt:type="i2" required="yes"/>
<BSplineSurface degreeV>
syntax: degreeV = i2
required: yes
datatype: i2
elements: BSplineSurface
source:
<AttributeType name="degreeV" dt:type="i2" required="yes"/>
<Ellipse endParameter>
syntax: endParameter = r8
required: yes
datatype: r8
elements: Ellipse
source:
<AttributeType name="endParameter" dt:type="r8" required="yes"/>
<BSplineCurve fitTolerance>
syntax: fitTolerance = r8
required: yes
datatype: r8
elements: BSplineCurve
source:
<AttributeType name="fitTolerance" dt:type="r8" required="yes"/>
<BSplineSurface fitTolerance>
syntax: fitTolerance = r8
required: yes
datatype: r8
elements: BSplineSurface
source:
<AttributeType name="fitTolerance" dt:type="r8" required="yes"/>
<Text fontName>
syntax: fontName = string
required: yes
datatype: string
elements: Text
source:
<AttributeType name="fontName" dt:type="string" required="yes"/>
<Text fontType>
syntax: [ fontType = enumeration: TrueType | SHX ]
required: no
datatype: enumeration
values: TrueType | SHX
default value: TrueType
elements: Text
source:
<AttributeType name="fontType" dt:type="enumeration" required="no" dt:values="TrueType SHX" default="TrueType"/>
<TrueColor hasAlpha>
syntax: [ hasAlpha = boolean ]
required: no
datatype: boolean
default value: 0
elements: TrueColor
source:
<AttributeType name="hasAlpha" dt:type="boolean" required="no" default="0"/>
<ColorIndex i>
syntax: i = ui1
required: yes
datatype: ui1
elements: ColorIndex
source:
<AttributeType name="i" dt:type="ui1" required="yes"/>
<VertexIndex i>
syntax: i = i4
required: yes
datatype: i4
elements: VertexIndex
source:
<AttributeType name="i" dt:type="i4" required="yes"/>
<ElementPropertyIndex i>
syntax: i = i4
required: yes
datatype: i4
elements: ElementPropertyIndex
source:
<AttributeType name="i" dt:type="i4" required="yes"/>
<View isBackClipped>
syntax: isBackClipped = boolean
required: yes
datatype: boolean
elements: View
source:
<AttributeType name="isBackClipped" dt:type="boolean" required="yes"/>
<Text isBold>
syntax: [ isBold = boolean ]
required: no
datatype: boolean
default value: 0
elements: Text
source:
<AttributeType name="isBold" dt:type="boolean" required="no" default="0"/>
<Polyline isClosed>
syntax: [ isClosed = boolean ]
required: no
datatype: boolean
default value: 0
elements: Polyline
source:
<AttributeType name="isClosed" dt:type="boolean" required="no" default="0"/>
<BSplineCurve isClosed>
syntax: isClosed = boolean
required: yes
datatype: boolean
elements: BSplineCurve
source:
<AttributeType name="isClosed" dt:type="boolean" required="yes"/>
<Mesh isClosedM>
syntax: [ isClosedM = boolean ]
required: no
datatype: boolean
default value: 0
elements: Mesh
source:
<AttributeType name="isClosedM" dt:type="boolean" required="no" default="0"/>
<Mesh isClosedN>
syntax: [ isClosedN = boolean ]
required: no
datatype: boolean
default value: 0
elements: Mesh
source:
<AttributeType name="isClosedN" dt:type="boolean" required="no" default="0"/>
<BSplineSurface isClosedU>
syntax: isClosedU = boolean
required: yes
datatype: boolean
elements: BSplineSurface
source:
<AttributeType name="isClosedU" dt:type="boolean" required="yes"/>
<BSplineSurface isClosedV>
syntax: isClosedV = boolean
required: yes
datatype: boolean
elements: BSplineSurface
source:
<AttributeType name="isClosedV" dt:type="boolean" required="yes"/>
<View isFrontClipped>
syntax: isFrontClipped = boolean
required: yes
datatype: boolean
elements: View
source:
<AttributeType name="isFrontClipped" dt:type="boolean" required="yes"/>
<Text isHorizontallyMirrored>
syntax: [ isHorizontallyMirrored = boolean ]
required: no
datatype: boolean
default value: 0
elements: Text
source:
<AttributeType name="isHorizontallyMirrored" dt:type="boolean" required="no" default="0"/>
<Text isOverlined>
syntax: [ isOverlined = boolean ]
required: no
datatype: boolean
default value: 0
elements: Text
source:
<AttributeType name="isOverlined" dt:type="boolean" required="no" default="0"/>
<BSplineCurve isPeriodic>
syntax: isPeriodic = boolean
required: yes
datatype: boolean
elements: BSplineCurve
source:
<AttributeType name="isPeriodic" dt:type="boolean" required="yes"/>
<BSplineSurface isPeriodicU>
syntax: isPeriodicU = boolean
required: yes
datatype: boolean
elements: BSplineSurface
source:
<AttributeType name="isPeriodicU" dt:type="boolean" required="yes"/>
<BSplineSurface isPeriodicV>
syntax: isPeriodicV = boolean
required: yes
datatype: boolean
elements: BSplineSurface
source:
<AttributeType name="isPeriodicV" dt:type="boolean" required="yes"/>
<View isPerspective>
syntax: isPerspective = boolean
required: yes
datatype: boolean
elements: View
source:
<AttributeType name="isPerspective" dt:type="boolean" required="yes"/>
<View isPlanView>
syntax: isPlanView = boolean
required: yes
datatype: boolean
elements: View
source:
<AttributeType name="isPlanView" dt:type="boolean" required="yes"/>
<BSplineCurve isRational>
syntax: isRational = boolean
required: yes
datatype: boolean
elements: BSplineCurve
source:
<AttributeType name="isRational" dt:type="boolean" required="yes"/>
<BSplineSurface isRational>
syntax: isRational = boolean
required: yes
datatype: boolean
elements: BSplineSurface
source:
<AttributeType name="isRational" dt:type="boolean" required="yes"/>
<View isTwisted>
syntax: isTwisted = boolean
required: yes
datatype: boolean
elements: View
source:
<AttributeType name="isTwisted" dt:type="boolean" required="yes"/>
<Text isUnderlined>
syntax: [ isUnderlined = boolean ]
required: no
datatype: boolean
default value: 0
elements: Text
source:
<AttributeType name="isUnderlined" dt:type="boolean" required="no" default="0"/>
<Text isVerticallyMirrored>
syntax: [ isVerticallyMirrored = boolean ]
required: no
datatype: boolean
default value: 0
elements: Text
source:
<AttributeType name="isVerticallyMirrored" dt:type="boolean" required="no" default="0"/>
<ElementProperty isVisible>
syntax: [ isVisible = boolean ]
required: no
datatype: boolean
default value: 1
elements: ElementProperty
source:
<AttributeType name="isVisible" dt:type="boolean" required="no" default="1"/>
<BSplineCurve knotTolerance>
syntax: knotTolerance = r8
required: yes
datatype: r8
elements: BSplineCurve
source:
<AttributeType name="knotTolerance" dt:type="r8" required="yes"/>
<BSplineSurface knotTolerance>
syntax: knotTolerance = r8
required: yes
datatype: r8
elements: BSplineSurface
source:
<AttributeType name="knotTolerance" dt:type="r8" required="yes"/>
<lengthUnits>
syntax: [ lengthUnits = enumeration: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec ]
required: no
datatype: enumeration
values: none | A | nm | mic | mm | cm | dm | m | dam | hm | km | Gm | microinch | mil | in | ft | yd | mi | au | lightyear | parsec
default value: none
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="lengthUnits" dt:type="enumeration" required="no" dt:values="none A nm mic mm cm dm m dam hm km Gm microinch mil in ft yd mi au
                    lightyear parsec" default="none"/>
<Ellipse minorMajorRatio>
syntax: minorMajorRatio = r8
required: yes
datatype: r8
elements: Ellipse
source:
<AttributeType name="minorMajorRatio" dt:type="r8" required="yes"/>
<Mesh mSize>
syntax: mSize = i4
required: yes
datatype: i4
elements: Mesh
source:
<AttributeType name="mSize" dt:type="i4" required="yes"/>
<FacettedSubmodel name>
syntax: name = id
required: yes
datatype: id
elements: FacettedSubmodel
source:
<AttributeType name="name" dt:type="id" required="yes"/>
<Submodel name>
syntax: name = id
required: yes
datatype: id
elements: Submodel
source:
<AttributeType name="name" dt:type="id" required="yes"/>
<Mesh nSize>
syntax: nSize = i4
required: yes
datatype: i4
elements: Mesh
source:
<AttributeType name="nSize" dt:type="i4" required="yes"/>
<BSplineCurve numberOfControlPoints>
syntax: numberOfControlPoints = i2
required: yes
datatype: i2
elements: BSplineCurve
source:
<AttributeType name="numberOfControlPoints" dt:type="i2" required="yes"/>
<BSplineSurface numberOfControlPointsU>
syntax: numberOfControlPointsU = i2
required: yes
datatype: i2
elements: BSplineSurface
source:
<AttributeType name="numberOfControlPointsU" dt:type="i2" required="yes"/>
<BSplineSurface numberOfControlPointsV>
syntax: numberOfControlPointsV = i2
required: yes
datatype: i2
elements: BSplineSurface
source:
<AttributeType name="numberOfControlPointsV" dt:type="i2" required="yes"/>
<BSplineCurve numberOfKnots>
syntax: numberOfKnots = i2
required: yes
datatype: i2
elements: BSplineCurve
source:
<AttributeType name="numberOfKnots" dt:type="i2" required="yes"/>
<BSplineSurface numberOfKnotsU>
syntax: numberOfKnotsU = i2
required: yes
datatype: i2
elements: BSplineSurface
source:
<AttributeType name="numberOfKnotsU" dt:type="i2" required="yes"/>
<BSplineSurface numberOfKnotsV>
syntax: numberOfKnotsV = i2
required: yes
datatype: i2
elements: BSplineSurface
source:
<AttributeType name="numberOfKnotsV" dt:type="i2" required="yes"/>
<quadraticCurveType>
syntax: [ quadraticCurveType = enumeration: Simple | Sector | Chord ]
required: no
datatype: enumeration
values: Simple | Sector | Chord
default value: Simple
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="quadraticCurveType" dt:type="enumeration" required="no" dt:values="Simple Sector Chord" default="Simple"/>
<Knot r>
syntax: [ r = r8 ]
required: no
datatype: r8
elements: Knot
source:
<AttributeType name="r" dt:type="r8" required="no"/>
<renderMode>
syntax: [ renderMode = enumeration: Plan | Wireframe | Hidden | FlatShade | Gouraud | FlatShadeWithWireframe | GouraudWithWireframe | Phong | Photo ]
required: no
datatype: enumeration
values: Plan | Wireframe | Hidden | FlatShade | Gouraud | FlatShadeWithWireframe | GouraudWithWireframe | Phong | Photo
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="renderMode" dt:type="enumeration" required="no" dt:values="Plan Wireframe Hidden FlatShade Gouraud
                            FlatShadeWithWireframe GouraudWithWireframe
                            Phong Photo"/>
<DataString s>
syntax: [ s = string ]
required: no (default)
datatype: string
elements: DataString
source:
<AttributeType name="s" dt:type="string"/>
<Ellipse startParameter>
syntax: startParameter = r8
required: yes
datatype: r8
elements: Ellipse
source:
<AttributeType name="startParameter" dt:type="r8" required="yes"/>
<FacettedSubmodelReference submodel>
syntax: submodel = idref
required: yes
datatype: idref
elements: FacettedSubmodelReference
source:
<AttributeType name="submodel" dt:type="idref" required="yes"/>
<SubmodelReference submodel>
syntax: submodel = idref
required: yes
datatype: idref
elements: SubmodelReference
source:
<AttributeType name="submodel" dt:type="idref" required="yes"/>
<systemId>
syntax: systemId = uri
required: yes
datatype: uri
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="systemId" dt:type="uri" required="yes"/>
<t>
syntax: t = r8
required: yes
datatype: r8
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="t" dt:type="r8" required="yes"/>
<TrueColor v1>
syntax: v1 = ui1
required: yes
datatype: ui1
elements: TrueColor
source:
<AttributeType name="v1" dt:type="ui1" required="yes"/>
<TrueColor v2>
syntax: v2 = ui1
required: yes
datatype: ui1
elements: TrueColor
source:
<AttributeType name="v2" dt:type="ui1" required="yes"/>
<TrueColor v3>
syntax: v3 = ui1
required: yes
datatype: ui1
elements: TrueColor
source:
<AttributeType name="v3" dt:type="ui1" required="yes"/>
<ControlPoint weight>
syntax: [ weight = r8 ]
required: no
datatype: r8
elements: ControlPoint
source:
<AttributeType name="weight" dt:type="r8" required="no"/>
<x>
syntax: x = r8
required: yes
datatype: r8
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="x" dt:type="r8" required="yes"/>
<Matrix3x3 xx>
syntax: xx = r8
required: yes
datatype: r8
elements: Matrix3x3
source:
<AttributeType name="xx" dt:type="r8" required="yes"/>
<Matrix3x3 xy>
syntax: xy = r8
required: yes
datatype: r8
elements: Matrix3x3
source:
<AttributeType name="xy" dt:type="r8" required="yes"/>
<Matrix3x3 xz>
syntax: [ xz = r8 ]
required: no
datatype: r8
default value: 0.0
elements: Matrix3x3
source:
<AttributeType name="xz" dt:type="r8" required="no" default="0.0"/>
<y>
syntax: y = r8
required: yes
datatype: r8
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="y" dt:type="r8" required="yes"/>
<Matrix3x3 yx>
syntax: yx = r8
required: yes
datatype: r8
elements: Matrix3x3
source:
<AttributeType name="yx" dt:type="r8" required="yes"/>
<Matrix3x3 yy>
syntax: yy = r8
required: yes
datatype: r8
elements: Matrix3x3
source:
<AttributeType name="yy" dt:type="r8" required="yes"/>
<Matrix3x3 yz>
syntax: [ yz = r8 ]
required: no
datatype: r8
default value: 0.0
elements: Matrix3x3
source:
<AttributeType name="yz" dt:type="r8" required="no" default="0.0"/>
<z>
syntax: [ z = r8 ]
required: no
datatype: r8
default value: 0.0
elements: DesignXml_V_beta1.xdr
source:
<AttributeType name="z" dt:type="r8" required="no" default="0.0"/>
<Matrix3x3 zx>
syntax: [ zx = r8 ]
required: no
datatype: r8
default value: 0.0
elements: Matrix3x3
source:
<AttributeType name="zx" dt:type="r8" required="no" default="0.0"/>
<Matrix3x3 zy>
syntax: [ zy = r8 ]
required: no
datatype: r8
default value: 0.0
elements: Matrix3x3
source:
<AttributeType name="zy" dt:type="r8" required="no" default="0.0"/>
<Matrix3x3 zz>
syntax: [ zz = r8 ]
required: no
datatype: r8
default value: 0.0
elements: Matrix3x3
source:
<AttributeType name="zz" dt:type="r8" required="no" default="0.0"/>


DesignXml_V_beta1.xdr Source

<Schema name="DesignXml_V_beta1.xdr" xmlns="urn:schemas-microsoft-com:xml-data" xmlns:dt="urn:schemas-microsoft-com:datatypes">
    <!--	DesignXML Object Composition. The dxml:Object element type has
            the following data channel representations of an application
            model. -->
    <ElementType name="Object" content="eltOnly" order="seq" model="closed">
        <element type="Administrative" minOccurs="0" maxOccurs="1"/>
        <element type="Raster2D" minOccurs="0" maxOccurs="*"/>
        <element type="Vector2D" minOccurs="0" maxOccurs="*"/>
        <element type="Facetted3D" minOccurs="0" maxOccurs="1"/>
        <element type="Geometry3D" minOccurs="0" maxOccurs="1"/>
        <element type="Model" minOccurs="0" maxOccurs="*"/>
    </ElementType>
    <!-- DesignXML Data Channels -->
    <!-- Administrative Channel has version number and summary information. -->
    <ElementType name="Title" content="eltOnly" order="seq" model="closed">
        <element type="DataString"/>
    </ElementType>
    <ElementType name="Subject" content="eltOnly" order="seq" model="closed">
        <element type="DataString"/>
    </ElementType>
    <ElementType name="Author" content="eltOnly" order="seq" model="closed">
        <element type="DataString"/>
    </ElementType>
    <ElementType name="Manager" content="eltOnly" order="seq" model="closed">
        <element type="DataString"/>
    </ElementType>
    <ElementType name="Company" content="eltOnly" order="seq" model="closed">
        <element type="DataString"/>
    </ElementType>
    <ElementType name="Category" content="eltOnly" order="seq" model="closed">
        <element type="DataString"/>
    </ElementType>
    <ElementType name="Keywords" content="eltOnly" order="seq" model="closed">
        <element type="DataString"/>
    </ElementType>
    <ElementType name="Comments" content="eltOnly" order="seq" model="closed">
        <element type="DataString"/>
    </ElementType>
    <ElementType name="HyperlinkBase" content="eltOnly" order="seq" model="closed">
        <element type="DataString"/>
    </ElementType>
    <ElementType name="Administrative" content="eltOnly" order="seq" model="closed">
        <element type="Title"/>
        <element type="Subject"/>
        <element type="Author"/>
        <element type="Manager"/>
        <element type="Company"/>
        <element type="Category"/>
        <element type="Keywords"/>
        <element type="Comments"/>
        <element type="HyperlinkBase"/>
    </ElementType>
    <!-- systemId is a URI or file path. -->
    <AttributeType name="systemId" dt:type="uri" required="yes"/>
    <!-- 	Units for model values.
            These represent the quantities covered in the
            International Metric System (SI), plus a few other units in common
            use whose value is represented with a single real number. -->
    <AttributeType name="lengthUnits" dt:type="enumeration" required="no" dt:values="none A nm mic mm cm dm m dam hm km Gm microinch mil in ft yd mi au
                    lightyear parsec" default="none"/>
    <AttributeType name="angleUnits" dt:type="enumeration" required="no" dt:values="rad degree grads" default="rad"/>
    <!--	Data String:
                "       <       &      '    and   >   must be escaped.
            &quot;   &lt;    &amp;  &apos;      &gt;
            are respective XML escape sequences.  -->
    <ElementType name="DataString" content="empty" model="closed">
        <description>
                    DataString is a container for a Microsoft XML Schema dt:r8
                    string attribute type.
                </description>
        <AttributeType name="s" dt:type="string"/>
        <attribute type="s"/>
    </ElementType>
    <!--	Raster2D Channel represents a single raster image, stored in an
            external file,  optionally bound to a specific view and render mode
            of the model. -->
    <ElementType name="Raster2D" content="eltOnly" order="seq" model="closed">
        <attribute type="systemId"/>
        <element type="RenderSpecification" minOccurs="0" maxOccurs="1"/>
    </ElementType>
    <!--	Vector2D Channel represents a single SVG image stored in an external
            file,  optionally bound to a specific view and render mode of the model.
    -->
    <ElementType name="Vector2D" content="eltOnly" order="seq" model="closed">
        <attribute type="systemId"/>
        <attribute type="lengthUnits"/>
        <attribute type="angleUnits"/>
        <element type="RenderSpecification" minOccurs="0" maxOccurs="1"/>
    </ElementType>
    <!-- ForwardReference points the reader to another XML that has
            the actual contents of a given channel. -->
    <ElementType name="ForwardReference" content="empty" model="closed">
        <attribute type="systemId"/>
    </ElementType>
    <!--	Facetted3D Channel represents the 2D or 3D geometric model built
            exclusively with linear geometry constructs, raster and text. -->
    <ElementType name="Facetted3D" content="eltOnly" order="seq" model="closed">
        <attribute type="lengthUnits"/>
        <attribute type="angleUnits"/>
        <!-- Contents may be either:
                1. A set of geometric elements plus an optional color pallette.
                or
                2. A URI to another XML file that has a Facetted3D element  -->
        <group order="one">
            <element type="ForwardReference"/>
            <group order="seq">
                <group order="many">
                    <element type="Point"/>
                    <element type="LineSegment"/>
                    <element type="Line"/>
                    <element type="Ray"/>
                    <element type="Polyline"/>
                    <element type="Mesh"/>
                    <element type="FacettedShell"/>
                    <element type="Text"/>
                    <element type="FacettedSubmodel"/>
                    <element type="FacettedSubmodelReference"/>
                </group>
                <element type="ColorPalette" minOccurs="0" maxOccurs="1"/>
            </group>
        </group>
    </ElementType>
    <!-- Geometry3D Channel represents the 2D or 3D geometric model using
            every geometry definition in this schema. -->
    <ElementType name="Geometry3D" content="eltOnly" order="seq" model="closed">
        <attribute type="lengthUnits"/>
        <attribute type="angleUnits"/>
        <!-- Contents may be either:
                1. A set of geometric elements plus an optional color pallette.
                or
                2. A URI to another XML file that has a Facetted3D element  -->
        <group order="one">
            <element type="ForwardReference"/>
            <group order="seq">
                <group order="many">
                    <element type="Point"/>
                    <element type="LineSegment"/>
                    <element type="Line"/>
                    <element type="Ray"/>
                    <element type="Polyline"/>
                    <element type="Mesh"/>
                    <element type="FacettedShell"/>
                    <element type="Text"/>
                    <element type="FacettedSubmodel"/>
                    <element type="FacettedSubmodelReference"/>
                    <element type="Arc"/>
                    <element type="Circle"/>
                    <element type="Ellipse"/>
                    <element type="BSplineCurve"/>
                    <element type="Cylinder"/>
                    <element type="Cone"/>
                    <element type="Sphere"/>
                    <element type="Torus"/>
                    <element type="Plane"/>
                    <element type="BSplineSurface"/>
                    <element type="BoundaryRep"/>
                    <element type="Submodel"/>
                    <element type="SubmodelReference"/>
                </group>
                <element type="ColorPalette" minOccurs="0" maxOccurs="1"/>
            </group>
        </group>
    </ElementType>
    <!-- The Model channel is open.  Applications that define their schemas for
            Model channel contents will declare their schemas and
            supply their designated "app" attribute value.  Autodesk
            developers should use their Registered Developer Symbol.
            Their model channel contents should reside in the nested
            "LocalModel" element, which distinguishes a model channel's
            contents from a <ForwardReference> -->
    <ElementType name="LocalModel" content="mixed" model="open"/>
    <ElementType name="Model" content="eltOnly" order="seq" model="closed">
        <AttributeType name="app" dt:type="nmtoken" required="yes"/>
        <attribute type="app"/>
        <!-- Contents may be either:
                1. An optional color palette plus a set of geometric elements.
                or
                2. A URI to another XML file that has a Facetted3D element  -->
        <group order="one">
            <element type="LocalModel"/>
            <element type="ForwardReference"/>
        </group>
    </ElementType>
    <!--	DesignXML Elements -->
    <!--	x, y, z:  Cartesian coordinate attribute names.
            "x" is also used for scalar "Length" element values.  -->
    <AttributeType name="x" dt:type="r8" required="yes"/>
    <AttributeType name="y" dt:type="r8" required="yes"/>
    <AttributeType name="z" dt:type="r8" required="no" default="0.0"/>
    <!-- t: == theta, for angles and so on -->
    <AttributeType name="t" dt:type="r8" required="yes"/>
    <!-- Model elements that combine values with model units. -->
    <ElementType name="Length" content="empty" model="closed">
        <description>
                    Length is a scalar real number "x" combined with
                    applicable units.
                </description>
        <attribute type="x"/>
        <attribute type="lengthUnits"/>
    </ElementType>
    <ElementType name="Angle" content="empty" model="closed">
        <description>
                    Angle is a scalar real number "t" combined with
                    applicable units.
                </description>
        <attribute type="t"/>
        <attribute type="angleUnits"/>
    </ElementType>
    <!--	Points and Vector structures for 3D, right-handed Cartesian
            coordinate system, but permits absence of a Z coordinate to
            represent 2D elements, or an implied 0.0 Z coordinate value. -->
    <ElementType name="Point" content="empty" model="closed">
        <description>
                    The DesignXML Point represents a 3D, right-handed
                    Cartesian coordinate point, but permits the absence
                    (an implied 0.0 value) of a Z coordinate to
                    represent 2D points.
                </description>
        <attribute type="x"/>
        <attribute type="y"/>
        <attribute type="z"/>
        <attribute type="lengthUnits"/>
    </ElementType>
    <ElementType name="Vector" content="empty" order="seq" model="closed">
        <description>
                    The DesignXML Vector represents a 3D, right-handed
                    Cartesian coordinate vector, but permits the absence
                    (an implied 0.0 value) of a Z coordinate to
                    represent 2D vectors.
                </description>
        <attribute type="x"/>
        <attribute type="y"/>
        <attribute type="z"/>
        <attribute type="lengthUnits"/>
    </ElementType>
    <!-- Normal: A vector used to define the orientation of a 2D plane in
            3D space.  Represents the "Z axis" of planar geometry, such as
            circles, arcs, and text strings. -->
    <ElementType name="Normal" content="eltOnly" order="seq" model="closed">
        <description>
                    A DesignXML Normal is a vector used to define the orientation
                    of a 2D plane in 3D space. A Normal vector represents
                    the Z axis of planar geometry such as circles, arcs, and
                    text strings.
                </description>
        <element type="Vector"/>
    </ElementType>
    <ElementType name="Matrix3x3" content="empty" order="seq" model="closed">
        <description>
                    The DesignXML Matrix3x3 element represents 3D orientation
                    and scale.  Each coordinate name uses two letters (for
                    example "xz"). The first letter represents an input
                    vector coordinate, and the second letter represents an
                    output vector coordinate.  One can also represent a 2x2
                    matrix for 2D rotation transforms by omitting all
                    attributes with a name containning "z" (the omitted
                    attribute values default to 0.0).
                </description>
        <AttributeType name="xx" dt:type="r8" required="yes"/>
        <AttributeType name="yx" dt:type="r8" required="yes"/>
        <AttributeType name="zx" dt:type="r8" required="no" default="0.0"/>
        <AttributeType name="xy" dt:type="r8" required="yes"/>
        <AttributeType name="yy" dt:type="r8" required="yes"/>
        <AttributeType name="zy" dt:type="r8" required="no" default="0.0"/>
        <AttributeType name="xz" dt:type="r8" required="no" default="0.0"/>
        <AttributeType name="yz" dt:type="r8" required="no" default="0.0"/>
        <AttributeType name="zz" dt:type="r8" required="no" default="0.0"/>
        <attribute type="xx"/>
        <attribute type="yx"/>
        <attribute type="zx"/>
        <attribute type="xy"/>
        <attribute type="yy"/>
        <attribute type="zy"/>
        <attribute type="xz"/>
        <attribute type="yz"/>
        <attribute type="zz"/>
    </ElementType>
    <!-- LinearCoordinateTransform:
           3D linear transform. Can also represent a 3x2 matrix
            for 2D transforms by omitting "z" elements and attributess. In fact, all
            elements are optional, with an empty matrix corresponding to an
            Identity matrix. -->
    <ElementType name="Orientation" content="eltOnly" order="seq" model="closed">
        <description>
                    See LinearCoordinateTransform.
                </description>
        <element type="Matrix3x3"/>
    </ElementType>
    <ElementType name="Translation" content="eltOnly" order="seq" model="closed">
        <description>
                    See LinearCoordinateTransform.
                </description>
        <element type="Vector"/>
    </ElementType>
    <ElementType name="LinearCoordinateTransform" content="eltOnly" order="seq" model="closed">
        <description>
                    A LinearCoordinateTransform represents a 3D linear
                    transform from a linear coordinate system to another
                    coordinate system. The LinearCoordinateTransform is
                    defined by its contained  Orientation (Matrix3x3)
                    and Translation (Vector) elements. A
                    LinearCoordinateTransform can also
                    represent a 3x2 matrix for 2D transforms by omitting "z"
                    elements and attributes. In fact, all elements are optional,
                    with an empty matrix corresponding to an identity matrix.
                    Planar entities such as text strings have a
                    non-identity coordinate system to reflect an orientation
                    that is not in the XY plane of the host coordinate system.
                </description>
        <element type="Orientation" minOccurs="0"/>
        <element type="Translation" minOccurs="0"/>
    </ElementType>
    <!--	View Specification, Rendering Modes. -->
    <ElementType name="ViewHeight" content="eltOnly" order="seq" model="closed">
        <description>
                    ViewHeight is the vertical view size in model units,
                    defined by the contained Length element.
                    For perspective views, the size applies to the view
                    plane that intercepts the target point.
                </description>
        <element type="Length"/>
    </ElementType>
    <ElementType name="AspectRatio" content="eltOnly" order="seq" model="closed">
        <description>
                    AspectRatio is the ratio of the view width to the view height, defined by the
                    contained Length element.
                </description>
        <element type="Length"/>
    </ElementType>
    <ElementType name="ViewDirection" content="eltOnly" order="seq" model="closed">
        <description>
                    ViewDirection is the point of view, defined by two angles
                    relative to the X axis and XY plane of the WCS.  The
                    contained Vector element describes the ViewDirection.
                </description>
        <element type="Vector"/>
    </ElementType>
    <ElementType name="TargetPoint" content="eltOnly" order="seq" model="closed">
        <description>
                    TargetPoint is the focal point of a 3D view.
                </description>
        <element type="Point"/>
    </ElementType>
    <ElementType name="FrontClip" content="eltOnly" order="seq" model="closed">
        <description>
                    FrontClip represents the front clipping plane in a 3D
                    view.  The front clipping plane is a plane perpendicular
                    to the line of sight; objects between the point of view
                    and the front clipping plane are clipped from view.  The
                    contained Length element defines the location of the
                    FrontClip plane as a distance from the target point.
                </description>
        <element type="Length"/>
    </ElementType>
    <ElementType name="BackClip" content="eltOnly" order="seq" model="closed">
        <description>
                    BackClip represents the back clipping plane in a 3D view.
                    The back clipping plane is a plane perpendicular to the line
                    of sight; objects behind the back clipping plane are
                    clipped from view.  The contained Length
                    element defines the location of the BackClip plane as a
                    distance from the target point.
                </description>
        <element type="Length"/>
    </ElementType>
    <ElementType name="PerspectiveViewingAngle" content="eltOnly" order="seq" model="closed">
        <description>
                    PerspectiveViewingAngle represents the visible field of
                    view in a perspective projection.  For example, a
                    PerspectiveViewingAngle value of 0 approximates an
                    orthographic (infinite distance) projection, a value of
                    180 approximates a fisheye view, and a value of 40-60
                    gives a noticeable perspective quality to the view.
                </description>
        <element type="Angle"/>
    </ElementType>
    <ElementType name="WorldZDisplayAngle" content="eltOnly" order="seq" model="closed">
        <description>
                    WorldZDisplayAngle is the angle (the twist) from
                    vertical that the model's Z axis (or Y axis for 2D views)
                    appears. An upside-down view is 180 degrees.
                </description>
        <element type="Angle"/>
    </ElementType>
    <ElementType name="View" content="eltOnly" order="seq" model="closed">
        <description>
                    Every View specification must have a height in model units
                    and a model target point, which is centered in the view.
                    After that, however, Boolean attributes indicate the need
                    for the other contained elements.  For example, the
                    value of the isTwisted attribute determines whether a
                    WorldZDisplayAngle element is needed.
                </description>
        <AttributeType name="isPlanView" dt:type="boolean" required="yes"/>
        <AttributeType name="isPerspective" dt:type="boolean" required="yes"/>
        <AttributeType name="isFrontClipped" dt:type="boolean" required="yes"/>
        <AttributeType name="isBackClipped" dt:type="boolean" required="yes"/>
        <AttributeType name="isTwisted" dt:type="boolean" required="yes"/>
        <attribute type="isPlanView"/>
        <attribute type="isPerspective"/>
        <attribute type="isFrontClipped"/>
        <attribute type="isBackClipped"/>
        <attribute type="isTwisted"/>
        <element type="ViewHeight"/>
        <element type="AspectRatio"/>
        <element type="TargetPoint"/>
        <element type="ViewDirection" minOccurs="0" maxOccurs="1"/>
        <element type="PerspectiveViewingAngle" minOccurs="0" maxOccurs="1"/>
        <element type="FrontClip" minOccurs="0" maxOccurs="1"/>
        <element type="BackClip" minOccurs="0" maxOccurs="1"/>
        <element type="WorldZDisplayAngle" minOccurs="0" maxOccurs="1"/>
    </ElementType>
    <AttributeType name="renderMode" dt:type="enumeration" required="no" dt:values="Plan Wireframe Hidden FlatShade Gouraud
                            FlatShadeWithWireframe GouraudWithWireframe
                            Phong Photo"/>
    <ElementType name="RenderSpecification" content="eltOnly" order="seq" model="closed">
        <description>
                    A RenderSpecification identifies a RenderMode (Plan,
                    Wireframe, Hidden, FlatShade, Gouraud,
                    FlatShadeWithWireframe, GouraudWithWireframe) and View.
                </description>
        <attribute type="renderMode"/>
        <element type="View" minOccurs="1" maxOccurs="1"/>
    </ElementType>
    <!-- Color Definitions -->
    <!-- Color LookUp Table definition -->
    <ElementType name="ColorPalette" content="eltOnly" order="seq" model="closed">
        <description>
                    ColorPalette is the color lookup table definition.
                </description>
        <!-- The real upper limit should be 256. -->
        <element type="TrueColor" minOccurs="1" maxOccurs="*"/>
    </ElementType>
    <!-- ColorIndex represents an index into a ColorPalette element. -->
    <ElementType name="ColorIndex" content="empty" model="closed">
        <description>
                    ColorIndex represents an index into a ColorPalette element.
                </description>
        <AttributeType name="i" dt:type="ui1" required="yes"/>
        <attribute type="i"/>
    </ElementType>
    <!--	TrueColor is 24-bit color + 8-bit alpha channel, with choice of color
            space. -->
    <AttributeType name="colorSpace" dt:type="enumeration" required="no" dt:values="HSV RGB YIQ" default="HSV"/>
    <ElementType name="TrueColor" content="empty" model="closed">
        <description>
                    TrueColor is the 24-bit color plus 8-bits for the alpha
                    channel with choice of color space.
                </description>
        <AttributeType name="v1" dt:type="ui1" required="yes"/>
        <AttributeType name="v2" dt:type="ui1" required="yes"/>
        <AttributeType name="v3" dt:type="ui1" required="yes"/>
        <AttributeType name="hasAlpha" dt:type="boolean" required="no" default="0"/>
        <AttributeType name="alpha" dt:type="ui1" required="no"/>
        <attribute type="v1"/>
        <attribute type="v2"/>
        <attribute type="v3"/>
        <attribute type="hasAlpha"/>
        <attribute type="alpha"/>
        <attribute type="colorSpace"/>
    </ElementType>
    <!-- Color is either a color index, or a true color, but not both. -->
    <ElementType name="Color" content="eltOnly" order="one" model="closed">
        <description>
                    Color is either a color index, or a true color, but not
                    both.
                </description>
        <element type="TrueColor"/>
        <element type="ColorIndex"/>
    </ElementType>
    <!-- Link elements are used to represent application-specified bindings. -->
    <ElementType name="Link" content="eltOnly" order="seq" model="closed">
        <description>
                    The Link element is used to associate elements in the
                    common DesignXML channels with other bodies of
                    information, including elements in other common
                    channels, elements in a model channel, or even
                    records in an external database.
                    The most obvious usage is to indicate which application
                    model element a Geometry3D or Facetted3D element
                    corresponds to.  For example, a Link might associate
                    a Facetted3D Line with its AcDbXML Entity handle. Any
                    number of Link elements can exist in a DXML file,
                    so each application should add a unique prefix to
                    the link name in order to distinguish it from links
                    created by other applications. Autodesk Developer
                    Network members should use their registered developer
                    symbols in the Link name.  Interpretation of links is
                    the responsibility of the applications implementing them.
                </description>
        <element type="DataString"/>
    </ElementType>
    <!--	Higher order Geometric Elements.  By default, they are represented
            in 3D and 2D Cartesian coordinate systems. -->
    <!-- LineSegment -->
    <ElementType name="StartPoint" content="eltOnly" order="seq" model="closed">
        <element type="Point"/>
    </ElementType>
    <ElementType name="EndPoint" content="eltOnly" order="seq" model="closed">
        <element type="Point"/>
    </ElementType>
    <ElementType name="LineSegment" content="eltOnly" order="seq" model="closed">
        <description>
                    Line segments are the set of points that lie directly
                    between the two specified endpoints.
                </description>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="StartPoint"/>
        <element type="EndPoint"/>
    </ElementType>
    <!-- Line (Infinite) and Ray -->
    <ElementType name="PointOnLine" content="eltOnly" order="seq" model="closed">
        <element type="Point"/>
    </ElementType>
    <ElementType name="Direction" content="eltOnly" order="seq" model="closed">
        <element type="Vector"/>
    </ElementType>
    <ElementType name="Line" content="eltOnly" order="seq" model="closed">
        <description>
                    An infinite line in space as defined by a point and a
                    direction vector.
                </description>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="PointOnLine"/>
        <element type="Direction"/>
    </ElementType>
    <ElementType name="Ray" content="eltOnly" order="seq" model="closed">
        <description>
                    A half line bounded by a point and extending in the
                    direction of the vector.
                </description>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="PointOnLine"/>
        <element type="Direction"/>
    </ElementType>
    <!-- A polyline is linear segments with shared endpoints. -->
    <ElementType name="Vertices" content="eltOnly" order="seq" model="closed">
        <description>
                    Vertices are the (minimum of two) points defining
                    Polyline, Mesh, FacettedShell, and Body.
                    The Vertices element effectively declares Point twice,
                    which is necessary so that an XDR validating parser
                    can enforce a minimum of two vertices.
                </description>
        <element type="Point" minOccurs="1" maxOccurs="1"/>
        <element type="Point" minOccurs="1" maxOccurs="*"/>
    </ElementType>
    <ElementType name="Polyline" content="eltOnly" order="seq" model="closed">
        <description>
                    A Polyline is composed of linear segments with
                    shared endpoints.
                </description>
        <AttributeType name="isClosed" dt:type="boolean" required="no" default="0"/>
        <attribute type="isClosed"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="Vertices" minOccurs="1" maxOccurs="1"/>
    </ElementType>
    <ElementType name="NormalVectors" content="eltOnly" order="seq" model="closed">
        <element type="Vector" minOccurs="1" maxOccurs="*"/>
    </ElementType>
    <ElementType name="ElementProperty" content="eltOnly" order="seq" model="closed">
        <AttributeType name="isVisible" dt:type="boolean" required="no" default="1"/>
        <attribute type="isVisible"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
    </ElementType>
    <ElementType name="EdgeProperties" content="eltOnly" order="seq" model="closed">
        <element type="ElementProperty" minOccurs="1" maxOccurs="*"/>
    </ElementType>
    <ElementType name="FaceProperties" content="eltOnly" order="seq" model="closed">
        <element type="ElementProperty" minOccurs="1" maxOccurs="*"/>
    </ElementType>
    <ElementType name="RasterImage" content="empty" order="seq" model="closed">
        <description>
                    Raster images are specified in separate files or URIs.
                    A DesignXML Mesh element serves as the geometric frame for
                    a RasterImage. A flat raster image is most easily
                    attached to a 2x2 unclosed mesh. Raster image X and Y
                    pixels are uniformly scaled to the Mesh's U and V
                    coordinates, respectively.
                </description>
        <attribute type="systemId"/>
    </ElementType>
    <ElementType name="Mesh" content="eltOnly" order="seq" model="closed">
        <description>
                    MxN quad polygon face meshes are specified as a matrix of
                    vertices, optional vertex normals, and face and edge
                    properties.  The implicit ordering is M groups of N vertices,
                    so that there are M rows and N columns.  The corresponding
                    parametric dimensions are U and V, which both have ranges
                    of 0.0 to 1.0.  The U dimension is 0.0 at the first vertex
                    in each row, and is 1.0 at either the N-1 vertex (if
                    unclosed in the N direction) or the first vertex
                    (if closed in the N direction).  The same relationship
                    applies to the V coordinate along the M rows of vertices.
                </description>
        <AttributeType name="mSize" dt:type="i4" required="yes"/>
        <AttributeType name="nSize" dt:type="i4" required="yes"/>
        <AttributeType name="isClosedM" dt:type="boolean" required="no" default="0"/>
        <AttributeType name="isClosedN" dt:type="boolean" required="no" default="0"/>
        <attribute type="mSize"/>
        <attribute type="nSize"/>
        <attribute type="isClosedM"/>
        <attribute type="isClosedN"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <description>
            The number of Mesh Vertices must equal mSize * nSize.
                </description>
        <element type="Vertices" minOccurs="1" maxOccurs="1"/>
        <description>
            The rest of the contained Mesh elements are optional
                    and independent from one another, but if present, must
                    be present in the numbers indicated.
                </description>
        <description>
                    Raster images are always applied to a mesh.
                </description>
        <element type="RasterImage" minOccurs="0" maxOccurs="1"/>
        <description>
                    The number of NormalVectors must equal (mSize * nSize).
                </description>
        <element type="NormalVectors" minOccurs="0" maxOccurs="1"/>
        <description>
                    The number of EdgeProperties must equal
                    (mSize - isClosedM + 1) * (nSize - isClosedN + 1)
                </description>
        <element type="EdgeProperties" minOccurs="0" maxOccurs="1"/>
        <description>
                    The number of FaceProperties must equal
                    (mSize - isClosedM) * (nSize - isClosedN)
                </description>
        <element type="FaceProperties" minOccurs="0" maxOccurs="1"/>
    </ElementType>
    <ElementType name="MaximumDeviation" content="eltOnly" order="seq" model="closed">
        <element type="Length"/>
    </ElementType>
    <ElementType name="VertexIndex" content="empty" model="closed">
        <AttributeType name="i" dt:type="i4" required="yes"/>
        <attribute type="i"/>
    </ElementType>
    <ElementType name="ElementPropertyIndex" content="empty" model="closed">
        <AttributeType name="i" dt:type="i4" required="yes"/>
        <attribute type="i"/>
    </ElementType>
    <ElementType name="FacettedFace" content="eltOnly" order="seq" model="closed">
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="Normal" minOccurs="0" maxOccurs="1"/>
        <!-- The following group defines a closed loop of linear edges,
                with optional overriding properties. -->
        <group order="many">
            <element type="VertexIndex"/>
            <element type="ElementPropertyIndex" minOccurs="0" maxOccurs="1"/>
        </group>
    </ElementType>
    <ElementType name="FacettedShell" content="eltOnly" order="seq" model="closed">
        <description>
                    A FacettedShell consists of arrays of face elements
                    that are closed boundary paths specified as
                    an array of indices into an array of shared vertex
                    locations. Shared vertex normals can be optionally
                    specified. Overriding edge element properties can
                    also be specified. The same index refers to a vertex,
                    and the edge that starts with the vertex.  The final
                    edge goes from the final vertex to vertex 0
                    (the first vertex). All specified faces are
                    visible; holes exist where there are no faces.
                </description>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <description>
                    If this shell represents nonlinear
                    geometry, MaximumDeviation specifies the maximum
                    distance the shell geometry can displace from the actual
                    geometry.  If the shell represents linear geometry,
                    0.0 is a viable length value.
                </description>
        <element type="MaximumDeviation"/>
        <description>
                    The FacettedFace element contains a group of VertexIndex
                    and ElementPropertyIndex elements that define a closed
                    loop of linear edges, with optional overriding properties.
                    Both VertexIndex and ElementPropertyIndex have valid
                    ranges of 0 through (n-1) where n is the number of
                    corresponding elements.
                </description>
        <element type="FacettedFace" minOccurs="0" maxOccurs="*"/>
        <description>
                    The number of Vertices points must be at least
                    ((the maximum VertexIndex used in any FacettedFace element)
                    + 1).
                </description>
        <element type="Vertices" minOccurs="1" maxOccurs="1"/>
        <description>
                    The remaining arrays NormalVectors and ElementProperties
                    are optional and independent from one another, but if
                    present, must have the same size as the Vertices element.
                </description>
        <description>
                    The number of NormalVectors must equal the number
                    of vertices.
                </description>
        <element type="NormalVectors" minOccurs="0" maxOccurs="1"/>
        <description>
                    The number of ElementProperties must be
                    at least ((the maximum ElementPropertyIndex used in any
                    FacettedFace element) + 1).
                </description>
        <element type="ElementProperty" minOccurs="0" maxOccurs="*"/>
    </ElementType>
    <ElementType name="Height" content="eltOnly" order="seq" model="closed">
        <element type="Length"/>
    </ElementType>
    <ElementType name="Position" content="eltOnly" order="seq" model="closed">
        <element type="Point"/>
    </ElementType>
    <ElementType name="Obliquing" content="eltOnly" order="seq" model="closed">
        <element type="Angle"/>
    </ElementType>
    <ElementType name="BaselineDirection" content="eltOnly" order="seq" model="closed">
        <element type="Vector"/>
    </ElementType>
    <ElementType name="Text" content="eltOnly" order="seq" model="closed">
        <description>
                    Text is strings with size, orientation and font
                    information.
                </description>
        <AttributeType name="fontName" dt:type="string" required="yes"/>
        <AttributeType name="fontType" dt:type="enumeration" required="no" dt:values="TrueType SHX" default="TrueType"/>
        <AttributeType name="isBold" dt:type="boolean" required="no" default="0"/>
        <AttributeType name="isUnderlined" dt:type="boolean" required="no" default="0"/>
        <AttributeType name="isOverlined" dt:type="boolean" required="no" default="0"/>
        <AttributeType name="isHorizontallyMirrored" dt:type="boolean" required="no" default="0"/>
        <AttributeType name="isVerticallyMirrored" dt:type="boolean" required="no" default="0"/>
        <attribute type="fontName"/>
        <attribute type="fontType"/>
        <attribute type="isBold"/>
        <attribute type="isUnderlined"/>
        <attribute type="isOverlined"/>
        <attribute type="isHorizontallyMirrored"/>
        <attribute type="isVerticallyMirrored"/>
        <element type="DataString"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <description>
                    The default coordinate system for text is defined by the following:
                        start position (origin),
                        oblique angle (italicized clockwise from
                        orthogonal Y axis),
                        height (Y Axis Scale factor),
                        baseline direction (X Axis),
                        and normal (Z Axis).
                </description>
        <element type="Position"/>
        <element type="Height"/>
        <element type="Obliquing" minOccurs="0" maxOccurs="1"/>
        <element type="BaselineDirection" minOccurs="0" maxOccurs="1"/>
        <element type="Normal" minOccurs="0" maxOccurs="1"/>
    </ElementType>
    <ElementType name="FacettedSubmodel" content="eltOnly" order="seq" model="closed">
        <description>
                    The FacettedSubmodel is a building block used to apply
                    transforms to other geometry.
                    You use a FacettedSubmodel by referencing it via a
                    FacettedSubmodelReference.
                    A FacettedSubmodel transform can be applied to every
                    Facetted3D channel object (not including FacettedSubmodel
                    elements themselves), plus Color and Link.
                </description>
        <description>
                    The name attribute is a unique id that will be referenced.
                </description>
        <AttributeType name="name" dt:type="id" required="yes"/>
        <attribute type="name"/>
        <attribute type="lengthUnits"/>
        <attribute type="angleUnits"/>
        <description>
                    The Color element specifies the default
                    color for the geometry.
                </description>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <group order="many">
            <element type="Point"/>
            <element type="LineSegment"/>
            <element type="Line"/>
            <element type="Ray"/>
            <element type="Polyline"/>
            <element type="Mesh"/>
            <element type="FacettedShell"/>
            <element type="Text"/>
            <element type="FacettedSubmodelReference"/>
        </group>
    </ElementType>
    <ElementType name="FacettedSubmodelReference" content="eltOnly" order="seq" model="closed">
        <description>
                    FacettedSubmodelReference references a FacettedSubmodel
                    via the submodel idref identifier.
                </description>
        <AttributeType name="submodel" dt:type="idref" required="yes"/>
        <attribute type="submodel"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="LinearCoordinateTransform" minOccurs="0" maxOccurs="1"/>
    </ElementType>
    <!-- Nonlinear Geometry constructs -->
    <!-- Circle -->
    <ElementType name="CenterPoint" content="eltOnly" order="seq" model="closed">
        <element type="Point"/>
    </ElementType>
    <ElementType name="Radius" content="eltOnly" order="seq" model="closed">
        <element type="Length"/>
    </ElementType>
    <ElementType name="Circle" content="eltOnly" order="seq" model="closed">
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="CenterPoint"/>
        <element type="Radius"/>
        <element type="Normal" minOccurs="0" maxOccurs="1"/>
    </ElementType>
    <!-- Arc -->
    <AttributeType name="quadraticCurveType" dt:type="enumeration" required="no" dt:values="Simple Sector Chord" default="Simple"/>
    <ElementType name="StartVector" content="eltOnly" order="seq" model="closed">
        <element type="Vector"/>
    </ElementType>
    <ElementType name="SweepAngle" content="eltOnly" order="seq" model="closed">
        <element type="Angle"/>
    </ElementType>
    <ElementType name="Arc" content="eltOnly" order="seq" model="closed">
        <description>
                    The quadraticCurveType attribute defines whether the
                    arc represents the outer edge arc curve
                    segment, the chord segment between the two arc endpoints,
                    or a sector.
                </description>
        <attribute type="quadraticCurveType"/>
        <description>
                    The contained Circle element defines the Arc center and
                    radius.
                </description>
        <element type="Circle"/>
        <description>
                    The StartVector's initial point is the Circle's center
                    point.
                    The Arc startpoint is defined by the StartVector's
                    intercept with the Circle.
                </description>
        <element type="StartVector"/>
        <description>
                    The SweepAngle defines the inclusive arc angle
                    difference between the startpoint (and angle),
                    and the endpoint (and angle).  For example, a
                    sweep angle of 90 degrees defines a quarter of
                    a full circle.
                </description>
        <element type="SweepAngle"/>
    </ElementType>
    <!-- Ellipse:  3D or 2D depending on "normal" element -->
    <ElementType name="MajorAxis" content="eltOnly" order="seq" model="closed">
        <element type="Vector"/>
    </ElementType>
    <ElementType name="Ellipse" content="eltOnly" order="seq" model="closed">
        <description>
                    The Ellipse is 3D or 2D, depending on the value of
                    the Normal element.
                </description>
        <AttributeType name="minorMajorRatio" dt:type="r8" required="yes"/>
        <AttributeType name="startParameter" dt:type="r8" required="yes"/>
        <AttributeType name="endParameter" dt:type="r8" required="yes"/>
        <attribute type="minorMajorRatio"/>
        <attribute type="startParameter"/>
        <attribute type="endParameter"/>
        <attribute type="quadraticCurveType"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="CenterPoint"/>
        <element type="MajorAxis"/>
        <element type="Normal" minOccurs="0" maxOccurs="1"/>
    </ElementType>
    <!-- B-Spline Curve -->
    <ElementType name="ControlPoint" content="eltOnly" order="seq" model="closed">
        <AttributeType name="weight" dt:type="r8" required="no"/>
        <attribute type="weight"/>
        <element type="Point"/>
    </ElementType>
    <ElementType name="Knot" content="empty" model="closed">
        <AttributeType name="r" dt:type="r8" required="no"/>
        <attribute type="r"/>
    </ElementType>
    <ElementType name="BSplineCurve" content="eltOnly" order="seq" model="closed">
        <AttributeType name="isClosed" dt:type="boolean" required="yes"/>
        <AttributeType name="isPeriodic" dt:type="boolean" required="yes"/>
        <AttributeType name="isRational" dt:type="boolean" required="yes"/>
        <AttributeType name="degree" dt:type="i2" required="yes"/>
        <AttributeType name="numberOfControlPoints" dt:type="i2" required="yes"/>
        <AttributeType name="numberOfKnots" dt:type="i2" required="yes"/>
        <AttributeType name="knotTolerance" dt:type="r8" required="yes"/>
        <AttributeType name="controlPointTolerance" dt:type="r8" required="yes"/>
        <AttributeType name="fitTolerance" dt:type="r8" required="yes"/>
        <attribute type="isClosed"/>
        <attribute type="isPeriodic"/>
        <attribute type="isRational"/>
        <attribute type="degree"/>
        <attribute type="numberOfControlPoints"/>
        <attribute type="numberOfKnots"/>
        <attribute type="knotTolerance"/>
        <attribute type="controlPointTolerance"/>
        <attribute type="fitTolerance"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="ControlPoint" minOccurs="0" maxOccurs="*"/>
        <element type="Knot" minOccurs="0" maxOccurs="*"/>
    </ElementType>
    <!-- Nonlinear Solids and Surfaces  -->
    <!-- Cylinder -->
    <ElementType name="BaseAndDirection" content="eltOnly" order="seq" model="closed">
        <element type="Circle"/>
    </ElementType>
    <ElementType name="Cylinder" content="eltOnly" order="seq" model="closed">
        <element type="BaseAndDirection"/>
        <element type="Height"/>
    </ElementType>
    <!-- Cone -->
    <ElementType name="TopRadius" content="eltOnly" order="seq" model="closed">
        <element type="Length"/>
    </ElementType>
    <ElementType name="Cone" content="eltOnly" order="seq" model="closed">
        <element type="BaseAndDirection"/>
        <element type="Height"/>
        <element type="TopRadius" minOccurs="0" maxOccurs="*"/>
    </ElementType>
    <!-- Sphere -->
    <ElementType name="Sphere" content="eltOnly" order="seq" model="closed">
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="CenterPoint"/>
        <element type="Radius"/>
    </ElementType>
    <!-- Torus -->
    <ElementType name="MajorRadius" content="eltOnly" order="seq" model="closed">
        <element type="Length"/>
    </ElementType>
    <ElementType name="MinorRadius" content="eltOnly" order="seq" model="closed">
        <element type="Length"/>
    </ElementType>
    <ElementType name="Torus" content="eltOnly" order="seq" model="closed">
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="CenterPoint"/>
        <element type="MajorRadius"/>
        <element type="MinorRadius"/>
        <element type="Normal" minOccurs="0" maxOccurs="1"/>
    </ElementType>
    <!-- Plane -->
    <ElementType name="Plane" content="eltOnly" order="seq" model="closed">
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="Point"/>
        <element type="Normal"/>
    </ElementType>
    <!-- B-Spline Surface -->
    <ElementType name="BSplineSurface" content="eltOnly" order="seq" model="closed">
        <AttributeType name="isClosedU" dt:type="boolean" required="yes"/>
        <AttributeType name="isClosedV" dt:type="boolean" required="yes"/>
        <AttributeType name="isPeriodicU" dt:type="boolean" required="yes"/>
        <AttributeType name="isPeriodicV" dt:type="boolean" required="yes"/>
        <AttributeType name="isRational" dt:type="boolean" required="yes"/>
        <AttributeType name="degreeU" dt:type="i2" required="yes"/>
        <AttributeType name="degreeV" dt:type="i2" required="yes"/>
        <AttributeType name="numberOfControlPointsU" dt:type="i2" required="yes"/>
        <AttributeType name="numberOfControlPointsV" dt:type="i2" required="yes"/>
        <AttributeType name="numberOfKnotsU" dt:type="i2" required="yes"/>
        <AttributeType name="numberOfKnotsV" dt:type="i2" required="yes"/>
        <AttributeType name="knotTolerance" dt:type="r8" required="yes"/>
        <AttributeType name="controlPointTolerance" dt:type="r8" required="yes"/>
        <AttributeType name="fitTolerance" dt:type="r8" required="yes"/>
        <attribute type="isClosedU"/>
        <attribute type="isClosedV"/>
        <attribute type="isPeriodicU"/>
        <attribute type="isPeriodicV"/>
        <attribute type="isRational"/>
        <attribute type="degreeU"/>
        <attribute type="degreeV"/>
        <attribute type="numberOfControlPointsU"/>
        <attribute type="numberOfControlPointsV"/>
        <attribute type="numberOfKnotsU"/>
        <attribute type="numberOfKnotsV"/>
        <attribute type="knotTolerance"/>
        <attribute type="controlPointTolerance"/>
        <attribute type="fitTolerance"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <description>
                    The number of control points should equal
                    (numberOfControlPointsU * numberOfControlPointsV).
                </description>
        <element type="ControlPoint" minOccurs="0" maxOccurs="*"/>
        <description>
                    The number of Knot occurrences should equal
                    (numberOfKnotsU * numberOfKnotsV).
                </description>
        <element type="Knot" minOccurs="0" maxOccurs="*"/>
    </ElementType>
    <ElementType name="BoundaryRep" content="eltOnly" order="seq" model="closed">
        <description>
              BRep topology is defined externally.
          The systemId attribute points to a file containing
                  ACIS Brep data.
                </description>
        <attribute type="systemId"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
    </ElementType>
    <ElementType name="Submodel" content="eltOnly" order="seq" model="closed">
        <description>
                    A Submodel is a building block used to apply
                    transforms to other geometry.
                    You use a Submodel by referencing it via a
                    SubmodelReference.
                    A Submodel transform can be applied to every
                    Geometry3D channel object (not including Submodel
                    elements themselves), plus Color and Link.
                </description>
        <description>
                    The name attribute is a unique id that can be referenced.
                </description>
        <AttributeType name="name" dt:type="id" required="yes"/>
        <attribute type="name"/>
        <attribute type="lengthUnits"/>
        <attribute type="angleUnits"/>
        <description>
                    The value of the Color element defines the default color
                    for the geometry.
                </description>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <group order="many">
            <element type="Point"/>
            <element type="LineSegment"/>
            <element type="Line"/>
            <element type="Ray"/>
            <element type="Polyline"/>
            <element type="Mesh"/>
            <element type="FacettedShell"/>
            <element type="Text"/>
            <element type="FacettedSubmodelReference"/>
            <element type="Arc"/>
            <element type="Circle"/>
            <element type="Ellipse"/>
            <element type="BSplineCurve"/>
            <element type="Cylinder"/>
            <element type="Sphere"/>
            <element type="Cone"/>
            <element type="Torus"/>
            <element type="Plane"/>
            <element type="BSplineSurface"/>
            <element type="BoundaryRep"/>
            <element type="SubmodelReference"/>
        </group>
    </ElementType>
    <ElementType name="SubmodelReference" content="eltOnly" order="seq" model="closed">
        <description>
                    SubmodelReference references a Submodel via the
                    submodel idref identifier.
                </description>
        <AttributeType name="submodel" dt:type="idref" required="yes"/>
        <attribute type="submodel"/>
        <element type="Color" minOccurs="0" maxOccurs="1"/>
        <element type="Link" minOccurs="0" maxOccurs="*"/>
        <element type="LinearCoordinateTransform" minOccurs="0" maxOccurs="1"/>
    </ElementType>
</Schema>


Schema Attributes Reference

open model
The element can contain elements, attributes, and text not specified in the content model. This is the default value.
closed model
The element cannot contain elements, attributes, and text except for those specified in the content model. DocumentTypeDefinitions use a closed model.
textOnly content
The element can contain only text, not elements. If the model attribute is set to "open," the element can contain text and additional elements.
eltOnly content
The element can contain only the elements, not free text. If the model attribute is set to "open," the element can contain text and additional elements.
empty content
The element cannot contain text or elements. If the model attribute is set to "open," the element can contain text and additional elements.
mixed content
The element can contain a mix of named elements and text. This is the default value.
one order
Only one of a set of elements is permitted.
seq order
The elements appear in the specified sequence.
many order
The elements are optional (they need not appear at all), but when present, they can appear in any order. This is the default.


Datatype Reference

bin.base64 datatype
MIME-style Base64 encoded binary BLOB
bin.hex datatype
Hexadecimal digits representing octets
boolean datatype
0 or 1, where 0 == "false" and 1 =="true"
char datatype
String, one character long
date datatype
Date in a subset ISO 8601 format, without the time data. For example: "1994-11-05"
dateTime datatype
Date in a subset of ISO 8601 format, with optional time and no optional zone. Fractional seconds can be as precise as nanoseconds. For example, "1988-04-07T18:39:09".
dateTime.tz datatype
Date in a subset ISO 8601 format, with optional time and optional zone. Fractional seconds can be as precise as nanoseconds. For example: "1988-04-07T18:39:09-08:00".
entity datatype
Represents the XML ENTITY type.
entities datatype
Represents the XML ENTITIES type.
enumeration datatype
Represents an enumerated type (supported for attributes only).
fixed.14.4 datatype
Same as "number" but no more than 14 digits to the left of the decimal point, and no more than 4 to the right.
float datatype
Real number, with no limit on digits; can potentially have a leading sign, fractional digits, and optionally an exponent. Punctuation as in U.S. English. Values range from 1.7976931348623157E+308 to 2.2250738585072014E-308.
id datatype
Represents the XML ID type.
idref datatype
Represents the XML IDREF type.
idrefs datatype
Represents the XML IDREFS type.
int datatype
Number, with optional sign, no fractions, and no exponent
nmtoken datatype
Represents the XML NMTOKEN type.
nmtokens datatype
Represents the XML NMTOKENS type.
notation datatype
Represents a NOTATION type.
number datatype
Number, with no limit on digits; can potentially have a leading sign, fractional digits, and optionally an exponent. Punctuation as in U.S. English. Values have same range as most significant number, R8, 1.7976931348623157E+308 to 2.2250738585072014E-308.
string datatype
Represents a string type.
time datatype
Time in a subset ISO 8601 format, with no date and no time zone; for example: "08:15:27".
time.tz datatype
Time in a subset ISO 8601 format, with no date but optional time zone; for example: "08:1527-05:00".
i1 datatype
Integer represented in one byte; a number, with optional sign, no fractions, no exponent—for example: "1, 127, -128".
i2 datatype
Integer represented in one word; a number, with optional sign, no fractions, no exponent—for example: "1, 703, -32768".
i4 datatype
Integer represented in four bytes; a number, with optional sign, no fractions, no exponent—for example: "1, 703, -32768, 148343, -1000000000".
r4 datatype
Real number, with seven-digit precision; can potentially have a leading sign, fractional digits, and optionally an exponent. Punctuation as in U.S. English. Values range from 3.40282347E+38F to 1.17549435E-38F.
r8
Real number, with 15-digit precision; can potentially have a leading sign, fractional digits, and optionally an exponent. Punctuation as in U.S. English. Values range from 1.7976931348623157E+308 to 2.2250738585072014E-308.
ui1 datatype
Unsigned integer; a number, unsigned, no fractions, no exponent—for example: "1, 255".
ui2 datatype
Unsigned integer, two bytes; a number, unsigned, no fractions, no exponent—for example: "1, 255, 65535".
ui4 datatype
Unsigned integer, four bytes; a number, unsigned, no fractions, no exponent—for example: "1, 703, 3000000000".
uri datatype
Uniform Resource Identifier (URI); for example, "urn:schemas-microsoft-com:Office9".
uuid datatype
Hexadecimal digits representing octets, optional embedded hyphens that are ignored; for example: "333C7BC4-460F-11D0-BC04-0080C7055A83".