►NHPS | |
CAbstractMethodException | Thrown if an abstract (pure virtual) method was called directly. |
CApplicationWindowKey | The ApplicationWindowKey class is a smart pointer to a database object. It is a handle to an application window Visualize can draw into. |
CApplicationWindowOptionsControl | The HPS::ApplicationWindowOptionsControl class is a smart pointer that is tied to a database object. It is used to query and manipulate options pertaining to an HPS::ApplicationWindowKey. Default values for the various fields of HPS::ApplicationWindowOptionsControl can be found here. |
CApplicationWindowOptionsKit | The ApplicationWindowOptionsKit class is a user space object. It is used to specify application-window-specific options. Calling HPS::ApplicationWindowOptionsKit::GetDefault() will return a kit with values found in this table. |
CAttributeLockControl | The HPS::AttributeLockControl class provides support for attribute locking, which allows temporarily override of an attribute setting for a segment and its descendants. This control is used to set and unset attribute locks at the segment level. For more information, see Core Graphics Programming Guide, section 1.2.4 - subsection "Attribute controls". This table lists default values for the various segment attributes accessible from HPS::AttributeLockControl. |
CAttributeLockKit | The HPS::AttributeLockKit class provides support for attribute locking, which allows temporarily override of an attribute setting for a segment and its descendants. This control is used to set and unset attribute locks at the segment level. Calling HPS::AttributeLockKit::GetDefault() will return a kit with values found in this table. |
CAxisTriadControl | The AxisTriadControl allows you to turn on or off the axis triad, move it to a specific corner of the screen, change the material palette used to style it, or otherwise manipulate it. |
CAxisTriadOperator | The AxisTriadOperator class defines an operator which allows the user to interact with the axis triad. This Operator works for both mouse- and touch-driven devices. Mouse-Driver Devices: Left Double Click: Double clicking on an axis snaps the view to that plane Left Button Down and Move: Rotates the scene Touch-Driven Devices: Double Tap: Double tapping on an axis snaps the view to that plane Tap and Move: Rotates the scene |
CBlankLinePatternElement | The BlankLinePatternElement class is a user space object. It is used for specifying blank elements within a line pattern. |
CBooleanMetadata | The BooleanMetadata class is a smart pointer. It represents a piece of boolean Metadata. |
CBoundingControl | The HPS::BoundingControl class is a smart pointer that is tied to a database object. This object allows you to manipulate settings related to bounding, such as volume and exclusion. This table lists default values for the various segment attributes accessible from HPS::BoundingControl. |
CBoundingKit | The HPS::BoundingKit class is a user space object, useful for carrying a group of attribute settings. Calling HPS::BoundingKit::GetDefault() will return a kit with values found in this table. |
CCADModel | The CADModel class is a smart pointer. It represents the root Component for a structured file format. |
CCameraChangedEvent | |
CCameraControl | The HPS::CameraControl class is a smart pointer that is tied to a database object. The CameraControl is used to manipulate the viewpoint, or camera, in a scene. Using this control, the view position, orientation, target, and aspect ratio of a segment's camera can be set. Cameras are considered segment attributes, but unlink other attributes, they inherit as a group down the segment hierarchy. This table lists default values for the various segment attributes accessible from HPS::CameraControl. |
CCameraKit | The HPS::CameraKit class is a user space object, useful for carrying a group of attribute settings. Calling HPS::CameraKit::GetDefault() will return a kit with values found in this table. |
CCameraPoint | |
CCanvas | The Canvas class is one of the four core display classes used in a Visualize application. It is meant to be used as part of a display hierarchy along with the Layout, View, and Model objects. The Canvas is the top-level object of the hierarchy and roughly correlates to a window. The Canvas is backed by an HPS::WindowKey. |
CCanvasDeletedEvent | |
CCapture | The Capture class is a smart pointer. It represents a capture, i.e., a collection of visibility settings, material settings, transformation settings, and camera, for a CADModel. |
CCaptureActivationEvent | |
CCircleKey | The CircleKey class is a smart pointer to a database object. It is a handle to a circle inserted via SegmentKey::InsertCircle. A circle has face geometry contained within its circumference. The visualization of the circle will be determined by attribute settings affecting faces and edges. |
CCircleKit | The HPS::CircleKit class is a user space object. It is a kit analog to a HPS::CircleKey. |
CCircularArcGlyphElement | The CircularArcGlyphElement class is a user space object. It is used to add circular arc elements to a glyph. |
CCircularArcKey | The CircularArcKey class is a smart pointer to a database object. It is handle to a circular arc inserted via SegmentKey::InsertCircularArc. A circular arc is the line geometry, as such its visualization will be determined by attributes affecting lines. |
CCircularArcKit | The CircularArcKit class is a user space object. It is a kit analog to a CircularArcKey. |
CCircularWedgeKey | The CircularWedgeKey class is a smart pointer to a database object. It is a handle to a circular wedge inserted via SegmentKey::InsertCircularWedge. A circular wedge has face geometry contained within the boundary edges of the circular wedge. The visualization of the wedge will be determined by attribute settings affecting faces and edges. |
CCircularWedgeKit | The CircularWedgeKit class is a user space object. It is a kit analog to a CircularWedgeKey. |
CColorInterpolationControl | The HPS::ColorInterpolationControl class is a smart pointer that is tied to a database object. This class is the interface that allows you to manipulate whether color is interpolated over faces and edges. This table lists default values for the various segment attributes accessible from HPS::ColorInterpolationControl. |
CColorInterpolationKit | The HPS::ColorInterpolationKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::ColorInterpolationKit::GetDefault() will return a kit with values found in this table. |
CComponent | The Component class is a smart pointer. It represents an arbitrary component of a structured file. |
CComponentHighlightEvent | The ComponentHighlightEvent class is the event that will be triggered for each highlight or unhighlight call. |
CComponentPath | The ComponentPath contains an array of components, organized from leaf to root. It allows the user to perform queries and operations along that path. |
CComponentTree | The ComponentTree class is a smart pointer which corresponds to a tree object in a GUI toolkit, e.g., a TreeView in WPF or a CTreeCtrl in MFC. This class can be derived from to facilitate tree creation in the various GUI toolkits. It is used to create a component or model browser. |
CComponentTreeItem | The ComponentTreeItem class is a smart pointer which corresponds to an item or node in a tree object in a GUI toolkit, e.g., a TreeViewItem in WPF or an HTREEITEM in MFC. This class must be derived from to facilitate tree creation in the various GUI toolkits. It is used to represent items in a component or model browser. |
CConditionalExpression | A ConditionalExpression is a string or collection of strings separated by logical operators. In practice, conditional expressions form a tree with the leaves being strings (the actual Conditions that must be satisfied) and the interior nodes being logical operators. |
CConditionControl | The ConditionControl class is a smart pointer that is tied to a database object. This class is used to set and unset conditions on a segment. A condition can be used to control when a style is applied, or to control when an included segment is included. |
CConstructRectangleOperator | |
CContourLineControl | The HPS::ContourLineControl class is a smart pointer that is tied to a database object. As its name suggests, this object can be used to control the various attributes related to contour lines, such as pattern, position, color, and weight. This table lists default values for the various segment attributes accessible from HPS::ContourLineControl. |
CContourLineKit | The HPS::ContourLineKit class is a user space object, useful for carrying a group of attribute settings. Calling HPS::ContourLineKit::GetDefault() will return a kit with values found in this table. |
CControl | The Control class is the base class for all Visualize controls. |
CCubeMapDefinition | The CubeMapDefinition class is a smart pointer to a database object. It is a handle to a cube map defined within a portfolio. |
CCullingControl | The HPS::CullingControl class is a smart pointer that is tied to a database object. Using this object, you are able to control the various options related to culling, such as enabling or disabling back face culling, vector culling, and frustum culling. This table lists default values for the various segment attributes accessible from HPS::CullingControl. |
CCullingKit | The HPS::CullingKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::CullingKit::GetDefault() will return a kit with values found in this table. |
CCurveAttributeControl | The HPS::CurveAttributeControl class is a smart pointer that is tied to a database object. This object is used to manipulate the various attributes related to curved lines, such as budget, angle, deviation, and length. This table lists default values for the various segment attributes accessible from HPS::CurveAttributeControl. |
CCurveAttributeKit | The HPS::CurveAttributeKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::CurveAttributeKit::GetDefault() will return a kit with values found in this table. |
CCutGeometryGatheringOptionsKit | |
CCuttingSectionAttributeControl | The HPS::CuttingSectionAttributeControl class is a smart pointer that is tied to a database object. This object is used to manipulate the various cutting section attributes. This table lists default values for the various segment attributes accessible from HPS::CuttingSectionAttributeControl. |
CCuttingSectionAttributeKit | The HPS::CuttingSectionAttributeKit class is a user space object which encapsulates a set of attributes pertaining to cutting sections. Calling HPS::CuttingSectionAttributeKit::GetDefault() will return a kit with values found in this table. |
CCuttingSectionKey | The CuttingSectionKey class is a smart pointer to a database object. It is a handle to a cutting section inserted via SegmentKey::InsertCuttingSection. |
CCuttingSectionKit | The CuttingSectionKit class is a user space object. It is a kit analog to a CuttingSectionKey. |
CCuttingSectionOperator | The CuttingSectionOperator class defines an operator which allows the user to insert and interact with cutting sections. This Operator works for both mouse- and touch-driven devices. Each instance of the operator supports inserting and interacting with a single cutting plane. Multiple instances of the operator can be pushed to the View’s operator stack when the user wants to add an additional cutting plane to the scene. The cutting plane associated with an instance of the operator will be removed when the operator is popped from the View’s operator stack |
CCylinderAttributeControl | The HPS::CylinderAttributeControl class is a smart pointer that is tied to a database object. This object is used to manipulate the various cylinder attributes, such as orientation and tessellation. This table lists default values for the various segment attributes accessible from HPS::CylinderAttributeControl. |
CCylinderAttributeKit | The HPS::CylinderAttributeKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::CylinderAttributeKit::GetDefault() will return a kit with values found in this table. |
CCylinderKey | The CylinderKey class is a smart pointer to a database object. It is a handle to a cylinder inserted via SegmentKey::InsertCylinder. |
CCylinderKit | The CylinderKit class is a user space object. It is a kit analog to a CylinderKey. |
CDebuggingControl | The HPS::DebuggingControl class is a smart pointer that is tied to a database object. Using this control, you are able to set and show the resource monitor. This control is only accessible from a HPS::WindowKey. This table lists default values for the various segment attributes accessible from HPS::DebuggingControl. |
CDebuggingKit | The HPS::DebuggingKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::DebuggingKit::GetDefault() will return a kit with values found in this table. |
CDefinition | The Definition class is a smart pointer to a database object. It is the base class for all definition objects. |
CDirectRGBColor | |
CDistantLightKey | The DistantLightKey class is a smart pointer to a database object. It is a handle to a distant light inserted via SegmentKey::InsertDistantLight. |
CDistantLightKit | The DistantLightKit class is a user space object. It is a kit analog to a DistantLightKey. |
CDotGlyphElement | The DotGlyphElement class is a user space object. It is used to dot elements to glyphs. |
CDoubleMetadata | The DoubleMetadata class is a smart pointer. It represents a piece of double Metadata. |
CDPoint | |
CDrawingAttributeControl | The HPS::DrawingAttributeControl class is a smart pointer that is tied to a database object. This object is used to manipulate various high-level settings, such as depth range, priority, and displacement. Note that some of the attributes available through this control should only be set for an entire window, while others can be set at multiple places.Global attributes: world handedness, polygon handedness, priority, depth range |
CDrawingAttributeKit | The HPS::DrawingAttributeKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::DrawingAttributeKit::GetDefault() will return a kit with values found in this table. |
CDrawWindowEvent | The DrawWindowEvent class is the event generated when the driver draws the window background for each subwindow. |
CDriverEvent | The DriverEvent class is the common base class of all driver events. A driver event represents a specific action the driver performs during an update. DriverEvents occur on the driver updater thread. |
CDriverEventHandler | The DriverEventHandler class is the base class for driver event handlers. Custom driver event handlers should inherit from this. |
CDVector | |
CEdgeAttributeControl | The HPS::EdgeAttributeControl class is a smart pointer that is tied to a database object. Using this control, you can manipulate the various attributes associated with geometry edges. Edges are present on any piece of facetted geometry.This table lists default values for the various segment attributes accessible from HPS::EdgeAttributeControl. |
CEdgeAttributeKit | The HPS::EdgeAttributeKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::EdgeAttributeKit::GetDefault() will return a kit with values found in this table. |
CEllipseGlyphElement | The EllipseGlyphElement class is a user space object. It is used to add ellipse elements to glyphs. |
CEllipseKey | The EllipseKey class is a smart pointer to a database object. It is a handle to an ellipse inserted via SegmentKey::InsertEllipse. |
CEllipseKit | The EllipseKit class is a user space object. It is the kit analog to an EllipseKey. |
CEllipticalArcKey | The EllipticalArcKey class is a smart pointer to a database object. It is a handle to an elliptical arc inserted via SegmentKey::InsertEllipticalArc. |
CEllipticalArcKit | The EllipticalArcKit class is a user space object. It is the kit analog to an EllipticalArcKey. |
CEmergencyHandler | The EmergencyHandler class is the base class for an custom EmergencyHandler. An EmergencyHandler allows the developer to provide custom logic to handle 'emergency' situations. For example, one can set a soft memory limit using HPS::Database::SetSoftMemoryLimit. If that limit is hit, Visualize will call the EmergencyHandler.An EmergencyHandler is set by calling HPS::Database::SetEmergencyHandler. Only one EmergencyHandler can be set on the Database. If you try to set a second handler, the first one will be overwritten.The default emergency handler will print a few diagnostics to stdout (when run in debug mode), but will make no attempt to recover from the emergency condition. |
CErrorEvent | The ErrorEvent class is the event that will be generated if an asynchronous error occurs. |
CEvent | The Event class is the common base class of all events. An event can be an error, input event, or a custom event. Events occur asynchronously and are processed in order from an event queue. |
CEventDispatcher | The EventDispatcher class is used for injecting any events and dealing with event handlers which handle those events. |
CEventHandler | The EventHandler class is the base class for any event handler that can be created. All custom event handlers should inherit from this. |
CEventNotifier | The EventNotifier class is a smart pointer that is tied to an event object. It is a special type of control that is used for synchronizing with an event's completion. |
CException | |
CFactory | The Factory class is used to create and query Sprocket objects. |
CFilter | The Filter class is a smart pointer. It represents a filter, i.e., a collection of visibility settings for a CADModel. |
CFilterActivationEvent | |
CFinishPictureEvent | The FinishPictureEvent class is the event generated when the driver finishes the update and puts the rendered image on screen (except for OffscreenWindows). |
CFlyOperator | The FlyOperator class defines an operator which allows the user to accurately move the camera around the scene. This Operator works for both mouse- and touch-driven devices. Mouse-Driven Devices: W: Move camera position and target forward A: Pan camera left S: Move camera position and target forward D: Pan camera right C: Pan camera down Space: Pan camera up Q: Roll camera left E: Roll camera right Right-button down and move: Rotate camera in place Shift: Walk at double the speed while pressed Ctrl: Walk at half the speed while pressed Mouse Wheel: Increase / Decrease step length Shift + Mouse Wheel: Increase / Decrease field of view Touch-Driven Devices: touch -left side of screen: Pans camera in left or right, moves camera forward or back touch -right side of screen: Rotates camera in place Two-finger touch -right side of screen: Pans camera up or down, rolls camera left or right The movement speed increases as the user drags his fingers away from the initial touch position |
CFocusLostEvent | The FocusLostEvent class is the event that is generated when an application loses focus |
CFontInfoState | The FontInfoState class is a user space object, useful for carrying a group attribute settings. |
CFontSearchResults | The FontSearchResults class is a smart-pointer to a database object. It contains the results of a Find operation. |
CFontSearchResultsIterator | An iterator used for traversing results from a search on an associated FontSearchResults object. |
CGeometryKey | |
CGlyphDefinition | The GlyphDefinition class is a smart pointer to a database object. It is a handler to a glyph defined within a portfolio. |
CGlyphElement | The GlyphElement class is a user space object. It is the base class for all glyph elements. |
CGlyphKit | The GlyphKit class is a user space object. It is used when defining a glyph. |
CGlyphLinePatternElement | The GlyphLinePatternElement class is a user space object. It is used for specifying glyphs elements within a line pattern. |
CGlyphPoint | |
CGridKey | The GridKey class is a smart pointer to a database object. It is a handle to a grid created by SegmentKey::InsertGrid. |
CGridKit | The GridKit class is a user space object. It is a kit analog to a GridKey. |
CHiddenLineAttributeControl | The HPS::HiddenLineAttributeControl class is a smart pointer that is tied to a database object. This control allows you to manipulate the various attributes associated with hidden lines. Hidden line is a rendering mode that applies to the scene as a whole. You should not set disparate hidden line attributes in your scene. This table lists default values for the various segment attributes accessible from HPS::HiddenLineAttributeControl. |
CHiddenLineAttributeKit | The HPS::HiddenLineAttributeKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::HiddenLineAttributeKit::GetDefault() will return a kit with values found in this table. |
CHideKeyboardEvent | The HideKeyboardEvent class is the event that can be used on mobile devices to request that the software keyboard be hidden |
CHighlightAreaOperator | |
CHighlightControl | The HPS::HighlightControl class is a smart pointer that is tied to a database object. It is used to control highlight and unhighlight operations on selection results, search results, key paths and keys. This table lists default * values for the various segment attributes accessible from HPS::HighlightControl. |
CHighlightEvent | The HighlightEvent class is the event that will be triggered for each highlight or unhighlight call. |
CHighlightOperator | |
CHighlightOptionsKit | The HighlightOptionsKit class is a user space object. It is used to hold settings needed when performing a highlight or unhighlight. HPS::HighlightOptionsKit::GetDefault() will return a highlight options kit with values found in this table. |
CImageDefinition | The ImageDefinition class is a smart pointer to a database object. It is a handle to an image defined within a portolfio. |
CImageKit | The ImageKit class is a user space object. It is used for specifying all data associated with images. |
CImportStatusEvent | The ImportStatusEvent class is the event that can be used by importers to let the user know what they are currently working on |
CIncludeKey | The IncludeKey class is a smart pointer to a database object. It is a handle to an include key created by SegmentKey::IncludeSegment. |
CIndexOutOfRangeException | An IndexOutOfRangeException is thrown when a user tries to access an array element beyond the valid range, typically when interacting with the points or faces defining geometry. |
CInfiniteLineGlyphElement | The InfiniteLineGlyphElement class is a user space object. It is used to add infinite line and ray elements to a glyph. |
CInfiniteLineKey | The InfiniteLineKey class is a smart pointer to a database object. It is a handle to an infinite line or ray inserted via SegmentKey::InsertInfiniteLine. |
CInfiniteLineKit | The InfiniteLineKit class is a user space object. It is a kit analog to an InfiniteLineKey. |
CInformationEvent | The InformationEvent class is the event that will be generated if an asynchronous informational message occurs. |
CInnerPixelPoint | |
CInnerWindowPoint | |
CInputEvent | The InputEvent class is the base class for input events such as MouseEvent, TouchEvent, and KeyboardEvent. It contains functionality which is common to all input event types, namely the state of modifier keys. |
CIntegerMetadata | The IntegerMetadata class is a smart pointer. It represents a piece of integer Metadata. |
CIntRectangle | |
CInvalidLicenseException | |
CInvalidObjectException | |
CInvalidOperationException | |
CInvalidSpecificationException | |
CIOException | The IOException class is an exception that is thrown if there was a problem during file import or export. |
CIONotifier | The IONotifier class is a smart-pointer that is tied to a file import. It is used to interact with an ongoing import or get the results from a completed import. |
CKey | The Key class is the common base class of all Visualize keys. Keys are handles to database objects and are the primary way of interacting with them (you would never modify a database object directly). The underlying mechanism is a smart pointer (assignment operator works like regular pointers). Attempting to use a deleted or otherwise invalid key will result in an InvalidObjectException. |
CKeyboardEvent | The KeyboardEvent class is the event generated for each key press and release. |
CKeyboardState | The KeyboardState class represents the state of a keyboard for a particular event. |
CKeyHasher | A std::hash compatible hasher for HPS::Key |
CKeyPath | The KeyPath contains an array of keys, organized from leaf to root. It allows the user to perform a number of queries along that path including accumulating net attributes and converting coordinates. |
CLayout | The Layout class is one of the four core display classes used in a Visualize application. It is meant to be used as part of a display hierarchy along with the Canvas, View, and Model objects. The parent of the Layout is the Canvas, and a Layout can have multiple Views. The Layout is meant to describe the way the Views are presented in the Canvas. Like the other three core objects, the Layout is backed by a HPS::SegmentKey. |
CLayoutDeletedEvent | |
CLayoutDetachedEvent | |
CLicense | |
CLightingAttributeControl | The HPS::LightingAttributeControl class is a smart pointer that is tied to a database object. This control is used to set the lighting interpolation algorithm. This table lists default values for the various segment attributes accessible from HPS::LightingAttributeControl. |
CLightingAttributeKit | The HPS::LightingAttributeKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::LightingAttributeKit::GetDefault() will return a kit with values found in this table. |
CLineAttributeControl | The HPS::LineAttributeControl class is a smart pointer that is tied to a database object. This control allows you to manipulate the weight and pattern of lines and polylines. This table lists default values for the various segment attributes accessible from HPS::LineAttributeControl. |
CLineAttributeKit | The HPS::LineAttributeKit class is a user space object, useful for carrying a group of attribute settings related to lines. Calling HPS::LineAttributeKit::GetDefault() will return a kit with values found in this table. |
CLineGlyphElement | The LineGlyphElement class is a user space object. |
CLineKey | The LineKey class is a smart pointer to a database object. It is a handle to a line inserted via SegmentKey::InsertLine. |
CLineKit | The LineKit class is a user space object. It is a kit analog to a LineKey. |
CLinePatternDefinition | The LinePatternDefinition class is a smart pointer to a database object. It is a handle to a line pattern defined within a portfolio. |
CLinePatternElement | The LinePatternElement class is a user space object. It is the base class for other line pattern element types. Line pattern elements are used to define a pattern that can be assigned lines or edges. |
CLinePatternKit | The LinePatternKit class is a user space object. It is used when defining a line pattern. |
CLinePatternOptionsKit | The LinePatternOptionsKit class is a user space object. It is used for specifying (or overriding) some line pattern options when setting a line pattern on a segment. |
CLinePatternParallelKit | The LinePatternParallelKit class is a user space object. It is used to define a single parallel within a line pattern. |
CMarkerAttributeControl | The HPS::MarkerAttributeControl class is a smart pointer that is tied to a database object. This control allows you to manipulate the marker size and symbol at the segment level. This table lists default values for the various segment attributes accessible from HPS::MarkerAttributeControl. |
CMarkerAttributeKit | The HPS::MarkerAttributeKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::MarkerAttributeKit::GetDefault() will return a kit with values found in this table. |
CMarkerKey | The MarkerKey class is a smart pointer to a database object. It is a handle to a marker inserted via SegmentKey::InsertMarker. |
CMarkerKit | The MarkerKit class is a user space object. It is a kit analog to a MarkerKey. |
►CMarkupOperator | The MarkupOperator class defines an operator which allows the user to insert mark-up text and geometry. This Operator works for both mouse- and touch-driven devices. The markup created through this operator will be deleted when the operator is popped from the View.The MarkupOperator allows users to add the following markup types:Freehand: For mouse driven devices, click and move the mouse to draw freehand markup. For touch driven devices, touch down and move your finger to draw freehand markupText: For mouse driven devices, click where you want to place text. Type with the keyboard and click elsewhere when you are done inserting the note. For touch driven devices, tap where you want to place text. Use the software keyboard to type, and hide the keyboard when you are done inserting the note. When inserting text markup on touch devices, the view will shift while inserting text, to allow you to always see the text you are inserting. The view will reset smoothly once you hide the keyboard.Circle: For mouse driven devices, click where you want to place the circle. Move the mouse while holding down the button associated with the operator to change the radius of the circle. For touch driven devices, there are two options available for inserting circle markups: a. tap where you want to place the circle and move your finger to change the circle radius b. tap with two fingers. Move and pinch with the fingers to change the position and radius of the circleRectangle: For mouse driven devices, click where you want to place the top left corner of the rectangle, Move the mouse while holding down the button associated with the operator to change the position of the bottom right corner of the rectangle. For touch driven devices, there are two options available for inserting rectangle markups: a. tap where you want to place the top left corner of the rectangle and move your finger to change the position of the bottom right corner. b. tap with two fingers. Move and pinch with the fingers to change the position and size of the rectangle.On devices with a keyboard, pressing Escape will delete the markup currently being inserted. An event of type MarkupInsertedEvent in injected after a markup is inserted. |
CMarkupInsertedEvent | |
CMaterialKit | The MaterialKit class is a user space object, useful for carrying a group of attribute settings. A MaterialKit can be associated with various geometry or subgeometery types using a material mapping kit or control. |
CMaterialMappingControl | The HPS::MaterialMappingControl class is a smart pointer that is tied to a database object. This object allows you to manipulate materials at the segment level. Examples of materials include texture, color, and gloss, among other things. Materials can be applied to geometry faces, edges, vertices, and text. Light color can also be set using this control. Materials can be applied at the segment, entity, or subentity level. In all MaterialMappingControl functions that take an RGBAColor, the alpha channel is ignored.This table lists default values for the various segment attributes accessible from HPS::MaterialMappingControl. |
CMaterialMappingKit | The HPS::MaterialMappingKit class is a user space object, used for grouping attribute settings related to materials. A HPS::MaterialMappingKit is assigned to a portfolio, which in turn associates the materials to various geometry or subgeometry. Calling HPS::MaterialMappingKit::GetDefault() will return a material mapping kit with values found in this table. |
CMaterialPaletteDefinition | The MaterialPaletteDefinition class is a smart pointer to a database object. It is a handle to a material palette defined within a portfolio. |
CMatrixKit | The MatrixKit class is a user space object, useful for carrying a group attribute settings. |
CMeshKey | The MeshKey class is a smart pointer to a database object. It is a handle to a mesh created by SegmentKey::InsertMesh. |
CMeshKit | The MeshKit class is a user space object. It is a kit analog to a MeshKey. |
CMetadata | The Metadata class is a smart pointer. It represents a variety of metadata, i.e., a (name, value) pair, which might be associated with a Component, e.g., IDs, names, layers, user-defined or format-specific attributes, etc. |
CModel | The Model class is one of the four core display classes used in a Visualize application. It is meant to be used as part of a display hierarchy along with the Canvas, Layout, and View objects. The parent of the Model is the View. The Model is meant to represent a segment which contains a geometric model. Like the other three core objects, the Model is backed by a HPS::SegmentKey. |
CModelDeletedEvent | |
CModelDetachedEvent | |
CModellingMatrixControl | The ModellingMatrixControl class is a smart pointer that is tied to a database object. This control gives you access to a segment's modelling matrix. You can set an entire matrix or individual elements. Additionally, this class provides a small set of utility methods for all the basic transformations, as well as getting the matrix adjoint and determinant. Elements of modelling matrices are in row-major order. |
CModifierKeys | |
CMouseButtons | |
CMouseEvent | The MouseEvent class is the event generated for each mouse action. |
CMouseState | The MouseState class represents the state of the mouse or similar pointer device for a particular event. |
CMouseWheelOperator | |
CNamedStyleDefinition | The NamedStyleDefinition class is a smart pointer to a database object. It is a handle to a named style defined within a portfolio. |
CNavigationCubeControl | The navigationCubeControl allows you to turn on or off the navigation cube, move it to a specific corner of the screen, change the material palette used to style it, or otherwise manipulate it. |
CNavigationCubeOperator | The NavigationCubeOperator class defines an operator which allows the user to interact with the navigation cube. This Operator works for both mouse- and touch-driven devices. Mouse-Driver Devices: Left Button Down: Snap view to plane Left Button Down and Move: Rotates the scene Touch-Driven Devices: Tap: Snaps view to plane Tap and Move: Rotates the scene |
CNormalizedPoint | |
CNURBSCurveKey | The NURBSCurveKey class is a smart pointer to a database object. It is a handle to a NURBS curve inserted via SegmentKey::InsertNURBSCurve. |
CNURBSCurveKit | The NURBSCurveKit class is a user space object. It is a kit analog to a NURBSCurveKey. |
CNURBSSurfaceAttributeControl | The HPS::NURBSSurfaceAttributeControl class is a smart pointer that is tied to a database object. This object allows you to manipulate various settings related to NURBS surfaces, such as budget, angle, deviation, and width. This table lists default values for the various segment attributes accessible from HPS::NURBSSurfaceAttributeControl. |
CNURBSSurfaceAttributeKit | The HPS::NURBSSurfaceAttributeKit class is a user space object that contains settings related to NURBS surfaces. Calling HPS::NURBSSurfaceAttributeKit::GetDefault() will return a kit with values found in this table. |
CNURBSSurfaceKey | The NURBSSurfaceKey class is a smart pointer to a database object. It is a handle to a NURBS surface inserted via SegmentKey::InsertNURBSSurface. |
CNURBSSurfaceKit | The NURBSSurfaceKit class is a user space object. It is a kit analog to a NURBSSurfaceKey. |
CObject | The Object class is the common base class of most Visualize classes. |
CObjectPoint | |
COffScreenWindowKey | The OffScreenWindowKey class is a smart pointer to a database object. Offscreen windows are special types of windows that represent images that can be rendered into. |
COffScreenWindowOptionsControl | The HPS::OffScreenWindowOptionsControl class is a smart pointer that is tied to a database object. It is used to query offscreen-window-specific options on an OffScreenWindowKey. This control also gives you the ability to make a screenshot of the Visualize scene using ShowImage. This table lists default values for the various segment attributes accessible from HPS::OffScreenWindowOptionsControl. |
COffScreenWindowOptionsKit | The HPS::OffScreenWindowOptionsKit class is a user space object. It is used to specify off-screen-window-specific options. Calling HPS::OffScreenWindowOptionsKit::GetDefault() will return an options kit with values found in this table. |
COperator | The Operator class is the base class for classes which handle under input and operate on the scene. This class handles GUI events such as key presses, mouse movement and clicks, and touches |
COperatorControl | The OperatorControl class is a smart pointer that is tied to a database object. This control allows you to add, remove, or otherwise manipulate operators associated with a view. |
COrbitOperator | The OrbitOperator class defines an operator which allows the user to orbit the camera. This Operator works for both mouse- and touch-driven devices. Mouse-Driven Devices: Left button pressed and move: Orbit camera Touch-Driven Devices: Touch down and move: Orbit camera |
CPanOperator | The PanOperator class defines an operator which allows the user to pan the camera. This Operator works for both mouse- and touch-driven devices. Mouse-Driven Devices: Left button pressed and move: Pan camera Touch-Driven Devices: Touch down and move: Pan camera |
CPanOrbitZoomOperator | The PanOrbitZoomOperator class defines an operator which allows the user to pan, orbit and zoom the camera. This Operator works for both mouse- and touch-driven devices. Mouse-Driven Devices: Left button pressed and move: Orbit camera Left button pressed and move + Shift: Pan camera Left button pressed and move + Ctrl: Zoom camera Touch-Driven Devices: Touch down and move: Orbit camera Two finger touch and move: Pan camera Pinch: Zoom camera |
CPerformanceControl | The HPS::PerformanceControl class is a smart pointer that is tied to a database object. This object is used to enable and disable performance-related attributes, such as display lists and static model. This table lists default values for the various segment attributes accessible from HPS::PerformanceControl. |
CPerformanceKit | The HPS::PerformanceKit class is a user space object, useful for carrying a group of attribute settings related to performance settings. Calling HPS::PerformanceKit::GetDefault() will return a kit with values found in this table. |
CPixelPoint | |
CPlane | |
CPlane2D | |
CPoint | |
CPoint2D | |
CPolygonKey | The PolygonKey class is a smart pointer to a database object. It is a handle to a polygon created by SegmentKey::InsertPolygon. |
CPolygonKit | The PolygonKit class is a user space object. It is a kit analog to a PolygonKey. |
CPortfolioControl | The PortfolioControl class is a smart pointer that is tied to a database object. Controls are used for manipulating settings within the database. |
CPortfolioKey | The PortfolioKey class is a smart pointer to a database object. Portfolios are special objects that can only contain definitions. A segment can use a portfolio to gain access to the definitions it contains. |
CPostProcessEffectsControl | The HPS::PostProcessEffectsControl class is a smart pointer that is tied to a database object. This object is effective only for the shader-based driver interfaces such as DirectX and OpenGL2. Ambient occlusion, bloom, silhouette edges, and depth of field are all enabled through this control. Default values for the various fields of HPS::PostProcessEffectsControl can be found here. |
CPostProcessEffectsKit | The HPS::PostProcessEffectsKit class is a user space object, useful for carrying a group of attribute settings related to post-process effects. Calling HPS::PostProcessEffectsKit::GetDefault() will return a kit with values found in this table. |
CQuaternion | |
CRectangle | |
CReferenceKey | The ReferenceKey class is a smart pointer to a database object. It is a handle to a geometry reference returned by SegmentKey::ReferenceGeometry. |
CRelativeOrbitOperator | |
CRGB24Color | |
CRGBA32Color | |
CRGBAColor | |
CRGBAS32Color | |
CRGBColor | |
CSceneTree | The SceneTree class is a smart pointer which corresponds to a tree object in a GUI toolkit, e.g., a TreeView in WPF or a CTreeCtrl in MFC. This class can be derived from to facilitate tree creation in the various GUI toolkits. It is used to create a scene graph or segment browser. |
CSceneTreeItem | The SceneTreeItem class is a smart pointer which corresponds to an item or node in a tree object in a GUI toolkit, e.g., a TreeViewItem in WPF or an HTREEITEM in MFC. This class must be derived from to facilitate tree creation in the various GUI toolkits. It is used to represent items in a scene graph or segment browser. |
CScreenRangePoint | |
CSearchOptionsKit | The SearchOptionsKit class is a user space object. It contains options used when performing a search. |
CSearchResults | The SearchResults class is a smart-pointer to a database object. It contains the results of a Find operation. |
CSearchResultsIterator | An iterator used for traversing results from a search on an associated SearchResults object. |
CSegmentKey | The SegmentKey class is a smart pointer to a database object. Segments are the nodes in the scene graph. They can contain attributes, geometry, or other segments, among other things. |
CSegmentOptimizationOptionsKit | Configuration options kit for controlling HPS::Segment::Optimize behavior. |
CSelectabilityControl | The SelectabilityControl class is a smart pointer that is tied to a database object. This object allows you to set and unset the selectability of the various types of geometry, such as faces, lines, markers, and vertices.Default values for the various fields of SelectabilityControl can be found here. |
CSelectabilityKit | The HPS::SelectabilityKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::SelectabilityKit::GetDefault() will return a kit with values found in this table. |
CSelectAreaOperator | The HPS::SelectAreaOperator class is a selection mechanism that operates on a rectangle input. As with all operators, this operator must be made active on a HPS::View object before it can be used. The results of the last selection can be obtained by calling GetActiveSelection(). Selection options such as granularity, algorithm, proximity, and more are set using a HPS::SelectionOptionsKit passed to SetSelectionOptions. See Programming Guide section "User Interaction" for more details on how to use operators. |
CSelectionControl | The SelectionControl class is a smart pointer that is tied to a database object. It is used to perform both window space selections (by point, by area, by polygon, by line) and object space selections (by shell, by volume, by ray). |
CSelectionItem | The SelectionItem class is a smart-pointer to a database object. It represents an item in a SelectionResults object. |
CSelectionOptionsControl | The HPS::SelectionOptionsControl class is a smart pointer that is tied to a database object. It is used to set selection related options on a HPS::WindowKey. Options include the selection algorithm, granularity, internal limit, related limit, level, proximity, and sorting. Default values for the various fields of HPS::SelectionOptionsControl can be found here. |
CSelectionOptionsKit | The SelectionOptionsKit class is a user space object. It contains options related to selection. Default values for the SelectionOptionsKit can be found in this table. |
CSelectionResults | The SelectionResults class is a smart pointer to a database object. It is a handle to the results of a selection action and allows iteration over them. When there are no remaining handles to a given selection result, the memory associated with it is freed. |
CSelectionResultsIterator | The SelectionResultsIterator class is used to iterate over a SelectionResults object and access the SelectionItem objects contained within it. |
CSelectOperator | The HPS::SelectOperator class is a selection mechanism that is intended to operate on a single selection point. As with all operators, this operator must be made active on a HPS::View object before it can be used. The results of the last selection can be obtained by calling GetActiveSelection(). Selection options such as granularity, algorithm, proximity, and more are set using a HPS::SelectionOptionsKit passed to SetSelectionOptions. See Programming Guide section "User Interaction" for more details on how to use operators. |
CShaderDefinition | Internal use only - customers should not use. The ShaderDefinition class is a smart pointer to a database object. It is a handle to a shader defined within a portfolio. |
CShaderKit | Internal use only - customers should not use. The ShaderKit class is a user space object. It is used for specifying all settings related to a ShaderDefinition. |
CShellKey | The ShellKey class is a smart pointer to a database object. It is a handle to a shell created by SegmentKey::InsertShell. |
CShellKit | The ShellKit class is a user space object. It is the kit analog to a ShellKey. |
CShellOptimizationOptionsKit | The ShellOptimizationOptionsKit class is a user space object. It is used for setting options for a shell optimization operation. Calling HPS::ShellOptimizationOptionsKit::GetDefault() will return an options kit with values found in this table. |
CShellRelationOptionsKit | The HPS::ShellRelationOptionsKit class is a user space object. It is used for setting options for a shell relation operation. Calling HPS::ShellRelationOptionsKit::GetDefault() will return an options kit with values found in this table. |
CShellRelationResultsKit | The ShellKit class is a user space object. It contains results from a shell relation operation. |
CShowKeyboardEvent | The ShowKeyboardEvent class is the event that can be used on mobile devices to request that the software keyboard be shown |
CSimpleCuboid | |
CSimpleSphere | |
CSimpleWalkOperator | The SimpleWalkOperator class defines an operator which allows the user to move forward and backwards and rotate while staying snapped to a plane. This Operator works for both mouse-driven devices only. Mouse-Driven Devices: Left-mouse button down and move: Pans the camera forward and backward, or rotates the scene based on the movement direction. The mouse sensitivity changes based on how far the mouse is dragged from the starting point Shift + Mouse Wheel: Increases / Decreases field of view |
CSmoothTransitionCompleteEvent | The SmoothTransitionCompleteEvent class is the event that will be triggered when a Smooth Transition ends. |
CSolidLinePatternElement | The SolidLinePatternElement class is a user space object. It is used for specifying solid elements within a line pattern. |
CSphereAttributeControl | The HPS::SphereAttributeControl class is a smart pointer that is tied to a database object. This control gives you access to the tessellation value for spheres. This table lists default values for the various segment attributes accessible from HPS::SphereAttributeControl. |
CSphereAttributeKit | The HPS::SphereAttributeKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::SphereAttributeKit::GetDefault() will return a kit with values found in this table. |
CSphereGlyphElement | The SphereGlyphElement class is a user space object. It is used to add ellipse elements to glyphs. |
CSphereKey | The SphereKey class is a smart pointer to a database object. It is a handle to a sphere inserted via SegmentKey::InsertSphere. |
CSphereKit | The SphereKit class is a user space object. It is a kit analog to a SphereKey. |
CSpotlightKey | The SpotlightKey class is a smart pointer to a database object. It is a handle to a spotlight inserted via SegmentKey::InsertSpotlight. |
CSpotlightKit | The HPS::SpotlightKit class is a user space object. It is the kit counterpart to a HPS::SpotlightKey. Calling HPS::SpotlightKit::GetDefault() will return a kit with values found in this table. |
CSprocket | |
CSprocketControl | |
CSprocketPath | The SprocketPath class is a utility class which can be used to automatically obtain a KeyPath from the Model to the Canvas. |
CStandAloneWindowEvent | The StandAloneWindowEvent class is the event that is generated by a Standalone window. |
CStandAloneWindowKey | The StandAloneWindowKey object is a handle to a stand-alone window that Visualize can draw into. Standalone windows are always directly created by Visualize. The Visualize rendering context will use the entire window for rendering. Standalone windows are only supported on Microsoft Windows and Linux platforms. |
CStandAloneWindowOptionsControl | The HPS::StandAloneWindowOptionsControl class is a smart pointer that is tied to a database object. It is used to set and query stand-alone-window-specific options on a HPS::StandAloneWindowKey. Default values for the various fields of HPS::StandAloneWindowOptionsControl can be found here. |
CStandAloneWindowOptionsKit | The StandAloneWindowOptionsKit class is a user space object. It is used to specify stand-alone-window-specific options Calling HPS::StandAloneWindowOptionsKit::GetDefault() will return an options kit with values found in this table. |
CStringMetadata | The StringMetadata class is a smart pointer. It represents a piece of string Metadata. |
CStyleControl | The StyleControl class is a smart pointer that is tied to a database object. Controls are used for manipulating settings within the database. |
CStyleKey | The StyleKey class is a smart pointer to a database object. It is a handle to a style key created by StyleControl::PushSegment. |
CSubwindowControl | The HPS::SubwindowControl class is a smart pointer that is tied to a database object. The HPS::SubwindowControl allows you to manipulate the various settings associated with subwindows, such as border, background, and priority. As the main Visualize window is also an implicit subwindow, this control also allows you to set the rendering algorithm. The rendering algorithm should only have a single setting for each window or subwindow. Setting disparate rendering algorithms in multiple places in your scene can lead to unexpected results. Default values for the various fields of HPS::SubwindowControl can be found here. |
CSubwindowKit | The HPS::SubwindowKit class is a user space object, useful for carrying a group of attribute settings related to subwindows. Calling HPS::SubwindowKit::GetDefault() will return a kit with values found in this table. |
CTextAttributeControl | The HPS::TextAttributeControl class is a smart pointer that is tied to a database object. This object gives you access to all the attributes associated with text, such as font, size, and rotation. Text characteristics such as bold, italic, and underline are also accessed through the HPS::TextAttributeControl. Default values for the various fields of HPS::TextAttributeControl can be found here. |
CTextAttributeKit | The HPS::TextAttributeKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::TextAttributeKit::GetDefault() will return a kit with values found in this table. |
CTextInputEvent | The TextInputEvent class is the event that is generated when an application receives text input |
CTextKey | The TextKey class is a smart pointer to a database object. It is a handle to text inserted via SegmentKey::InsertText. |
CTextKit | The TextKit class is a user space object. It is the kit analog to a TextKey. |
CTextureDefinition | The TextureDefinition class is a smart pointer to a database object. It is a handler to a texture defined within a portfolio. |
CTextureMatrixControl | The TextureMatrixControl class is a smart pointer that is tied to a database object. It controls the various attributes related to texture matrices. |
CTextureOptionsKit | The TextureOptionsKit class is a user space object. It is used for setting texture options when defining textures or cube maps. Calling HPS::TextureOptionsKit::GetDefault() will return an options kit with values found in this table. |
CTimeMetadata | The TimeMetadata class is a smart pointer. It represents a piece of time Metadata, i.e., a 32-bit integer to be interpreted as time_t. |
CTimerTickEvent | The TimerTickEvent class is the event that will be triggered for each timer tick. |
CTouch | |
CTouchEvent | The TouchEvent class is the event generated for each touch action on a multi-touch device. |
CTouchState | The TouchState class represents the state of touches on a multi-touch device for a particular event. |
CTransformMaskControl | The HPS::TransformMaskControl class is a smart pointer that is tied to a database object. This class allows you to manipulate the settings associated with a transform mask. A transform mask allows a segment to ignore its inherited transform. For example, if you want to be able to rotate a scene at a high level, but have a piece of geometry ignore rotations, you could achieve that effect using a transform mask. This table lists default values for the various segment attributes accessible from HPS::TransformMaskControl. |
CTransformMaskKit | The HPS::TransformMaskKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::TransformMaskKit::GetDefault() will return a kit with values found in this table. |
CTransparencyControl | The HPS::TransparencyControl class is a smart pointer that is tied to a database object. This object allows you to set and unset the algorithms used for calculating transparency. Some algorithms, such as depth peeling, have additional attributes, and those are also controlled using this class. Default values for the various fields of HPS::TransparencyControl can be found here. |
CTransparencyKit | The HPS::TransparencyKit class is a user space object, useful for carrying a group of attribute settings related to transparency. Calling HPS::TransparencyKit::GetDefault() will return a kit with values found in this table. |
CTreeContext | The TreeContext class is a user space object. It contains a spatial partition used for selection and relation computations with shells. If many world-space selections are going to be computed without modifying the segment tree, using the same tree context for all of them can be a significant optimization. If one is not specified, a new one is computed internally each time. |
CTrimElement | The TrimElement class is a user space object. It is used to specify the curves that are used to define a trim region. |
CTrimKit | The TrimKit class is a user space object. It is used to define trim curves (either NURBS curves or lines) that can be used to trim NURBS surfaces. |
CTurntableOperator | The TurntableOperator class defines an operator which allows the user to orbit the camera along a specific axis. This Operator works for both mouse- and touch-driven devices. Mouse-Driven Devices: Left button pressed and move: Orbit camera around z-axis Mouse wheel: Orbit camera around y-axis Left click + Control: Selects click location as rotation center Touch-Driven Devices: Touch down and move: Orbit camera around z-axis Two finger touch and move: Orbit camera around y-axis Double Tap: Selects click location as rotation center |
CUnsignedIntegerMetadata | The UnsignedIntegerMetadata class is a smart pointer. It represents a piece of unsigned integer Metadata. |
CUpdateCompletedEvent | The UpdateCompletedEvent class is the event that is generated when an update is completed |
CUpdateInfo | |
CUpdateNotifier | The UpdateNotifier class is a smart pointer that is tied to a window update. It is a special type of control that is used for synchronizing with an window update status. |
CUpdateOptionsControl | The HPS::UpdateOptionsControl class is a smart pointer that is tied to a database object. It is used to set selection related options on a HPS::WindowKey. Options include the selection algorithm, granularity, internal limit, related limit, level, proximity, and sorting. Default values for the various fields of HPS::UpdateOptionsControl can be found here. |
CUpdateOptionsKit | The HPS::UpdateOptionsKit class is a user space object. It contains options related to selection. Calling HPS::UpdateOptionsKit::GetDefault() will return a kit with values found in this table. |
CUTF8Hasher | A std::hash compatible hasher for HPS::UTF8 |
CVector | |
CVector2D | |
CView | The View class is one of the four core display classes used in a Visualize application. It is meant to be used as part of a display hierarchy along with the Canvas, Layout, and Model objects. The View has a parent Layout and can contain a single Model. The View is meant to represent one particular camera's view of the scene. Like the other three core objects, the View is backed by a HPS::SegmentKey. |
CViewDeletedEvent | |
CViewDetachedEvent | |
CVisibilityControl | The HPS::VisibilityControl class is a smart pointer that is tied to a database object. This control allows you to set and unset the visibility of any type of geometry or subentity in the scene. The visibility of windows is also controlled here. Additionally, various behaviors such as casting and emitting shadows is also done through this control. Default values for the various fields of HPS::VisibilityControl can be found here. |
CVisibilityKit | The HPS::VisibilityKit class is a user space object, useful for carrying a group of attribute settings. Calling HPS::VisibilityKit::GetDefault() will return a kit with values found in this table. |
CVisualEffectsControl | The HPS::VisualEffectsControl class is a smart pointer that is tied to a database object. This object enables you to set and unset various visual effects, such as shadows (including shadow color), reflection planes, and anti-aliasing. Default values for the various fields of HPS::VisualEffectsControl can be found here. |
CVisualEffectsKit | The HPS::VisualEffectsKit class is a user space object, useful for carrying a group attribute settings. Calling HPS::VisualEffectsKit::GetDefault() will return a kit with values found in this table. |
CWalkOperator | The WalkOperator class defines an operator which allows the user to accurately move the camera around the scene, while snapped to a plane. This operator works for both mouse and touch-driven devices. Mouse-driven devices: |
CWarningEvent | The WarningEvent class is the event that will be generated if an asynchronous warning occurs. |
CWindowInfoControl | The WindowInfoControl class is a smart pointer that is tied to a database object. This object allows you to query various attributes about a window, such as its size and aspect ratio. |
CWindowInfoKit | The WindowInfoKit class is a user space object, useful for carrying a group attribute settings. |
CWindowKey | The WindowKey class is a smart pointer to a database object. Windows are special segments that are backed by a driver instance and a physical window. Some operations and attributes can only be performed or set from window keys. The WindowKey class itself is a base class for more specific window types (application windows, off-screen windows, stand-alone windows). |
CWindowPoint | |
CWorld | The World class is a special object that must be constructed prior to making any database calls and must exist for the life of the application. |
CWorldPoint | |
CZoomBoxOperator | |
CZoomFitTouchOperator | The ZoomFitTouchOperator class defines an operator which fits the camera to the model currently loaded. This Operator works for touch-driven devices only. Touch-Driven Devices: Double Tap: Fits the camera to the model currently loaded. |
CZoomOperator | The ZoomOperator class defines an operator which allows the user to zoom the camera. This Operator works for both mouse- and touch-driven devices. Mouse-Driven Devices: Left button pressed and move: Zoom camera Touch-Driven Devices: Pinch: Zoom camera |