# HCA

class `HCA`

  The HCA class contains objects used for importing Stream Cache files.

  Public Types

  typedef ::std::shared_ptr<ModelTreeItem> `ModelTreeItemPtr`
  typedef ::std::shared_ptr<ModelTree> `ModelTreePtr`
  class `File`

    The File class provides functions to import Stream Cache files.

    Public Static Functions

    static ImportNotifier `Import`(char const *in_file_name, ImportOptionsKit const &in_options)

      Performs an asynchronous local import of the specified Stream Cache file with the provided options. May throw an IOException prior to starting the asynchronous import. After the import has started it will take place on a separate thread. The status of the import can be checked using the returned ImportNotifier. It is possible to wait for the import to complete by using the Wait method from the returned ImportNotifier. While it is possible to interact with the scene’s camera even before the model has fully finished loading, attempting to select the model, highlight it, hide, isolate or show parts of it while it is being loaded will result in an exception being thrown.

      Deprecated:

        This function has been deprecated.

      Parameters: | in_file_name – The name of the file to import. in_options – The options controlling the import of the Stream Cache file.
      Returns: | An ImportNotifier object that can be used to query the import progress and status.

    static void `Import`(char const *in_file_name, ImportOptionsKit const &in_options, ImportNotifier &in_notifier)

      Performs an asynchronous local import of the specified Stream Cache file with the provided options. May throw an IOException prior to starting the asynchronous import. After the import has started it will take place on a separate thread. The status of the import can be checked using the returned ImportNotifier. It is possible to wait for the import to complete by using the Wait method from the returned ImportNotifier. While it is possible to interact with the scene’s camera even before the model has fully finished loading, attempting to select the model, highlight it, hide, isolate or show parts of it while it is being loaded will result in an exception being thrown.

      Parameters: | in_file_name – The name of the file to import. in_options – The options controlling the import of the Stream Cache file. in_notifier – The notifier to be used during the import
      Returns: | An ImportNotifier object that can be used to query the import progress and status.

    static ImportNotifier `Import`(char const *in_file_name, NetworkImportOptionsKit const &in_options)

      Performs an asynchronous import of the specified Stream Cache file with the provided options over the network. May throw an IOException prior to starting the asynchronous import. After the import has started it will take place on a separate thread. The Wait method from the returned ImportNotifier can be used to wait for the minimum necessary model data is imported. Once Wait returns, it is safe to interact with the model, even as geometry continues to stream in. Attempting to select, highlight, isolate, hide, or show parts of the model before Wait returns can result in an exception being thrown.

      Deprecated:

        This function has been deprecated.

      Parameters: | in_file_name – The name of the file to import. in_options – The options controlling the import of the Stream Cache file.
      Returns: | An ImportNotifier object that can be used to query the import progress and status.

    static void `Import`(char const *in_file_name, NetworkImportOptionsKit const &in_options, ImportNotifier &in_notifier)

      Performs an asynchronous import of the specified Stream Cache file with the provided options over the network. May throw an IOException prior to starting the asynchronous import. After the import has started it will take place on a separate thread. The Wait method from the returned ImportNotifier can be used to wait for the minimum necessary model data is imported. Once Wait returns, it is safe to interact with the model, even as geometry continues to stream in. Attempting to select, highlight, isolate, hide, or show parts of the model before Wait returns can result in an exception being thrown.

      Parameters: | in_file_name – The name of the file to import. in_options – The options controlling the import of the Stream Cache file. in_notifier – The notifier to be used during the import
      Returns: | An ImportNotifier object that can be used to query the import progress and status.

  class `ImportNotifier` : public HPS::IONotifier

    The ImportNotifier 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.

    Public Functions

    void `Assign`(ImportNotifier const &in_that)

      Associate this ImportNotifier with the same file import as the source ImportNotifier.

      Parameters: | in_that – The source ImportNotifier for the assignment.

    HPS::Model &`GetTarget`() const

      Get the the Model where the Stream Cache file was imported into. Throws an IOException if the import is not complete or was not successful.

      Returns: | The Model containing the Stream Cache file for a successful file import.

    `ImportNotifier`()

      The default constructor creates an ImportNotifier object which is not tied to any file import.

    `ImportNotifier`(ImportNotifier &&in_that)

      The move constructor creates an ImportNotifier by transferring the underlying impl of the rvalue reference to this ImportNotifier thereby avoiding a copy and allocation.

      Parameters: | in_that – An rvalue reference to an ImportNotifier to take the impl from.

    `ImportNotifier`(ImportNotifier const &in_that)

      The copy constructor creates a new ImportNotifier object that is associated with the same file import as the source ImportNotifier.

      Parameters: | in_that – The source ImportNotifier to copy.

    `ImportNotifier`(IONotifier const &in_that)

      The conversion constructor creates a new derived ImportNotifier object from a base IONotifier object. The copy will only be successful if the source notifier is really an upcast of this notifier type. Otherwise the copy will fail and the resulting ImportNotifier will be invalid.

      Parameters: | in_that – The source IONotifier to copy.

    inline virtual HPS::Type `ObjectType`() const

      This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

      Returns: | The declared type of the object in question, which may differ from the true, underlying type.

    ImportNotifier &`operator=`(ImportNotifier &&in_that)

      The move assignment operator transfers the underlying impl of the rvalue reference to this ImportNotifier thereby avoiding a copy.

      Parameters: | in_that – An rvalue reference to an ImportNotifier to take the impl from.
      Returns: | A reference to this ImportNotfier.

    ImportNotifier &`operator=`(ImportNotifier const &in_that)

      Associate this ImportNotifier with the same file import as the source ImportNotifier.

      Parameters: | in_that – The source ImportNotifier for the assignment.
      Returns: | A reference to this ImportNotifier.

    virtual `~ImportNotifier`()

    Public Static Attributes

    static const HPS::Type `staticType` = HPS::Type::HCAImportNotifier
  class `ImportOptionsKit` : public HPS::Sprocket

    The HPS::HCA::ImportOptionsKit class is a user space object. It contains settings controlling what and how Stream Cache data is imported via the HCA Sprocket.

    Public Functions

    virtual bool `Empty`() const

      Indicates whether this ImportOptionsKit has any values set on it.

      Returns: | true if no values are set on this ImportOptionsKit, false otherwise.

    bool `Equals`(ImportOptionsKit const &in_kit) const

      Check if the source ImportOptionsKit is equivalent to this ImportOptionsKit.

      Parameters: | in_kit – The source ImportOptionsKit to compare to this ImportOptionsKit.
      Returns: | true if the objects are equivalent, false otherwise.

    `ImportOptionsKit`()

      The default constructor creates an empty ImportOptionsKit object.

    `ImportOptionsKit`(ImportOptionsKit &&in_that)

      The move constructor creates an ImportOptionsKit by transferring the underlying impl of the rvalue reference to this ImportOptionsKit thereby avoiding a copy and allocation.

      Parameters: | in_that – An rvalue reference to an ImportOptionsKit to take the impl from.

    `ImportOptionsKit`(ImportOptionsKit const &in_kit)

      The copy constructor creates a new ImportOptionsKit object that contains the same settings as the source ImportOptionsKit.

      Parameters: | in_kit – The source ImportOptionsKit to copy.

    inline virtual HPS::Type `ObjectType`() const

      This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

      Returns: | The declared type of the object in question, which may differ from the true, underlying type.

    bool `operator!=`(ImportOptionsKit const &in_kit) const

      Check if the source ImportOptionsKit is not equivalent to this ImportOptionsKit.

      Parameters: | in_kit – The source ImportOptionsKit to compare to this ImportOptionsKit.
      Returns: | true if the objects are not equivalent, false otherwise.

    ImportOptionsKit &`operator=`(ImportOptionsKit &&in_that)

      The move assignment operator transfers the underlying impl of the rvalue reference to this ImportOptionsKit thereby avoiding a copy.

      Parameters: | in_that – An rvalue reference to an ImportOptionsKit to take the impl from.
      Returns: | A reference to this ImportOptionsKit.

    ImportOptionsKit &`operator=`(ImportOptionsKit const &in_kit)

      Copies the source ImportOptionsKit into this ImportOptionsKit.

      Parameters: | in_kit – The source ImportOptionsKit to copy.
      Returns: | A reference to this ImportOptionsKit.

    bool `operator==`(ImportOptionsKit const &in_kit) const

      Check if the source ImportOptionsKit is equivalent to this ImportOptionsKit.

      Parameters: | in_kit – The source ImportOptionsKit to compare to this ImportOptionsKit.
      Returns: | true if the objects are equivalent, false otherwise.

    void `Set`(ImportOptionsKit const &in_kit)

      Copies the source ImportOptionsKit into this ImportOptionsKit.

      Parameters: | in_kit – The source ImportOptionsKit to copy.

    ImportOptionsKit &`SetJavascriptPath`(HPS::UTF8 const &javascript_path)

      Sets the path to hc_access.js which will be used during the import. Setting a Javascript Path is required for the import to succeed. The hc_access.js file is provided with HOOPS Visualize.

      Parameters: | javascript_path – Path of the javascript file to use.
      Returns: | A reference to this ImportOptionsKit.

    ImportOptionsKit &`SetTarget`(HPS::Model const &in_target)

      Sets a Model to be used as part of the import. Geometry will be imported in the model Segment, and definitions will be added to the Portfolio associated with the Model provided. Setting a target is required for the import to succeed.

      Parameters: | in_model – Model to use.
      Returns: | A reference to this ImportOptionsKit.

    ImportOptionsKit &`SetView`(HPS::View const &in_view)

      Sets a View to be used as part of the import. Setting a View is required for the import to succeed.

      Parameters: | in_view – View to use for camera tracking.
      Returns: | A reference to this ImportOptionsKit.

    void `Show`(ImportOptionsKit &out_kit) const

      Copies this ImportOptionsKit into the given ImportOptionsKit.

      Parameters: | out_kit – The ImportOptionsKit to populate with the contents of this ImportOptionsKit.

    bool `ShowJavascriptPath`(HPS::UTF8 &out_javascript_path) const

      Shows the path that will be used to find hc_access.js during import.

      Parameters: | out_javascript_path – The path used to reach hc_access.js.
      Returns: | Returns false if a javascript path setting was not specified, false otherwise.

    bool `ShowTarget`(HPS::Model &out_model) const

      Shows the target import setting.

      Parameters: | out_model – Model to use to implicitly set Segment, Library and Portfolio into which the data will be imported.
      Returns: | Returns false if a target setting was not specified, false otherwise.

    bool `ShowView`(HPS::View &out_view) const

      Shows the view import setting.

      Parameters: | out_view – View to use.
      Returns: | Returns false if a view setting was not specified, false otherwise.

    ImportOptionsKit &`UnsetEverything`()

      Removes all settings from this ImportOptionsKit.

      Returns: | A reference to this ImportOptionsKit.

    ImportOptionsKit &`UnsetJavascriptPath`()

      Removes javascript path import setting.

      Returns: | A reference to this ImportOptionsKit.

    ImportOptionsKit &`UnsetTarget`()

      Removes the target import setting.

      Returns: | A reference to this ImportOptionsKit.

    ImportOptionsKit &`UnsetView`()

      Removes the view import setting.

      Returns: | A reference to this ImportOptionsKit.

    virtual `~ImportOptionsKit`()

    Public Static Functions

    static ImportOptionsKit `GetDefault`()

      Creates an ImportOptionsKit which contains the default settings. The returned object will not necessarily have values set for every option, but it will have settings for those options where it is reasonable to have a default. These values will be used for import unless an option is overridden by the options passed to File::Import.

      Returns: | An ImportOptionsKit with the default settings.

    Public Static Attributes

    static const HPS::Type `staticType` = HPS::Type::HCAImportOptionsKit
  class `Model`

    The Model class provides interactions with a HCA Model

    Public Functions

    bool `Empty`()

      Checks the state of the Model.

      Returns: | true if this Model is uninitialized, false otherwise.

    bool `Equals`(Model const &other) const

      Check if the source Model is equivalent to this Model.

      Parameters: | other – The source Model to compare to this Model.
      Returns: | true if the objects are equivalent, false otherwise.

    void `Hide`(HPS::Canvas const &in_canvas, int64_t in_node_id)

      Hides the specified node under the given Canvas. This makes the selected node invisible. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_canvas – The Canvas in which to hide the node. in_node_id – The ID of the node to be hidden

    void `Highlight`(HPS::Canvas const &in_canvas, HighlightOptionsKit const &in_highlight_options, HPS::Int64Array const &in_node_ids)

      Highlights the specified nodes under the given Canvas, using the options provided. All specified nodes will be highlighted using the same options. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_canvas – The Canvas in which to highlight the nodes. in_highlight_options – The options to be used when highlighting in_node_ids. in_node_ids – an array of node IDs to be highlighted

    void `Highlight`(HPS::Canvas const &in_canvas, HighlightOptionsKit const &in_highlight_options, int64_t in_node_id)

      Highlights the specified node under the given Canvas, using the options provided. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_canvas – The Canvas in which to highlight the node. in_highlight_options – The options to be used when highlighting in_node_id. in_node_id – The ID of the node to be highlighted

    bool `IsHidden`(int64_t in_node_id)

      Checks whether the given node is currently Hidden as a result of a Hide or Isolate operation. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_node_id – The ID of the node to examine.
      Returns: | true if the node is hidden, false otherwise.

    bool `IsHighlighted`(int64_t in_node_id)

      Checks whether the given node is currently highlighted. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_node_id – The ID of the node to examine.
      Returns: | true if the node is highlighted, false otherwise.

    void `Isolate`(HPS::Canvas const &in_canvas, int64_t in_node_id)

      Shows only the specified node and hides the rest. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_canvas – The Canvas in which to isolate the node. in_node_id – The ID of the node to isolate.

    `Model`()

      Constructs an uninitialized HCA::Model.

    `Model`(HPS::Model const &in_model)

      Constructs a HCA::Model under an existing HPS::Model.

      Parameters: | in_model – the HPS::Model under which to create an HCA::Model.

    `Model`(Model &&that)

      The move constructor creates an HCA::Model by transferring the underlying object of the rvalue reference to this HCA::Model.

      Parameters: | in_that – An rvalue reference to an HCA::Model to take the underlying object from.

    `Model`(Model const &that)

      Copy constructor. This constructor creates an HCA::Model which shares the same resources of the source HCA::Model.

      Parameters: | in_that – The source HCA::Model to copy.

    void `OnHighlightUnhighlight`()

      This convenience function performs the HCA::ModelTreeItem::OnHighlightUnhighlight function on the root item of the Model Tree See the description of HCA::ModelTreeItem::OnHighlightUnhighlight for more information.

    bool `operator!=`(Model const &other) const

      Check if the source Model is not equivalent to this Model.

      Parameters: | other – The source Model to compare to this Model.
      Returns: | true if the objects are not equivalent, false otherwise.

    Model &`operator=`(Model &&other)

      Copies the source Model into this Model.

      Parameters: | other – The source Model to copy.
      Returns: | A reference to this Model.

    bool `operator==`(Model const &other) const

      Check if the source Model is equivalent to this Model.

      Parameters: | other – The source Model to compare to this Model.
      Returns: | true if the objects are equivalent, false otherwise.

    bool `RequestNodeProperties`(int64_t in_node_id, uint32_t &out_request_id)

      Requests properties for the specified node. throws HPS::InvalidObjectException is the Model is uninitialized. When the request has been fulfilled, an event of type HCA::RequestIdEvent will be injected to the Database’s Event Dispatcher. Registering a handler to HCA::RequestIdEvent will allow the user to know when this request has completed. The value of HCA::RequestIdEvent::request_id object will match out_requested_id, returned by this function.

      Parameters: | in_node_id – the ID for the node whose properties should be collected. out_request_id – an ID which uniquely identifies this request
      Returns: | true if the node’s properties were gathered successfully, false otherwise.

    bool `RetrieveNodeProperties`(uint32_t in_request_id, uint32_t in_timeout_ms, int64_t &out_node_id, bool &out_valid, HPS::UTF8Array &out_keys, HPS::UTF8Array &out_values)

      Retrieves previously requested properties throws HPS::InvalidObjectException is the Model is uninitialized. Before retrieving properties, you should request them, using RequestNodeProperties. This function waits for the requested property to become available If your model’s properties are not changing, it is sufficient to call RequestNodeProperties just once for each node ID of interest. Each property is returned as a pair or key and value. The out_keys and out_values parameters are two parallel arrays containing respectively the key and value of each property.

      Parameters: | in_request_id – a unique ID representing a request for properties. This value is obtained through a call to RequestNodeProperties. in_timeout_ms – the maximum amount of time to wait while trying to retrieve the node properties, specified in milliseconds. Passing 0 means that the function will wait indefinitely until it can retrieve the properties. out_node_id – the ID of the node for which properties are being returned. out_valid – whether the returned properties are valid. out_keys – the property keys. Each entry in this array corresponds to the entry at the same index in the out_values array. out_values – the property values. Each entry in this array corresponds to the entry at the same index in the out_keys array.
      Returns: | true if the node’s properties were retrieved successfully, false otherwise.

    void `Show`(HPS::Canvas const &in_canvas, int64_t in_node_id)

      Shows the specified node under the given Canvas. This makes the selected node visible. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_canvas – The Canvas in which to show the node. in_node_id – The ID of the node to be shown

    void `ShowAll`(HPS::Canvas const &in_canvas)

      Shows all nodes in the model, under the specified Canvas. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_canvas – The Canvas in which to show the nodes.

    bool `ShowNodeChildren`(int64_t in_node_id, HPS::Int64Array &out_ids)

      Shows the IDs of the children of the requested node. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_node_id – the ID for the node whose children should be shown out_ids – an array of IDs representing the children of in_node_id.
      Returns: | true if the node’s children were found successfully, false otherwise.

    bool `ShowNodeFromKeyPath`(HPS::KeyPath const &in_key_path, int64_t &out_node_id)

      Given a KeyPath, the associated node ID is returned.

      Parameters: | in_key_path – the key path for which a node ID is being requested out_node_id – the node ID that corresponds to in_key_path
      Returns: | true if the node ID is associated to in_key_path, false otherwise.

    bool `ShowNodeName`(int64_t in_node_id, HPS::UTF8 &out_name)

      Shows the name for the requested node. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_node_id – the ID for the node whose name should be shown out_name – the name of in_node_id, in the UTF8 locale. Might be an empty UTF8 object.
      Returns: | true if the node name was found successfully, false otherwise.

    bool `ShowNodeParent`(int64_t in_node_id, int64_t &out_parent_id)

      Shows the ID of the parent of the requested node. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_node_id – the ID for the node whose parent should be shown out_parent_id – the ID representing the parent of in_node_id. Might be an empty array
      Returns: | true if the node’s parent was found successfully, false otherwise.

    bool `ShowRootNode`(int64_t &out_node_id)

      Shows the node ID for the root node of the Model. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | out_node_id – the node ID for the root node of the Model.
      Returns: | true if the root node ID was found, false otherwise.

    void `Unhighlight`(HPS::Canvas const &in_canvas, int64_t in_node_id)

      Unhighlights the specified node under the given Canvas. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_canvas – The Canvas in which to unhighlight the node. in_node_id – The ID of the node to be unhighlighted

    void `UnhighlightAll`(HPS::Canvas const &in_canvas)

      Unhighlights all nodes in the model, under the specified Canvas. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_canvas – The Canvas in which to unhighlight the nodes.

    void `Zoom`(HPS::Canvas const &in_canvas, int64_t in_node_id)

      Smoothly zooms the camera to focus on the specified node. The transition lasts half a second. throws HPS::InvalidObjectException is the Model is uninitialized.

      Parameters: | in_canvas – The Canvas in which to zoom to the node. in_node_id – The ID of the node to zoom to.

    `~Model`()
  class `ModelTree` : public HPS::Sprocket

    The ModelTree 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 model browser.

    Public Types

    enum class `ItemType`

      Enumerates the types of items that can be contained in a ModelTree.

      Values:

      enumerator `None`

        No type.

      enumerator `Model`

        Item is an HCA::Model.

      enumerator `Node`

        Item is an HCA::Node.

    Public Functions

    virtual void `Assign`(ModelTree const &in_that)

      Share the underlying smart-pointer of the ModelTree source.

      Parameters: | in_that – The ModelTree source of the assignment.
      Returns: | A reference to this ModelTree.

    bool `Equals`(ModelTree const &in_that) const

      Check if the source ModelTree points to the same underlying impl as this ModelTree.

      Parameters: | in_that – The source ModelTree to compare to this ModelTree.
      Returns: | true if the objects reference the same underlying data, false otherwise.

    virtual void `Flush`()

      Resets the root ModelTreeItem for this ModelTree. This will release the root ModelTreeItem by this ModelTree and set the root to a null pointer. If this function is overridden, the overriding function should invoke this base function.

    HPS::Canvas &`GetCanvas`() const

      Gets the Canvas associated with this ModelTree.

      Returns: | The Canvas associated with this ModelTree.

    HCA::Model &`GetHCAModel`() const

      Gets the HCA Model associated with this ModelTree.

      Returns: | The HCA Model associated with this ModelTree.

    ModelTreeItemPtr `GetRoot`() const

      Gets the root ModelTreeItem for this ModelTree.

      Returns: | The root ModelTreeItem for this ModelTree.

    `ModelTree`()

      The default constructor creates an uninitialized ModelTree object. The Type() function will return Type::None.

    `ModelTree`(Canvas const &in_canvas, HCA::Model &hca_model)

      This constructor creates a ModelTree object associated with a Canvas and the specified HCA::Model. This constructor should be used to create a new ModelTree object.

      Parameters: | in_canvas – The Canvas to associate this ModelTree with. hca_model – The model to associate this ModelTree with.

    `ModelTree`(ModelTree &&in_that)

      The move constructor creates a ModelTree by transferring the underlying object of the rvalue reference to this ModelTree.

      Parameters: | in_that – An rvalue reference to a ModelTree to take the underlying object from.

    `ModelTree`(ModelTree const &in_that)

      The copy constructor creates a ModelTree object that shares the underlying smart-pointer of the source ModelTree.

      Parameters: | in_that – The source ModelTree to copy.

    inline virtual HPS::Type `ObjectType`() const

      This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

      Returns: | The declared type of the object in question, which may differ from the true, underlying type.

    bool `operator!=`(ModelTree const &in_that) const

      Check if the source ModelTree points to a different impl than this ModelTree.

      Parameters: | in_that – The source ModelTree to compare to this ModelTree.
      Returns: | true if the objects reference different underlying data, false otherwise.

    ModelTree &`operator=`(ModelTree &&in_that)

      The move assignment operator transfers the underlying object of the rvalue reference to this ModelTree.

      Parameters: | in_that – An rvalue reference to a ModelTree to take the underlying object from.
      Returns: | A reference to this ModelTree.

    ModelTree &`operator=`(ModelTree const &in_that)

      Share the underlying smart-pointer of the ModelTree source.

      Parameters: | in_that – The ModelTree source of the assignment.
      Returns: | A reference to this ModelTree.

    bool `operator==`(ModelTree const &in_that) const

      Check if the source ModelTree points to the same underlying impl as this ModelTree.

      Parameters: | in_that – The source ModelTree to compare to this ModelTree.
      Returns: | true if the objects reference the same underlying data, false otherwise.

    void `SetRoot`(ModelTreeItemPtr const &in_root)

      Sets the root ModelTreeItem for this ModelTree. This object should be created on the heap and it should have been created with a ModelTreeItem constructor which took an HCA::Model, otherwise an exception will be thrown. Additionally, if there was already an existing root for this ModelTree, the Flush function will be invoked prior to setting this as the new root, and ModelTreeItem::Expand will be invoked on the new root.

      See also

      Flush

      See also

      ModelTreeItem::Expand

      Parameters: | in_root – The root ModelTreeItem for this ModelTree.

    virtual `~ModelTree`()

    Public Static Attributes

    static const HPS::Type `staticType` = HPS::Type::HCAModelTree
  class `ModelTreeItem` : public HPS::Sprocket

    The ModelTreeItem 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 model browser.

    Public Functions

    virtual ModelTreeItemPtr `AddChild`(int64_t in_node_id) = 0

      This function is used to create a new ModelTreeItem to be the child of this ModelTreeItem. You will need to implement this function in your class which derives from HCA::ModelTreeItem. This function will be invoked if this ComponentTreeItem has children and Expand has been invoked on it. This function should contain any necessary calls to GUI toolkits to create the appropriate GUI elements. Additionally, since this function requires the creation of a derived ModelTreeItem, that derived ModelTreeItem should use the base constructor which is appropriate for creating non-root items.

      Parameters: | in_node_id – The node ID to be associated with the ModelTreeItem being added to the ModelTree.

    virtual void `Assign`(ModelTreeItem const &in_that)

      Share the underlying smart-pointer of the ModelTreeItem source.

      Parameters: | in_that – The ModelTreeItem source of the assignment.
      Returns: | A reference to this ModelTreeItem.

    virtual void `Collapse`()

      This function should be invoked when this ModelTreeItem needs to collapse. If this function is overridden, the overriding function should invoke this base function. Additionally, this function will always release all children for this ModelTreeItem when invoked.

    bool `Equals`(ModelTreeItem const &in_that) const

      Check if the source ModelTreeItem points to the same underlying impl as this ModelTreeItem.

      Parameters: | in_that – The source ModelTreeItem to compare to this ModelTreeItem.
      Returns: | true if the objects reference the same underlying data, false otherwise.

    virtual void `Expand`()

      This function should be invoked when this ModelTreeItem needs to expand. If this function is overridden, the overriding function should invoke this base function. Additionally, this function will always repopulate the children for this ModelTreeItem when invoked.

    ModelTree::ItemType `GetItemType`() const

      Gets the item type for this ModelTreeItem. This is used to determine what type of data this ModelTreeItem represents in the ModelTree.

      Returns: | The item type for this ModelTreeItem.

    uint64_t `GetNodeId`() const

      Returns the HCA node ID associated with this ModelTreeItem

      Returns: | The HCA node ID associated with this ModelTreeItem .

    UTF8 `GetTitle`() const

      Gets the title for this ModelTreeItem. This is the text that should be displayed for this ModelTreeItem in the ModelTree.

      Returns: | The title for this ModelTreeItem.

    ModelTreePtr `GetTree`() const

      Gets the ModelTree associated with this ModelTreeItem. This provides a means of accessing the derived ModelTree by this ModelTreeItem if necessary.

      Returns: | The ModelTree associated with this ModelTreeItem.

    bool `HasChildren`() const

      Indicates whether this ModelTreeItem has any children.

      Returns: | true if this ModelTreeItem has children, false otherwise.

    void `Hide`()

      Hides this ModelTreeItem it isn’t already. Geometry associated with a hidden ModelTreeItem becomes invisible. Calling this function will result in a call to OnShowHide after the hide operation has taken place.

    void `Highlight`(HighlightOptionsKit const &in_highlight_options)

      Highlights this ModelTreeItem using the options specified. Calling this function will result in a call to OnHighlightUnhighlight after the highlight operation has taken place.

    bool `IsExpanded`() const

      Indicates whether this ModelTreeItem is currently expanded.

      Returns: | true if this ModelTreeItem is expanded, false otherwise.

    bool `IsHidden`() const

      Indicates whether this ModelTreeItem is currently hidden.

      Returns: | true if this ModelTreeItem is hidden, false otherwise.

    bool `IsHighlighted`() const

      Indicates whether this ModelTreeItem is currently highlighted.

      Returns: | true if this ModelTreeItem is highlighted, false otherwise.

    void `Isolate`()

      Shows this ModelTreeItem and hides every other nodes in the tree, causing this item to become the only one visible. The camera will zoom to the isolated item. Calling this function will result in a call to OnShowHide for the item which is isolated, after the isolate operation has taken place.

    `ModelTreeItem`()

      The default constructor creates an uninitialized ModelTreeItem object. The Type() function will return Type::None.

    `ModelTreeItem`(ModelTreeItem &&in_that)

      The move constructor creates a ModelTreeItem by transferring the underlying object of the rvalue reference to this ModelTreeItem.

      Parameters: | in_that – An rvalue reference to a ModelTreeItem to take the underlying object from.

    `ModelTreeItem`(ModelTreeItem const &in_that)

      The copy constructor creates a ModelTreeItem object that shares the underlying smart-pointer of the source ModelTreeItem.

      Parameters: | in_that – The source ModelTreeItem to copy.

    `ModelTreeItem`(ModelTreePtr const &in_tree, HCA::Model const &in_hca_model)

      This constructor creates a ModelTreeItem suitable for acting as a root in a ModelTree.

      Parameters: | in_tree – A pointer to the ModelTree which will contain this ModelTreeItem in_hca_model – The HCA::Model which will be assigned to this ModelTreeItem.

    `ModelTreeItem`(ModelTreePtr const &in_tree, int64_t in_node_id)

      This constructor creates a ModelTreeItem which is not suitable for acting as a root in a ModelTree, but is suitable to be a ModelTreeItem under the root of the ModelTree. This constructor should be the one invoked in the overridden AddChild function.

      Parameters: | in_tree – A pointer to the ModelTree which will contain this ModelTreeItem. in_node_id – The node ID to be associated with this ModelTreeItem.

    inline virtual HPS::Type `ObjectType`() const

      This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

      Returns: | The declared type of the object in question, which may differ from the true, underlying type.

    virtual void `OnHighlightUnhighlight`()

      This function will be invoked when this item becomes highlighted or unhighlighted. If you want something to happen when an item’s highlight state changes you should provide an implementation for this function in your class which derives from HCA::ModelTreeItem. A common usage for this function is to make the text associated with highlighted items bold to indicate to users whether the item is highlighted or not at a glance.

    inline virtual void `OnShowHide`()

      This function will be invoked when this item becomes shown or hidden. If you want something to happen when an item becomes shown or hidden you should provide an implementation for this function in your class which derives from HCA::ModelTreeItem. A common usage for this function is to change the icon associated with the node to indicate to users whether the item is shown or hidden at a glance.

    bool `operator!=`(ModelTreeItem const &in_that) const

      Check if the source ModelTreeItem points to a different impl than this ModelTreeItem.

      Parameters: | in_that – The source ModelTreeItem to compare to this ModelTreeItem.
      Returns: | true if the objects reference different underlying data, false otherwise.

    ModelTreeItem &`operator=`(ModelTreeItem &&in_that)

      The move assignment operator transfers the underlying object of the rvalue reference to this ModelTreeItem.

      Parameters: | in_that – An rvalue reference to a ModelTreeItem to take the underlying object from.
      Returns: | A reference to this ModelTreeItem.

    ModelTreeItem &`operator=`(ModelTreeItem const &in_that)

      Share the underlying smart-pointer of the ModelTreeItem source.

      Parameters: | in_that – The ModelTreeItem source of the assignment.
      Returns: | A reference to this ModelTreeItem.

    bool `operator==`(ModelTreeItem const &in_that) const

      Check if the source ModelTreeItem points to the same underlying impl as this ModelTreeItem.

      Parameters: | in_that – The source ModelTreeItem to compare to this ModelTreeItem.
      Returns: | true if the objects reference the same underlying data, false otherwise.

    bool `RequestProperties`(uint32_t &out_request_id)
    void `Show`()

      Shows this ModelTreeItem it isn’t already visible. Geometry associated with a shown ModelTreeItem becomes visible. Calling this function will result in a call to OnShowHide after the show operation has taken place.

    void `Unhighlight`()

      Removes all highlights from this ModelTreeItem. Calling this function will result in a call to OnHighlightUnhighlight after the unhighlight operation has taken place.

    void `Zoom`()

      Smoothly zooms the camera to focus on this item. The transition lasts half a second.

    virtual `~ModelTreeItem`()

    Public Static Attributes

    static const HPS::Type `staticType` = HPS::Type::HCAModelTreeItem
  class `NetworkImportOptionsKit` : public HPS::Sprocket

    The HPS::HCA::NetworkImportOptionsKit class is a user space object. It contains settings controlling what and how Stream Cache data is imported over a network via the HCA Sprocket.

    Public Functions

    virtual bool `Empty`() const

      Indicates whether this NetworkImportOptionsKit has any values set on it.

      Returns: | true if no values are set on this NetworkImportOptionsKit, false otherwise.

    bool `Equals`(NetworkImportOptionsKit const &in_kit) const

      Check if the source NetworkImportOptionsKit is equivalent to this NetworkImportOptionsKit.

      Parameters: | in_kit – The source NetworkImportOptionsKit to compare to this NetworkImportOptionsKit.
      Returns: | true if the objects are equivalent, false otherwise.

    `NetworkImportOptionsKit`()

      The default constructor creates an empty NetworkImportOptionsKit object.

    `NetworkImportOptionsKit`(NetworkImportOptionsKit &&in_that)

      The move constructor creates an NetworkImportOptionsKit by transferring the underlying impl of the rvalue reference to this NetworkImportOptionsKit thereby avoiding a copy and allocation.

      Parameters: | in_that – An rvalue reference to an NetworkImportOptionsKit to take the impl from.

    `NetworkImportOptionsKit`(NetworkImportOptionsKit const &in_kit)

      The copy constructor creates a new NetworkImportOptionsKit object that contains the same settings as the source NetworkImportOptionsKit.

      Parameters: | in_kit – The source NetworkImportOptionsKit to copy.

    inline virtual HPS::Type `ObjectType`() const

      This function returns the type the object, as declared (if the object is derived, this does not give the true type of the derived object).

      Returns: | The declared type of the object in question, which may differ from the true, underlying type.

    bool `operator!=`(NetworkImportOptionsKit const &in_kit) const

      Check if the source NetworkImportOptionsKit is not equivalent to this NetworkImportOptionsKit.

      Parameters: | in_kit – The source NetworkImportOptionsKit to compare to this NetworkImportOptionsKit.
      Returns: | true if the objects are not equivalent, false otherwise.

    NetworkImportOptionsKit &`operator=`(NetworkImportOptionsKit &&in_that)

      The move assignment operator transfers the underlying impl of the rvalue reference to this NetworkImportOptionsKit thereby avoiding a copy.

      Parameters: | in_that – An rvalue reference to an NetworkImportOptionsKit to take the impl from.
      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`operator=`(NetworkImportOptionsKit const &in_kit)

      Copies the source NetworkImportOptionsKit into this NetworkImportOptionsKit.

      Parameters: | in_kit – The source NetworkImportOptionsKit to copy.
      Returns: | A reference to this NetworkImportOptionsKit.

    bool `operator==`(NetworkImportOptionsKit const &in_kit) const

      Check if the source NetworkImportOptionsKit is equivalent to this NetworkImportOptionsKit.

      Parameters: | in_kit – The source NetworkImportOptionsKit to compare to this NetworkImportOptionsKit.
      Returns: | true if the objects are equivalent, false otherwise.

    void `Set`(NetworkImportOptionsKit const &in_kit)

      Copies the source NetworkImportOptionsKit into this NetworkImportOptionsKit.

      Parameters: | in_kit – The source NetworkImportOptionsKit to copy.

    NetworkImportOptionsKit &`SetEjectedGeometryBoundingPreviews`(bool ejected_geometry_bounding_previews)

      Whether to display a bounding mesh to replace geometry that was ejected because of the memory limit being hit. Additionally this option will only be honored if a memory limit is set.

      Parameters: | ejected_geometry_bounding_previews – Whether ejected geometry should be replaced with boundings.
      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`SetJavascriptPath`(HPS::UTF8 const &javascript_path)

      Sets the path to hc_access.js which will be used during the import. Setting a Javascript Path is required for the import to succeed. The hc_access.js file is provided with HOOPS Visualize.

      Parameters: | javascript_path – Path of the javascript file to use.
      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`SetLimitMiB`(uint32_t limit_MiB)

      Sets the memory amount to devote to geometry data, specified in Megabytes. Passing a value of zero to this function is equivalent to calling UnsetLimitMib() Reaching the memory limit will cause some geometry to be ejected from the scene so that more can stream in.

      Parameters: | limit_MiB – Memory in Megabytes to use for geometry data.
      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`SetModelBoundingPreviews`(bool model_bounding_previews)

      Whether to load and display previews of the model bounding when streaming starts. As actual geometry starts streaming in, it will replace its bounding.

      Parameters: | model_bounding_previews – Whether model boundings will be streamed.
      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`SetNetworkPath`(HPS::UTF8 const &network_path)

      Sets the URL that will be used to connect to the Communicator server. The Network Path is required when importing a file over the network.

      Parameters: | network_path – URL to use.
      Returns: | A reference to this ImportOptionsKit.

    NetworkImportOptionsKit &`SetTarget`(HPS::Model const &in_target)

      Sets a Model to be used as part of the import. Geometry will be imported in the model Segment, and definitions will be added to the Portfolio associated with the Model provided. Setting a target is required for the import to succeed.

      Parameters: | in_model – Model to use.
      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`SetView`(HPS::View const &in_view)

      Sets a View to be used as part of the import. Setting a View is required for the import to succeed.

      Parameters: | in_view – View to use for camera tracking.
      Returns: | A reference to this NetworkImportOptionsKit.

    void `Show`(NetworkImportOptionsKit &out_kit) const

      Copies this NetworkImportOptionsKit into the given NetworkImportOptionsKit.

      Parameters: | out_kit – The NetworkImportOptionsKit to populate with the contents of this NetworkImportOptionsKit.

    bool `ShowEjectedGeometryBoundingPreviews`(bool &out_ejected_geometry_bounding_previews) const

      Shows the ejected bounding previews import setting.

      Parameters: | out_ejected_geometry_bounding_previews – Whether ejected geometry should be replaced with a visualization of its boundings.
      Returns: | Returns false if an ejected bounding preview setting was not specified false otherwise.

    bool `ShowJavascriptPath`(HPS::UTF8 &out_javascript_path) const

      Shows the path that will be used to find hc_access.js during import.

      Parameters: | out_javascript_path – The path used to reach hc_access.js.
      Returns: | Returns false if a javascript path setting was not specified, false otherwise.

    bool `ShowLimitMiB`(uint32_t &out_limit_MiB) const

      Shows the memory limit import setting.

      Parameters: | out_limit_MiB – The amount of memory, specified in Megabytes, to use for geometry data.
      Returns: | Returns false if a memory limit setting was not specified, false otherwise.

    bool `ShowModelBoundingPreviews`(bool &out_model_bounding_previews) const

      Shows the model bounding preview import setting.

      Parameters: | out_model_bounding_previews – Whether boundings should be visualized while waiting for geometry to stream in.
      Returns: | Returns false if a model bounding preview setting was not specified, false otherwise.

    bool `ShowNetworkPath`(HPS::UTF8 &out_network_path) const

      Shows the network path import setting.

      Parameters: | out_network_path – The network path to use during the import.
      Returns: | Returns false if a network path setting was not specified, false otherwise.

    bool `ShowTarget`(HPS::Model &out_model) const

      Shows the target import setting.

      Parameters: | out_model – Model to use to implicitly set Segment, Library and Portfolio into which the data will be imported.
      Returns: | Returns false if a target setting was not specified, false otherwise.

    bool `ShowView`(HPS::View &out_view) const

      Shows the view import setting.

      Parameters: | out_view – View to use.
      Returns: | Returns false if a view setting was not specified, false otherwise.

    NetworkImportOptionsKit &`UnsetEjectedGeometryBoundingPreviews`()

      Removes ejected bounding previews setting import setting.

      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`UnsetEverything`()

      Removes all settings from this NetworkImportOptionsKit.

      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`UnsetJavascriptPath`()

      Removes javascript path import setting.

      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`UnsetLimitMiB`()

      Removes the geometry data memory limit import setting.

      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`UnsetModelBoundingPreviews`()

      Removes model bounding previews setting import setting.

      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`UnsetNetworkPath`()

      Removes network path import setting.

      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`UnsetTarget`()

      Removes the target import setting.

      Returns: | A reference to this NetworkImportOptionsKit.

    NetworkImportOptionsKit &`UnsetView`()

      Removes the view import setting.

      Returns: | A reference to this NetworkImportOptionsKit.

    virtual `~NetworkImportOptionsKit`()

    Public Static Functions

    static NetworkImportOptionsKit `GetDefault`()

      Creates an NetworkImportOptionsKit which contains the default settings. The returned object will not necessarily have values set for every option, but it will have settings for those options where it is reasonable to have a default. These values will be used for import unless an option is overridden by the options passed to File::Import.

      Returns: | An NetworkImportOptionsKit with the default settings.

    Public Static Attributes

    static const HPS::Type `staticType` = HPS::Type::HCANetworkImportOptionsKit
  class `RequestIdEvent` : public HPS::Event

    The RequestIdEvent class is the event that will be triggered for each HCA Model Request call.

    Public Functions

    inline virtual Event *`Clone`() const override

      Allocates and returns a copy of this RequestIdEvent.

      Returns: | A copy of this RequestIdEvent.

    inline `RequestIdEvent`()

      The default constructor creates an empty RequestIdEvent object.

    inline `RequestIdEvent`(Event const &in_event)

      This constructor converts an Event Object to a RequestIdEvent object.

      Parameters: | in_event – The Event Object to be converted.

    inline `RequestIdEvent`(uint32_t in_request_id)
    virtual `~RequestIdEvent`()

    Public Members

    uint32_t `request_id`

Conversation saved
HOOPSY BETA

### Hello! I'm HOOPSY

Your multilingual generative AI assistant for documentation. Ask me anything about HOOPS Visualize Desktop in your own language, or choose a sample question below to start a conversation:

What is HOOPS Visualize Desktop?
What are the latest release notes for HOOPS Visualize Desktop?
How do I start evaluating HOOPS Visualize Desktop?
How do I write my first sample application?
How can I get assistance?

HOOPSY may store conversations according to OpenAI's policy. Responses may not always be accurate.

HOOPSY is thinking...