| ►NNDEVR | |
| CAboutDialog | Shows information about the current software version |
| CACIColor | ACI colors are the standard colors used in AutoCAD-based products. Each color is identified by an ACI number, an integer from 1 through 255 |
| CAerialImageRequest | Contains the information for requesting a 2D top-down view of a geographic location to be used with a AerialImage service such as google earth |
| CAerialImageSettings | Dialog for showing an AerialImage or top down view rendered with a service like google earth with user controls for adjusting view |
| CAerialImageView | A simple widget for showing an AerialImage or top down view rendered with a service like google earth A loading screen appears as images are loaded in |
| CAlignGyroButton | A button that allows the user to align, or define the orientation, for a OrientationSensor |
| CAngle | The primary angle storage class for this API. Stores an angle in an optimized format |
| CAngleDefinitions | Logic for converting between Euler angles and basic rotations or normals |
| CAngleUnit | Contains logic for converting angles into user defined units including up-direction and clockwise-logic |
| CAngularDimensionData | Logic for storing an angular dimension in a CAD-friendly way for exporting and importing |
| CApplicationLauncherButtonManager | Creates a button for launching a 3rd party application. While the application is running the button is pressed. When application terminates button is unpressed automatically |
| CApplicationOption | The default object to store data of any type that should persist through sessions of the application |
| CApplicationOptionBase | The core of the default object to store data of any type that should persist through sessions of the application. Developers should use ApplicationOption |
| CApplicationOptions | The container for storing N-number of ApplicationOption for the program. Almost all options are typically "user options" and are added to that container by default |
| CApplicationResource | High-Level functions for communicating with the operating system or getting general information about the application |
| CApplicationSetup | Initializes the engine for most applications. Applications using the default workspace should call this function to layout and initialize the application. Calls all relevant module functions in the correct order |
| CArcData | Logic for storing a arc data in a CAD-friendly way for exporting and importing |
| CArcShape | Model class for storing, rendering, and logically modifying a 3D conic arc |
| CArialColorTheme | Allows the user to specify a color theme for a Aerial image request. For example Google allows various colors for roads, buildings, etc |
| CAsciiFactory | Writes points of data to a plain-text file based on FactoryOptions. AsciiFactories allow for defining multiple columns of data to be streamed out to the text file |
| CAsciiFileOutputStream | A LogStream that attached to a log, writes messages directly to a specified ascii file |
| CAsciiModelFileDialog | Default dialog shown when the user exports an ascii-or custom column style file |
| CAsciiOptions | Storage class for all IO options related to an Ascii file output used by an IOFactory services that write to Ascii |
| CAssimpFactory | IOFactory for writing to files using the ASSIMP 3rd party library. Assimp supports many file types. For more information see: https://assimp.org/ |
| CAssimpSceneMemory | Stores all of the objects needed for an aiScene in a way that is efficient and uses native containers |
| CAttrib | Logic for storing a attribue data in a CAD-friendly way for exporting and importing |
| CAutomatedTest | Base class for performing a test for easily testing certain software functionality |
| CAutomatedTestingDialog | Gives user information and allows execution for all registered automated testing |
| CAutoModelFileDialog | Dialog that allows user to choose import or export options while simultaniously automatically writing or reading the file in the background such that the user might already have the data when finished |
| CAutoZoomFocus | Logic for automatically zooming a Camera or Viewport to a certain location or having certain objects in focus of the frame |
| CAxisAngle | An angle about a particular, defined 3D axis |
| CBackgroundandLightingEditor | A dialog for allowing the user to specify a background or sun position of a particular camera or viewport |
| CBandMatrix | Band Matrix solver |
| CBase64Encoder | Functions for converting to and from Base64 https://en.wikipedia.org/wiki/Base64 |
| CBaseValues | Dummy class to ensure creation of an include file around core root values |
| CBasicCustomUnit | A program-defined unit that can be used for some specific task different from a program-wide unit |
| CBasicKeyController | The core class for assigning actions to key-presses and registering them as a program-wide service |
| CBasicModelIterator | A class for easily transversing a model heirarchy, applying an optional function at each level |
| CBasicResourceListener | Simple version of ResourceListener which allows for a simple function callback that will be executed when a Resource changes instead of a class override |
| CBasicThread | A class that allows user to use a function inline to execute something |
| CBasicUnitOption | A definition of how to describe a particular set of data to a custom category of unit |
| CBattery | A device which has an accociated voltage or percent that changes. Can have set upper and lower limits |
| CBatteryAlertWatcher | Listens for changes to a Battery and reports an error to the user when thresholds are crossed |
| CBatteryCapacityInfo | For a given BatteryCapacityType, the limits that define the state of the battery |
| CBatteryWidget | A button that displays information about multiple Batteries when clicked. Button changes color based on the status of specified Battery objects |
| CBinaryCompressionObject | A container for storing compressed data, typically used for File IO operations. Responsible for storing the data associated with the compression |
| CBinaryFile | Logic for reading or writing to a binary file including logic for |
| CBinaryHeap | A heap data structure that takes the form of a binary tree which is a common way of implementing priority queues |
| CBiRadialObject | An ellipse like shape (such as an oval or egg) with two points, where all points on the shape are equal distance between the two points (distanceTo(A) + distanceTo(B) = radius) |
| CBitFlag | A bitset that stores 8 bits (elements with only two possible values: 0 or 1, true or false, ...) |
| CBitIterator | Simple bit iterator, typically used for parsing Buffer of bools in loops |
| CBitReference | A convenience class used with Buffers or Vectors of bools for referencing or acting on a single bit |
| CBlockData | A block structure (Similar to a Model) used to share data with CAD |
| CBlockInsert | Information for how to place a CAD block within a scene (Similar to Model) |
| CBluetoothConnection | A ConnectionBackend that provides logic for interfacing with a QBluetooth connection |
| CBluetoothConnectionDialog | A ConnectionDialog that allows the user to modify a Bluetooth connection |
| CBluetoothConnectionDialogFactory | A ConnectionDialogFactory which enables the creation of a BluetoothConnectionDialog |
| CBluetoothConnectionFactory | A ConnectionFactory that enables the creation of a BluetoothConnection for interfacing with a QBluetoothSocket |
| CBluetoothManager | Logic for using the QBluetooth functions for finding and establishing connections with Bluetooth devices or services |
| CBooleanDescription | Describes custom options for a particular GeometryBoolean operation |
| CBounds | A specification of upper and lower bounds in N-dimensions |
| CBoundsWidget | Allows the user to enter in a minimum and maximum value in N dimensions (up to 3) |
| CBuffer | The equivelent of std::vector but with a bit more control. The basic array unit of the library |
| CBufferAllocator | Specific logic for reserving memory for a Buffer. When managed, and more memory is needed memory is reserved using the ([Current Capacity] * 3) / 2) + 1 |
| CBufferAllocator< bool, t_index_type, false > | Specific logic for allocating booleans in a Buffer. Will allocate 8 booleans per byte for quick storage and access |
| CBufferBase | A dummy class for easy tracking of inheritance with templated Buffers |
| CBufferedScanner | Implentation of Scanner, however all data is cached. Faster, but consumes |
| CBufferFunctions | A dummy class to include complex Buffer insert and sort functions Functions that enhance the functionality of the Buffer class |
| CBufferInsertIterator | Used by stl library to insert objects into the buffer |
| CBulgeConverter | Converts CAD Bulge objects into arc shapes that can be used by the NDEVR API |
| CButton | A core widget that allows the user to click one of many button types |
| CButtonDialog | Typically used for dialogs which have any number of buttons associated with it that are toggled on when the dialog is visible, and off when the widget is invisible. Each button controls the visibility of the dialog |
| CButtonGallery | Typically used for dialogs which have any number of buttons associated with it that are toggled on when the dialog is visible, and off when the widget is invisible. Each button controls the visibility of the dialog |
| CCachedFactoryIOThread | A thread designed to read and write files using the FactoryIO interface. Thread will perform all actions on a temp file, then move the file when accept() is called |
| CCADApplicationManager | Converts all loaded data into a binary DXF which is then shared, in real time, with a CAD engine such as AutoCAD or IntelliCAD |
| CCADColorInfo | Stores color information for interfacing with CAD |
| CCADDictionaryObject | A container for information pointing to a CAD dictionary in CAD memory |
| CCADEntityStreamer | A base-class for streaming out CAD entities from a file or CAD program memory |
| CCADGeometryWriter | Streams NDEVR Geometry entities as CAD objects |
| CCADHandleManager | Handles converting NDEVR API UUID objects into CAD HANDLE IDs |
| CCADHelperFunctions | Useful functions for interfacing with the standard CAD environment |
| CCADImageData | Logic for storing a image data in a CAD-friendly way for exporting and importing |
| ►CCADMeshData | Stores mesh data in a way optimized for CAD |
| CMeshOverride | |
| CCADVariable | A variable shared between NDEVR and CAD |
| CCADWriteModifier | An interface that can handle writing certain entities in a special way to the CAD environment |
| CCalibrationPosition | Represents a location used for calibrating an IMU. Described by the expected gravity vector for that location |
| CCalibratorWidget | A widget that allows the user to interact with an IMUCalibrator object and perform an IMU calibration |
| CCameraAnimation | A container for information relating to a Camera 3D animation such as zooming or rotating around a target |
| CCameraUniformObject | A structure containing common information pushed to the video card for NDEVR Rendering Engine operations |
| CCameraView | A simple frame for displaying Viewport data to a user. Data is rendered by a given Rendering engine based on the nature of the Camera stream |
| CCancelException | An Exception thrown when the user cancels an operation. This is not a true error but designed to be used in control paths that allow users to cancel activities |
| CCaptureCache | Stores information about a screenshot |
| CCheckForUpdatesDialog | A dialog designed to show whether or not the application needs to be updated or the state of the update |
| CCheckoutLock | Used by Viewports to signal they are rendering and we should not be performing an Update |
| CCheckSumGenerator | Logic for generating checksums based on initial value and a type |
| CCircleData | Logic for storing a circle data in a CAD-friendly way for exporting and importing |
| CCloth | The data and operations for performing bare earth using Cloth simulation |
| CCloudtoCloudDistance | A filter which removes objects that are too far away from a given cloud and a Cloth |
| CColor | The core Color class in the NDEVR API. Colors can be defined in several ways. The ACIColor is compact, and the LABColor can provide optimal visuals |
| CColorByValueWidget | Allows the user to select a property and range to color a Model or Scene |
| CColorChannelCombo | Allows the user to select a method to color a particular channel |
| CColorChooserButton | A button that pops up a ColorChooserDialog and changes background color based on the color chosen |
| CColorOptions | |
| CColorThemeButton | A button for adjusting the color theme used by the NDEVR engine (Typically light or dark color palettes) |
| CColumnDetails | Stores the data for AsciiModelFileDialog user specified columns |
| CCommandInformation | Stores long-term statistics for commands executed using HardwareCommandQueue |
| CCommandLockObject | Used with DesignObjectLookups to lock the application for a critical process. Will potentially display the title to the end user |
| CCompressedStringInfo | Contains information for referencing compressed strings |
| CCompressor | Class which is designed to compress objects for writing to file. Typically objects are added then the compressor is run compressing all data at once |
| CConcavePolygon | Stores convenience functions for a concavec polygon Works on a Polygon object to decompose it into triangles or sub-polygons |
| CConcurrentOperation | Contains thread-safe operations for inter-thread logic Increment and Decrement can be used to safely add to a shared uint04 value |
| CConfigType | Stores String variables reprenting the type of compile configuration that will be supported by a particular Module or resource (debug vs release) |
| CConnection | A standard interface for all types of connections that allow transmitting and recieving of data between two devices or services |
| CConnectionBackend | Provides the unseen backend logic for setting up, tearing down, and sending data over a specific type of connection |
| CConnectionCategory | A category represents the type of connection. For example Bluetooth, Serial Port, TCP, etc |
| CConnectionDialog | A virtual dialog that provides an interface that allows the user to adjust certain parameters for a Connection |
| CConnectionDialogFactory | Used to, given a Connection, generate an appropriate ConnectionDialog to allow adjustment of parameters |
| CConnectionFactory | Stores factories that can be registered for creating Connections of various types |
| CConnectionForwarding | Logic for taking all rx data from one Connection and sending it through another Connection and vice-versa |
| CConnectionForwardingDialog | A table that allows the user to specify any number of ConnectionForwarding objects |
| CConnectionInfo | A structure designed to store information about a specific Connection |
| CConnectionSearchParamaters | Describes settings for performing a Connection search |
| CConnectionSetupWidget | A dialog with many different ConnectionDialog objects that allow the user to specify a particular Connection |
| CConnectionStatusWidget | A dial and information text that shows the current status of a connection. Typically shown when a connection is being attempted to keep the user informed on the status of the connection attempt |
| CConnectionWidget | A small widget that can be shown that allows the user to attempt a connection, disconnect, or even define a connection |
| CConstant | Defines for a given type (such as sint04, fltp08, UUID, etc) a maximum, minimum, and reserved 'invalid' value |
| CConstBitIterator | Simple bit iterator, typically used for parsing Buffer of bools in loops |
| CConstPointer | Provides a constant, unmodifiable pointer that has shared ownership of a dynamically allocated object |
| CConstraint | Constains two particles for use in the CSF filter |
| CContainerWidget | Manages a series of SectionContent that can share the same space or lay out in various patterns including as floating windows used within NDEVR API Widget Docking system. While the NDEVR API Widget Docking system allows widgets to be floating, they must still subrscribe to a ContainerWidgetBase which acts as a parent window and, if necessary, causes the widget to rejoin the Container. When asked for being displayed full-screen, the widget will take over the complete space of the ContainerWidgetBase. A ContainerWidgetBase inherits from QCustomStackedWidgetBase which which is only used when a widget wants to go fullscreen. Othewise it is always on index 0 which contains the section content in the specified layout |
| CContainerWidgetBase | The root class that manages a series of SectionContent that can share the same space or lay out in various patterns including as floating windows used within NDEVR API Widget Docking system. While the NDEVR API Widget Docking system allows widgets to be floating, they must still subrscribe to a ContainerWidgetBase which acts as a parent window and, if necessary, causes the widget to rejoin the Container. When asked for being displayed full-screen, the widget will take over the complete space of the ContainerWidgetBase. A ContainerWidgetBase inherits from QCustomStackedWidgetBase which which is only used when a widget wants to go fullscreen. Othewise it is always on index 0 which contains the section content in the specified layout |
| CContextMenuCallback | Allows for customization of what is shown when the user right-clicks or accesses the ContextMenu for an object, selection, or scene |
| CContextMenuManager | Manages setting up the context menu that is shown when the user right-clicks or accesses the ContextMenu for an object, selection, or scene |
| ►CControllerInterface | Provides standard logic shared across all hardware controllers to be used with the software |
| CControlButton | |
| CControllerInput | |
| CControlStick | |
| CControlTrigger | |
| CHapticFeedback | |
| CControllerInterfaceManager | Stores services that allow the software to access physical hardware controllers that can be used with the system |
| CCoordinateBoundsSelector | A dedicated dialog for allowing the user to select bounds for a northing and easting. Allows registration of a dedicated dialog for selecting coordinates |
| CCoordinateConverter | Stores different projections and then converts data from one projection into another |
| CCoordinateConverterDialog | A dialog that allows the user to set a Coordinate projection for the current project |
| CCoordinateConverterFactory | Allows for the creation of Coordinate spaces |
| CCoordinateOptions | Stores ApplicationOptions related to coordinates |
| CCoordinateProjection | Basic data about a particular coordinate projection. See https://ndevr.org/coordinate-projection/ |
| CCoordinateProjectionChooser | Allows the user to select a coordinate projection from a list of ones available |
| CCoordinateProjectionManager | Stores Coordinate Projections See https://ndevr.org/coordinate-projection/ |
| CCoordinateSelector | Allows the user to select Coordinates using the CoordinateBoundsSelector selector |
| CCoordinateUnitOption | A definition of how to describe coordinate data |
| CCrashManager | Handles crashes and can be used to write crash reports, etc On Windows this class can be used to create mini-dumps |
| CCSFFilter | Filters using the CSF logic for determining bare-earth |
| CCSFParams | Contains parameters for performing a Cloth surfacing operation |
| CCustomDesignChart | A chart that allows for the plotting of 2 Geometry Data sources as a scatter plot |
| CCustomDesignChartDialog | A chart that allows the user to select data from a model to plot as a scatter plot |
| CCustomDockButton | A DockItem that represents a button. These can be placed on the Docking widget to add functionality. For example, in touch mode we use this class to have a "Add View" button |
| CCustomModelLogic | An easy interface for adding common SoftwareInterfaces relating to a Model to the program logic. Can be used to easily change program behavior for a particular Model |
| CCustomTreeWidgets | Allows for modification or addition of the widgets shown when an object is selected by the user in the TreeView. Default widgets |
| CCustomUnit | A program-defined unit that can be used for some specific task different from a program-wide unit |
| CCylinderShape | Model class for storing, rendering, and logically modifying a 3D cylinder |
| CDatabase | Provides access to a set of named database tables |
| CDataset | A dataset is a basic grouping of data (DEPRECIATED) |
| CDatasetManager | Used to group datasets (DEPRECIATED) |
| CDBFParser | Logic for reading or writing to a database file that uses the .dbf |
| CDDMMSSAngleUnit | Degrees, Minutes, Seconds stored in a compact way where degrees and minutes are seperated by a decimal and minutes and secons are always 2 decimals |
| CDebugStream | A LogStream that writes to the debug console The debug console can be used to see the output in, for example, Visual Studio or Android debug terminal |
| CDefaultMaterials | Provides default materials that can be used within the NDEVR API |
| CDefaultSelectionEffect | The default behavior for selection, which is to create a bounding box around an object |
| CDeferredImageIconEngine | Used to render any icons when they are needed. Resources will not be consumed until draw is called |
| CDeploymentInfo | |
| CDeploymentLengthCombobox | Provides a list of quick options for the desired Segment length for a Deployment |
| CDeploymentModeCombobox | Provides a list of options for the user to select how to perform a particular Deployment |
| CDeploymentOptions | Stores ApplicationOptions related to Deployments |
| CDeploymentUnit | A CustomUnit that is used to define the length of a Deployment |
| CDeploymentWidget | A widget used for allowing the user to quickly setup an OrientationSensor for a Deployment |
| CDepthBiasSlider | Can adjust the depth offset of a material using a QCustomSlider widget |
| CDesignCommand | A command for safely modifying something in a DesignObjectLookup. Modifications will be done in a seperate thread from the UI and will be recorded for undo-redo. Most user modifications of data should occur via a DesignCommand |
| CDesignCommandManager | Stores logic for performing, undoing, or redoing DesignCommands |
| CDesignObject | A low-level database object that can be used to access general stored properties within the NDEVR Model heirarchy or 3D environment |
| CDesignObjectBase | Provides the underlying data storage for the NDEVR Scene Model heirarchy |
| CDesignObjectChooser | Provides a screen of buttons that allow the user to pick a Model for an action |
| CDesignObjectComboWidget | Shows a filtered list of models in a combobox that the user can use to select a desired Model |
| CDesignObjectDialog | A popup dialog for showing options or information to the user for a particular DesignObject. A DesignObjectDialog stores multiple Editors which are used to edit or modify the target Model, Material or Geometry |
| CDesignObjectDialogFactory | Allows extended functionality to DesignObjectDialogs by adding callbacks that can be used primarily to add tabs to the dialog |
| CDesignObjectEditor | A basic Editor that shows generic information, such as name and description. If Library services are enabled allows for adding and removing from the library |
| CDesignObjectGallery | Shows a series of Buttons with large icons that represent DesignObjects that allow the user to choose one |
| CDesignObjectInterface | Base level class providing convenience functions for intefacing with one or more DesignObjects |
| CDesignObjectLookup | A core class where all Design Objects including models, materials, and geometries are stored. Contains the logic necessary to build or display any number of Scenes simultaniously |
| CDesignObjectOrientation | Allows the user to adjust the orientation for a design object (DEPRICATED) |
| CDesignObjectSearchWidget | Allows the user to enter search terms for filtering out tables or other views |
| CDesignObjectStringWidget | A widget allowing easy access to change the properties of a designObject by taking user string input |
| CDesignObjectToggleWidget | A widget allowing easy access to change the properties of a designObject by showing a toggle to the user |
| CDesignObjectUpdateTarget | An object that will be call update, each time the lookup is updated |
| CDesignObjectVisibleButton | A class for easily showing or hiding a Model in 3D space |
| CDesignObjectWidgetInterface | A base class for interacting with one or more DesignObjects |
| CDesignParameter | A definition of data that is logically stored in the Model heirarchy. Data could be a property of a Model, Geometry, Vertex, Shape, or Material |
| CDesignParameterAccumulator | Searches a model heirarchy and pulls all parameter data based on the AccumationMode settings |
| CDesignParameterExecutor | Used to execute a ManagedDesignCommand |
| CDesignParameterFinder | Searches a model heirarchy and pulls a list of available parameters along with the count for how many instances of that parameter are present |
| CDesignParameterSetter | Classes for conveniently setting parameters for a series of DesignObjects in the model hierarchy |
| CDesignPixmapResolver | Resolves images that are stored in NDV files or are a part of ImageFactory This class opens and pulls icons stored in NDV files and also converts NDEVR native images into the QPixmap fomrat |
| CDesignPointWidget | A point widget that can potentially be measured with a GNSS system or with user mouse input. Logic enhanced over typical PointWidget to allow for more functionality using the Design library functions |
| CDesignPropertyTable | A base class for tables wishing to show columns of DesignObject properties |
| CDesignPropertyTableView | A QTableView for showing Model or DesignObject properties |
| CDesignSelection | A simple structure for storing a collection of data |
| CDesignSettings | Stores generic settings that impact the behavior of the NDEVR API |
| CDesignSortFilterProxyModel | Provides the ability to pull data from a DesignObjectLookup for display in tables within the NDEVR API and filter and sort it |
| CDesignTableEditorWidget | |
| CDesignTableModel | Provides the ability to pull data from a DesignObjectLookup for display in tables within the NDEVR API |
| CDesignTask | A task which is to be executed by a DesignObjectLookup. When active tasks may limit certain functionality |
| CDesignTaskManager | Manages all active and inactive tasks for a DesignObjectLookup |
| ►CDesignWidget | A widget showing key properties of a DesignObject selection, used primarily in a SelectionWidget |
| CPropertiesStruct | |
| CDevice | A root class which describes some physical object, such as a Motor, Sensor, or Connection. Devices are updated automatically by calling startAutoUpdate and stopAutoUpdate |
| CDeviceFinder | Based class for finding devices connected to the system |
| CDeviceLostException | A specific type of Exception that occurs when a GraphicsDevice is lost. This typically requires a complete re-initialization of the NDEVR Graphics Engine |
| CDeviceManager | Container for all active Devices connected to the software |
| CDeviceUpdateThread | A class that updates a device by repeatedly calling update() until stop() is called |
| CDeviceWatcher | Watches and alerts the program when a USB device is plugged in or unplugged |
| CDialIcon | An icon along with defined behavior describing how that icon should interact with a parent QCustomDial object |
| CDiametricDimension | Logic for storing an diametric dimension in a CAD-friendly way for exporting and importing |
| CDictionary | A hash-based key-value store, useful for quick associative lookups. Key features include: |
| CDictionaryBase | A dummy base class for all Dictionary templates Used to more easily track inheritance for the templated Dictionary class |
| CDimAlignedData | A CAD measurement similar to AngleMeasurementModel |
| CDimensionData | Dimensional measurements stored in a CAD-friendly way |
| CDimensionOptions | Options for CAD dimension objects |
| CDimOrdinateData | Logic for storing an ordinate dimension in a CAD-friendly way for exporting and importing |
| CDistance | Dummy class for including distance functions |
| CDistanceEncoder | A distance encoder is a device that measures distance by generating pulses in response to an object's movement. The pulses are then processed and converted into a distance measurement |
| ►CDistanceEncoderSpreadsheet | Creates and writes data from a distance encoder to a set excel page |
| CDistanceReading | |
| CDockInit | Provides a way to optianally lazily initialize widgets when needed but still pass them to container docks. Useful for adding things to Settings dialogs or other large structures where they may never be initialized |
| CDockItem | The root class that allows iterface with the NDEVR API Widget Docking system |
| CDockWidget | |
| CDownloadDatasetWidget | A popup that is shown when a remote project is being downlaoded |
| CDropOverlay | Paints a translucent rectangle over another widget. The geometry of the rectangle is based on the mouse location. Used with the NDEVR API Widget Docking system to show where a dock can be placed |
| CDropOverlayCross | Shows a cross with 5 different drop area possibilities |
| CDVI3DSpreadsheetFactory | Creates and writes data from a DVISpreadsheet for easily importing and exporting data as points |
| CDWGFactory | Writes and Reads from DWG Files using the IOFactory interface |
| CDXFAttributes | DXF Style attributes that can be applied to CAD Entity objects |
| CDXFBlockWriter | A ModelIterator that iterates over each object in the model heirarchy turning them into nested BlockData objects |
| CDXFFactory | Writes and Reads from various DXF File types using the IOFactory interface. Optionally handles resolving IDs and UUIDs |
| CDXFGroup | A type of entity in CAD representing several entities grouped together |
| CDXFMaterial | A DXF friendly material class which contains UV properties similar to a Material object |
| CDXFReader | Logic for reading from a DXF stream of data. Data is streamed to a given CADEntityStreamer to be handled by the NDEVR API |
| CDXFTableWriteIterator | Converts objects into entities that can be placed within a DXF Entity Table. If flatten_model is false these entities will consist of nested Blocks |
| CDXFValueManager | DXF streams store data in a large numbered index structure. This class optimally stores this data so that it can be used to created entities at the right time |
| CDXFWriter | Handles writing data to a CAD entity stream |
| CDynamicPointer | Provides a modifiable pointer that has shared ownership of a dynamically allocated object |
| CE57Factory | Writes to an E57Factory using the IOFactory interface |
| CEditor | A base class for displaying options for editing a single DesignObject, typically a Model |
| CEffect | A core class that provides a dynamic effect to an object in a model heirarchy |
| CElevationRequest | Stores options and recieves data for determining the elevation at given coordinates |
| CElevationService | For a given coordinate, determines the elevation at that coordinate |
| CEllipseData | Stores Ellipse information for interfacing with CAD |
| CEnclosedModelInfo | A reference to some included Geometry or Model data included in a DesignSelection |
| CEntityConverter | Primary class responsible for converting CAD entities into native CAD entities. If specified can merge UUID structures based on modified time |
| CEntityData | An entity in CAD which has a layer and other handle information |
| ►CEquation | Stores in a compressed way, a formula that can be solved. A formula is made of up variables, numbers, and operations. Formulas can be simplified, or potentially solved to a numeric value |
| CEquationPart | |
| CEvent | Base class for user-driven events which are typically KeyEvent or MouseEvent |
| CException | Provides consistent interface to handle errors through the throw expression. All exceptions generated by the Parke library inherit from Exception |
| CExportChooserDialog | Allows the user to choose a specific Export format for use with IOFactory exporting |
| CExportRequest | Stores information related to exporting specific data from the software |
| CExternalApplicationManager | Manages an external application. This application may be run as a child process of the NDEVR API. For example a CAD session or a program to setup a GPS device. Programs often interact via a shared file which is handled through the IOFactory interface |
| CExtruder | Class containing static functions that define logic to extrude shapes along some given polyline |
| CExtrusion | Logic for storing a extrusion data in a CAD-friendly way for exporting and importing |
| CExtrusionData | Data for extruding an object onto a plane in CAD |
| CFactoryFeatures | Allows IOFactories to report what features they support to make the import/export dialogs easier to setup and layout |
| CFactoryModelFilters | Provides easy filtering tools for factories that are only able to export certain types of models or geometries |
| CFactoryOptions | User-defined options that define preferences for importing and exporting using IOFactory objects |
| CFactoryParameters | A container of input information that is to be filled with output information by an IOFactory |
| CFeatureOptions | Logic for checking or enabling software features. Certain capabilities will be locked by default without a user activation or without NDEVR issued IDs |
| CFFTLogic | Logic for implenting Fast Fourier Transform, a mathematical algorithm that converts signals from the time domain to the frequency domain |
| CFieldChooser | A Widget for setting up and choosing a Field used for importing and exporting data |
| CFile | Logic for reading or writing to a file as well as navigating filesystems |
| CFileAndFolderOptions | Stores ApplicationOptions related to user preferences for paths and program behavior relating to directories |
| CFileAndFolderSettingsDialog | Allows the user to adjust default folders or whether or not the software uses project folders or project files |
| CFileCachedData | Data that is cached from a file into program memory to limit expensive |
| CFileChooserDialog | A dialog designed to allow the user to navigate a filesytem and select or create one or more files or folders that match a criteria |
| CFileDropFrame | A simple frame that allows the user to drag and drop a file into it |
| CFileException | An Exception that contains information about a runtime error with a particular File. This is typically thrown when an action with a file causes an error to occur within the NDEVR API |
| CFileFactoryWarning | Allows the software to display a warning to the end user about a problem encountered during an IOFactory read/write operation |
| CFileFormat | Data that describes a particular file format and how to use the format with the program. Used especially with IOFactory |
| CFileHanderExtension | A description of the type of file a Module or resource can handle |
| CFileHandler | Stores information relating to a type of file the module can preview or handle |
| CFileHandlerVerb | Stores variables needed to perform a file action for a particular Module or resource |
| CFileOptions | Stores program-wide variables for controlling how the software works with |
| CFileRequest | A FileRequest bundles format data as well as a particular file |
| CFileResource | Contains methods for getting information about particular OS directories |
| CFileSearch | Logic for searching for files based on some criteria |
| CFilterDescription | Describes special options/parameters for a GeometryFilter engine |
| CFilteringWidget | A widget allowing the user to select a FilterDescription and adjust its properties and execute a filtering operation |
| CFireWallException | Stores information relating to a particular FireWallException needed by a Module or feature |
| CFloatingWidget | Used with the NDEVR API Widget Docking system for widgets that are floating. These widgets appear as windows within the application, though they are still managed by a ContainerWidget |
| CFont | Information for how to display text data |
| CFontEditor | A series of widgets that allow the user to adjust a font. Supports choosing a font, setting a size, bolding, underlining, etc |
| CFontEngine | Stores many different types of font |
| CFormula | Logic for storing the definition of a formula, that can be displayed to the end-user |
| CFormulaDialog | Allows the user to see and edit a formula |
| CFormulaTree | Logic that saves formulas into a tree-like dependency structure |
| CFragUniformObject | Items to send to the OpenGL Fragmentation shader |
| CFunctionCall | Used with StackTracer to track a specific function call in a stack trace |
| CGaussianRN | Used to generate a random number over a Gaussian distribution with templated setup parameters for very quick speed |
| CGenericOption | Stores a generic option of any type as well as some information about how the user might interact with that type |
| CGenericOptionGroup | Stores a groups of GenericOptions that can be used to group them |
| CGenericOptionsGroup | Creates a clean formatted dialog for any number of GenericOptions within a GenericOptionGroup Each option is labelled |
| CGenericOptionsWidget | Automatically creates a widget based on a GenericOption |
| ►CGeometry | A core class within the model heirarchy containing vertex-based data (Usually 3D data) within a set container. Geometries can be shared by multiple Model parents. The primary information for Geometry comes from its vertices, which can be resized. In addition, primitive columns are used to group these vertices in various different ways. Geometries can take on different shapes depending on their Type. See PrimitiveMode. In addition to vertices some data is stored in the form of GeometryProperty values which can be accessed via getGeometryProperty(GeometryProperty). For iterating over each vertex in the Geometry, use VertexIterator For iterating over each line in linework Geometry, use LineIterator For iterating over Geoemetry colors, use VertexColorIterator |
| COptimizedPrimitiveDef | |
| CSmoothingParameters | |
| CGeometryBoolean | Class for calculating geometry Boolean operations (AND, OR, NOT, XOR, ...) in 3D space. See https://en.wikipedia.org/wiki/Boolean_operations_on_polygons |
| CGeometryBooleanParameters | Stores a groups of options for performing GeometryBoolean operations |
| CGeometryEditor | A popup Editor dialog for showing options or information related to Geometry objects |
| CGeometryFilter | A service that contains registered algorithms for removing vertices or shapes from a group of vertices or shapes |
| CGeometryFilterParameters | Stores a groups of options for performing GeometryFilter operations |
| CGeometryPositionModRestore | Class to easily restore calculated data in a Geometry after a location altering process |
| CGeometryRegistration | A service that contains registered algorithms for registering geometry such that the input is adjusted to match the output. See https://en.wikipedia.org/wiki/Point-set_registration |
| CGeometryRegistrationDescription | Describes special options/parameters for a GeometryRegistration engine |
| CGeometryRegistrationParameters | Describes options/parameters for running the GeometryRegistration |
| CGeometrySelectionOptimizer | Indexes and stores specific vertices or objects in a selection |
| CGeometryVertices | An container for storing some number of vertices for editing |
| CGeoSlamFactory | Reads .geoslam files |
| CGettingStartedDialog | This dialog is shown front and center before the user has loaded any data or created a project In touch mode large buttons are shown, while the company logo is shown as a backdrop in Desktop mode |
| CGLCapabilities | Capabilities provided by a GLESGraphicsDevice |
| CGLESCameraManager | Manages viewports in the OpenGL engine, responsible for matrix transformations within shaders |
| CGLESCameraViewFactory | Allows the software to generate OpenGL windows when requested that are rendered with OpenGL |
| CGLESGraphicsDevice | Buffer for storing data in the OpenGL engine, usually for rendering |
| CGLESGraphicsPipeline | Creates and manages the resources necessary for rendering a single Viewport within the OpenGL pipeline. May be run on a single thread for each Viewport |
| CGLESGraphicsSession | Creates and manages the resources necessary for converting a DesignObjectLookup into 3D rendered data in the OpenGL engine |
| CGLESGraphicsWindow | The core Window used to render a viewport with OpenGL |
| CGLESMaterialManager | Structure responsible for handling the OpenGL data surrounding a particular Material object |
| CGLESRenderObject | A root render Object for OpenGL, which consists of a set Material, Model, and Geometry that is used together to optimally create a 3D render |
| CGLESShader | A Shader for rendering default OpenGL logic to the graphics card |
| CGLESShaderManager | Manages all shaders used with OpenGL and the NDEVR API |
| CGLESVertexManager | Manages vertex buffers for the OpenGL engine |
| CGLESVertexUniformObject | Stores items to send to the OpenGL Vertex Shader |
| CGNSSInterface | A GNSS interface provides logic for finding available GNSS devices |
| CGNSSManager | A storage class for GNSSInterface that allows the software to specify roles, or find and assign GNSS devices |
| CGNSSRole | A GNSS role describes how the user wants to use a particular GNSS Device. For example: A role might be used for travese or orientation, or a front or rear measurement point |
| CGPSPoint | A coordinate generated by a GPNSS system |
| CGrabNetworkInfo | Provides an AutomatedTest for grabbing network information |
| CGraphicsBuffer | A Special abstract TableColumn responsible for interfacing a Buffer of data with the video card. Provides common interface for setting the memory around primitive types. GraphicsBuffers typically mirror local TableColumns and push updates to the video card at times when it is appropriate to do so |
| CGraphicsCameraManager | A structure for managing Viewport interactions with an NDEVR Rendering Engine |
| CGraphicsDevice | A physical or virtual device used with the NDEVR Rendering Engine. A device contains System specific limitations for rendering. Only one device is used for all rendering operations |
| CGraphicsException | A common exeption thrown when an issue occurs within the NDEVR Graphics Engine |
| CGraphicsManager | A common interface responsible for managing specific actions with a Gaphics engine, such as Vulkan or OpenGL |
| CGraphicsManagerBase | Used for interfacing with a Gaphics engine, such as Vulkan or OpenGL |
| CGraphicsManagerFactory | Stores a default rendering engine to be used with the application |
| CGraphicsPipeline | A GraphicsPipeline is a set of resources that are chained together to correctly render something |
| CGraphicsSession | A GraphicsPipeline that is responsible for setting up and rendering the resources of a DesignObjectLookup |
| CGraphicsUpdateArguments | Options that are used for performing an update on a Graphics Engine call |
| CGraphicsUpdater | Responsible for updating resources or layouts of data in-between calls to render |
| CGriddedSliceIterator | Slices object into evenly spaced cross sections |
| CGridIndexing | Converts 1 dimensional index into N dimensional index based on size of each dimension |
| CGridMesh | Stores a uniform grid of data in N dimensions into a Geometry object |
| CHandleData | A handle used to reference an object in CAD |
| ►CHardwareCommandQueue | A base class for communicating with Hardware, typically firmware by the software. Commands a queued up and sent, before waiting for a response for each command |
| CCommandQueueItem | |
| CCommandRecord | |
| CHardwareException | A typical exception thrown when something fails with a Device |
| CHardwareInformation | Contains information about a computer or device that is capable of running software typically with a CPU and memory |
| CHardwareSearchParameters | Options for finding active hardware connectons. Used with DeviceFinder |
| CHardwareSearchPathParameters | A series of paths to use for finding potential hardware connections. Used with DeviceFinder |
| CHatchData | Logic for storing a hatch-data in a CAD-friendly way for exporting and importing |
| CHatchEdgeData | Stores information about the edge of a CAD hatch pattern |
| CHatchLoopData | Provides loops of data for the CAD hatch pattern |
| CHSBColor | The HSB (Hue, Saturation, Brightness) color model defines a color space in terms of three constituent components hue, brightness and brightness |
| CHSLColor | The HSL (Hue, Saturation, Luminosity) color model defines a color space in |
| ►CIcoFile | Logic for handling files with the .ico extension |
| CBitmapInfoHeader | |
| CIconDir | |
| CIconDirEntry | |
| CIconCacheWidget | A placeholder widget for Files displayed with FileChooserDialog until the actual icon can be loaded from the disk, which may be a slow operation for large directories |
| CIconDefinition | Information for displaying a particular icon |
| CIconEngineItem | Stores a specific renderer and transform for SVG rendering |
| CIconManager | Stores information about many different icons |
| CIconThemeSettings | Stores information for how to draw icons, when supported |
| CImage | A root class that stores an an array of pixel data that can be displayed as an Image |
| CImageData | A container for Images managed by the ImageFactory. Provides convenience access functions without actually allocating memory outside of the factory |
| CImageDataStream | Defines a DataStream for Image reading or writing |
| CImageDefData | Stores the definition of an Image for easy interface with CAD |
| CImageFactory | The core class for reading/writing and storing images in an optimized way |
| CImageFormatHandler | Can be used to add functionality to the ImageFactory |
| CImageModelDialog | A popup Editor dialog for showing options or information related to ImageModel model objects |
| CImageVectorizationEngine | Contains services that can turn a 2D rastered image into linework |
| CImageView | A widget that shows a raster image or icon |
| CIMUCalibrator | Logic and storage for IMU calibration. An IMU calibration works by moving the sensor into a series of predefined locations and using this motion to calibrated the accelerometer and gyro |
| CINIFactory | Contains methods for easily reading and writing to an INI file including efficient casting, callback, and variable storage methods |
| CINIInterface | Contains methods for easily reading and writing to an INI file including |
| CINIOption | A class used with INIFactory to store a reference to an object in the program that can be inherited to provide read and write functionality to the factory |
| CInitialSetupDialog | Shown after a new installation on a device, allowing the user to familiarize themselves with the environment and to setup any needed settings, such as language, and performing registation |
| CInterfaceOrientationController | This class is responsible for notifying and providing default layout logic when the orientation of the widget changes, such as for a screen rotaton. Espcially useful for phones that may change orientation. For example, QBoxLayouts will be set to vertical when the screen is vertical and horizontal when the screen is horizontal. Widgets can be added inverted, meaning the opposite of the default layout behavior will occur. Widget will be layed out as soon as run is called on it, and subsequently when the interface layout changes. Provided widget is destroyed on the main thread, there is no need to automatically remove it from the controller |
| CIntersection | Dummy class for including intersection functions |
| CInvisibleButton | A button that is completely invisible. Can be used to intercept a user click in a certain area |
| CIOFactory | A service that provides Import/Export functionality for a model heirarchy. These can be registered with a EnableFactory to allow the user to export/import to certain file formats. In order to provide support for new file formats, classes should overrdide this class and then add themselves using EnableFactory |
| CIPWidget | A simple widget for entering in an IP address. Multiple QCustomLineEdits allow the user to enter in the parts of the IP connection |
| CIredesPatternFactory | |
| Cis_base_of_template_impl | |
| CIsSameType | |
| CIsSameType< t_type_a, t_type_a > | |
| CIsVec | |
| CIsVecType | |
| CItemDownloader | Used for Downloading resources from a network |
| CJoystick | A joystick that allows the user to move around, reporting the vector of the stick, relative to the center of the joystick |
| CJoystickSettings | Settings that define how a Joystick will behave |
| CJoystickSettingsDialog | A dialog which allows the user to set sensitivity and other properties of a Joystick object |
| CJSONNode | JavaScript Object Notation or JSON is an open - standard file format that uses human - readable text to transmit data objects consisting of attribute–value pairs and array data types(or any other
serializable value) |
| CKeyController | A high-level controller that stores many sub controllers that can be used to modify behaviors on user key-presses |
| CKeyControllerBase | Base class for KeyController, a service which provides functionality based on user key-presses |
| CKeyEvent | A class which describes a user key press |
| CKeyOption | An action that can be tied to a specific KeyPress within the software |
| CKeypad | A popup for showing a virtual keyboard or keypad. Changes based on the allowed input to a widget. Usually shown in touch mode |
| CKeystrokeWidget | Allows the user to assign a keystroke to an action by displaying a button with the current keystroke assignment that when clicked, records a new keyboard assignment |
| CKMLFactory | |
| CLABColor | A Lab color space is a color-opponent space with dimension L for luminance and a and b for the color-opponent dimensions, based on nonlinearly-compressed CIE XYZ color space coordinates |
| CLandXMLFactory | Writes and reads to a LandXML file: http://www.landxml.org/About.aspx |
| CLanguageEditor | Allows the user to adjust translation values for a given language |
| CLanguageHighlighter | Syntactically highlights translations |
| CLASFactory | Provides support for reading and writing to LAS and LAZ point cloud files using the FactoryIO interface |
| CLatLonUnit | A specific unit that can convert between coordinate projections |
| CLayerCacheObject | Stores cached information for the LayerModel |
| CLayerData | Layer information shared with CAD |
| CLayerEditor | A popup Editor dialog for showing options or information related to Layer model objects |
| CLayerModel | Used for showing Layers in a table using the QAbstractItemModel interface |
| CLayerTable | A table showing a list of Layers |
| CLayerWidget | A widget that allows the user to set or interface with the current layer |
| CLeaderData | Logic for storing a leader in a CAD-friendly way for exporting and importing |
| CLEDLightWidget | Displays a simple light widget that can be set to blink or change colors |
| CLibAssert | The default way to make Assert statements within the NDEVR API. A no-op in release but throws an exception in debug |
| CLibraryManager | Manages loading Models from a group that is stored either on a remote server or locally on the disk in a compressed or uncompressed folder |
| CLibraryWidget | Allows the user to select Models or Materials from a list to add to the scene. See DesignObjectChooser and LibraryManager |
| CLight | A Device responsible for turning on and off a light source. The light could be anything from a laser pointer to a large diffuse light source |
| CLinearDimension | A CAD measurement similar to DistanceMeasurementModel |
| CLineData | A CAD-friendly way to store line segment information |
| CLineElevationRequest | Used with ElevationService to request elevations over a polyline at set intervals |
| CLineIterator | A class to easily iterate each line segment over a Geometry of lines |
| CLineSegment | A line segment represented by two vertices, a start and end |
| CLineTypeData | Information for a type of line in CAD |
| CLineworkMaterialEditor | A popup Editor dialog for showing options or information related to Materials used with outlines or linework such as pixel thickness |
| CLocalApplicationLauncher | Information and logic for launching an application seperate from the current software |
| CLocalApplicationLauncherThread | Allows application to run on a seperate thread |
| CLocalBattery | Allows the software to get information about local system batteries |
| CLocalPhysicalCameraView | Provides access to a local camera on the system, such as a webcam or camera for a phone |
| CLocalPhysicalCameraViewFactory | Provides an interface to PhysicalCameraViewFactory for creating a LocalPhysicalCameraView |
| CLocationElevationUnit | An Unit that has both a location and elevation (Think Lat/Lon which has meters for elevation) |
| CLocationOperations | A Model which contains logic for dynamically setting the location of an object relative to information that might dynamically change |
| CLockAnalyzerThread | Used to check for and resolve potential deadlocks or resource starvation across threads |
| CLog | Serves as the primary program interface for processes to report issues and allows any number of LogStreams to subscribe and receive the log information in real-time |
| CLogManager | A class that has any number of children that also feed into the log. Can be used to easily collect logs from a variaty of different streams |
| CLogManagerDialog | A dialog which shows multiple log views, where each log is a tab |
| CLogMessage | A class that allows for specific log information to be conveyed to a ProgressInfo object including information about severity and timestamp information |
| CLogStream | A class that listens to a log object and processes the updates in a specified way. Any number of LogStreams can be attached to a ProgressInfo object and will be updated in real time |
| CLogView | A table showing a specific log that allows the user to scroll around to view various log entries |
| CLogViewTable | A model for creating a table that displays logged records |
| CLoopedAutomatedTest | A type of AutomatedTest that repeatedly loops until stopped by the user |
| CLUDecomposition | Logic for performing LU Decomposition https://en.wikipedia.org/wiki/LU_decomposition |
| CMachineID | Logic for retrieving specific details about the machine this software is running on |
| CMadgwickOrientationSensor | Used to calculate madgick orientation given sensor streams for gyro and optionally magnetometer(s) and accelerometer(s) |
| CMagneticCalibrationData | Stores magnetic calibration data as a Model including the transformation and calibration points |
| CMagneticCalibrationFactory | IOFactory interface for reading and writing MagneticCalibrationData to files |
| CMagneticCalibrationSpreadsheet | IOFactory interface for reading and writing data from magnetometer calibration checks to excel files |
| CMagneticDeclinationDialog | Dialog which allows user to set or calculate the magnetic declination. https://en.wikipedia.org/wiki/Magnetic_declination |
| CMagneticDeclinationDialogFactory | Allows program-wide registration of a magnetic dialog to display when user should adjust magnetic declination |
| CMagnetometerCalibrationDialog | Dialog which allows user to edit or create a MagneticCalibrationData object |
| CMagnetometerWidget | Widget for displaying the live state of a magnetometer object |
| CManagedDesignCommand | A specified type of DesignCommand that performs common actions such as grouping or setting property variables |
| CManual | Contains information for adding a manual to the software, usually shown in the "About" page |
| CManualManager | Manages all available manuals in the software |
| CMaterial | Container responsible for storing and setting the appearance of a Model or Geometry within the NDEVR API 3D environment. Models may have 3 materials but Materials can be shared across any number of Models within a Scene |
| CMaterialPropertySlider | Can adjust the properties of a material using a QCustomSlider widget |
| CMaterialRaster | Stores information for painting pixels at a time into a 2D texture |
| CMaterialRasterBase | Base class for painting pixels at a time into a 2D texture |
| CMaterialRasterFactory | Creates rasters for converting points and directions into 2D images |
| CMaterialUVImageOptions | Provides CAD information for managing images attached to a Material |
| CMaterialUVOptions | UVOptions used for interfacing with CAD, similar to those used by a Material object |
| CMaterialWidget | A simple widget showing some visual properties of a Material or Model |
| CMatrix | |
| CMatrixDefinitions | Provides common definitions for creating 4x4 matrices of certain types |
| CMatrixEditor | A simple widget that shows a modifiable 4x4 matrix and corresponding widgets for editting a 4x4 matrix |
| ►CMatrixFunctions | |
| CTransformSolveOptions | |
| CMatrixInverter | Templated logic for inverting a matrix based on the number of rows and columns |
| CMatrixUnit | A unit that has a complex rotational offset. Think northing-easting vs easting-southing |
| CMD5 | Logic for creating an MD5 hash |
| CMD5_CTX | Struct for storing md5 information |
| CMeasurementOptions | Stores ApplicationOptions related to user preferences for measurements |
| CMedian | A dummy class for including optimized median functions |
| CMercatorImage | Information output from a specific Aerial Tile request |
| CMercatorImageManager | Place where service can be registered to provide aerial image support |
| CMercatorImageRequest | Contains the information for requesting a 2D top-down view of a geographic location to be used with a AerialImage service such as google earth. = |
| CModel | A core class that represents a node on model heirarchy. This node may contain a Geometry or one or more child Models as well as 3 different materials for rendering the Geometry parts |
| CModelChooserCombo | |
| CModelFactory | The core logic for importing and exporting files from the model heirarchy. Stores a series of IOFactory children that can define when and how they are able to export or import data |
| CModelFileDialog | Shows options related to an import or export that utilizes the IOFactory methods to write or read properties. Dialog allows user to edit settings related to one set of FactoryOptions |
| CModelIterator | A base class for easily transversing a model heirarchy, applying an overritten function at each level or for each object |
| CModelMaterialEditor | A popup Editor dialog for showing options or information related to a Model's Material children |
| CModelMaterialsDialog | A popup Editor dialog for showing options or information related to showing all of the materials that a Model might have |
| CModelOffsetCommandWidget | Allows the user to offset a model to a different location |
| CModelOrientationEditor | A popup Editor dialog for showing options related to the Orientation of a specific Model |
| CModelSelectionTree | |
| ►CModelTableColumnSpec | Provides the ability to pull specific data from a DesignObjectLookup for display in a column of a table |
| CRelativePathObject | |
| CModelTableDelegate | A QItemDelegate for showing model properties in a QTableView |
| CModule | Base class for extensions, typically added as external DLL's that can modify or enhance the behavior of the software |
| CModuleConfiguration | Stores all information relating to a particular feature or resource included by a Module |
| CModuleDependency | A dependency of a Module. Either a resource, or install action, defined by the module and automatically handled by the NDEVR build environment |
| CModuleFeatureBase | Describes the Module or feature to the end user |
| CModuleManager | Logic for the program-wide storage and execution of Modules. Called in software setup to allow modules to perform actions to modify or enhance the software |
| CModuleResourceManager | Stores all dependencies for a combination of modules that make up a complete software package |
| CModulesDialog | Allows the user to see which Modules are available and toggle them on or off, when Modules are toggleable |
| CMotor | A motor is a device which produces rotational spin. This could be anything from a servo motor to a rapidly spinning device with an apx RPM |
| CMotorDeploymentWidget | Provides an interface for controlling a motor involved with a particular Deployment |
| CMouseEvent | |
| CMovementPath | Logic for moving an object across a path of both position, and optionally, orientation |
| CMTextData | Stores text data that may have an attachment point and direction for interfacing with CAD |
| CNCCustomReport | |
| CNDEVRApplication | The root class of the NDEVR Application |
| ►CNDEVRChart | Default base chart for 2D line or scatter plots within the NDEVR API |
| CPlotData | |
| CNDEVRGraphicsManagerFactory | Stores a default rendering engine to be used with the application, with logic for finding a enabled Graphics Engine and using it to create a GraphicsManager |
| CNDEVRIconEngine | Used to render any icons or fetch any pixmaps within the software. More rendering engines can be added to create QIcon or QPixmap objects for given resources |
| CNDEVRProxyStyle | Responsible for setting up the core style of the application including size of various widgets and colors. Some themes are inherited from the OS, some from Qt's fusion style, and some are defined and drawn directly |
| CNDEVRRadialChart | Default radial (round) base chart for 2D line or scatter plots within the NDEVR API |
| ►CNDEVRRibbon | |
| CNDEVRRibbonWidget | |
| CNDEVRRibbonOptions | |
| CNDEVRSVGIconEngine | A QIconEngine used to render SVG icons |
| CNDEVRUpdateChecker | Allows the application to check a given location for an update.txt file which it can then use to download and update the software |
| CNDEVRWindow | A top-level widget |
| CNDVArchiveManager | Manages file archives which are compressed ndv files merged for convenience |
| CNDVFactory | Reads and writes to NDV Files. NDV Files are optionally compressed data dumps of the internal structure of model heirarchies |
| CNDVSetupCallback | Used to modify objects when they are imported using the NDVFactory |
| CNetworkAccessManager | Provides an interface for accessing resources on the internet |
| CNetworkConnectionDialog | A ConnectionDialog allowing the user to edit a TCP/UDP style connection |
| CNetworkConnectionDialogFactory | A ConnectionDialogFactory which allows for the creation of a NetworkConnectionDialog |
| CNetworkRequest | A request for data or information from a network |
| CNewModelCommand | A DesignCommand that creates a new Model to some specification |
| CNewProjectTest | Provides an AutomatedTest for repeatedly creating and destroying Projects |
| CNtpAuthenticationInfo | |
| CNtpClient | |
| CNtpFullPacket | |
| CNtpPacket | |
| CNtpPacketFlags | |
| CNtpReply | |
| CNtpTimestamp | |
| CNumberParser | |
| CNumberWriter | Logic for writing to a number |
| CObjectAllocator | |
| CObjectAllocatorT | The default object allocator for Buffer |
| CObjectAllocatorT< t_index_type, false > | The default object allocator for Buffers of non-primitive types that have destructors or memory on the heap |
| CObjectAllocatorT< t_index_type, true > | The default object allocator for Buffers of primitive types such as doubles or ints |
| CObjectChecker | Used with QTDesignObject to check the type of an object |
| CObjectChecker< DesignObject > | |
| CObjectChecker< DesignSelection > | |
| CObjectChecker< Geometry > | |
| CObjectChecker< Material > | |
| CObjectChecker< Model > | |
| CObjectInfo | Information about the object |
| COpacitySlider | Can adjust the opacity of a material using a QCustomSlider widget |
| COpenCloseTest | Provides an AutomatedTest for repeatedly opening and closing a Project |
| COpenGLBuffer | Buffer for storing data in the OpenGL engine, usually for rendering |
| COpenMP | Dummy class for including OpenMP macros https://www.openmp.org/ |
| COptimizedSelection | Stores an indexed selection |
| COrientationEditor | A dialog where the user can set a 3D orientation of an object |
| COrientationOperations | Allows for easy manipulation of a Models orientation |
| ►COrientationOperationsWidget | A popup Editor dialog for showing options or information related to the orientation of an Object layer or Calibration. Objects can be set to rotate along a given axis |
| CGNSSCallback | |
| COrientationReading | A single reading, typically used by a MadgwickOrientationSensor consisiting of input from all IMU sensors. These might be interpolated values |
| COrientationSensor | Used to report the orientation of a Hardware object within 3D space |
| COSInformation | Contains information about an Operating System including versions and types |
| COSType | Stores String variables reprenting the type of OS that will be supported by a particular module or resource |
| CPaperSpace | Stores CAD details about PaperSpace or 2D document space |
| CParticle | Used with CSF Cloth, The particle class represents a particle of mass that can move around in 3D space |
| CPath | An interpolated path in 3D space |
| CPathSliceIterator | Slices object evenly along a specified polyline |
| CPDFFactory | Writes to a PDF file using the IOFactory interface |
| CPermission | Information about a requested OS-permission typically requested at install time |
| CPerspectiveListNormalFlipper | A class that flips a surface generated normals from point clouds or lines given based around a path of a perspective |
| CPixelThicknessSlider | Can adjust the pixel thickness of a material using a QCustomSlider widget |
| CPixmapResolver | Base class for logic that can be used to resolve a Pixmap resource and turn it into a QPixmap for use by the NDEVR API |
| CPlacementData | Data about where to place an object, used for interfacing with CAD |
| CPlane | Logic for a given plane or N-dimensions. Planes are coordinate systems of one less dimension than the dimension they occupy |
| CPlatformType | Stores String variables reprenting the type of platform CPU configuration that will be supported by a particular Module or resource (x64, x86, arm etc) |
| CPointData | Point data stored in a friendly way for interfacing with CAD |
| CPointer | Provides shared ownership of a dynamically allocated object |
| CPointerCore | Used by Pointer to store the reference count of the pointer |
| ►CPointWidget | Allows the user to input an N-dimensional point (up to 4 dimensions) with an optinal unit. Also allows other widgets, such as a GNSS take reading button, to be added into the layout |
| CGNSSCallback | |
| CPreTransform | |
| CPolygon | An N-sided polygon |
| CPolyline | A polyline which stores vertex information for many points along a given path |
| CPolylineData | Logic for storing a polyline data in a CAD-friendly way for exporting and importing |
| CPolylineMaker | Given random line segments, constructs a polyline when the vertices match. Used in Parameter slicing |
| CPolylineSliceCache | Internal class for storing Polyline slice data |
| CPolylineSliceEditor | Allows for visualization of individual 2D slices of polylines that lie on the same plane |
| CPolylineSliceIterator | Arguments for performing a Geometry slice operation |
| CPolylineSlicer | Logic for slicing one or more Model/Geometry objects into polyline Model/Geometry objects based on set criteria |
| CPopupInfo | Class which is used to pass arguments and requests for creating a popup dialog or widget. You can request things like fullscreen, whether or not the dialog is closable, etc, as well as the animation origin for the popup |
| CPopupManager | Responsible for displaying widgets that want to be in their own window |
| CPositionSensor | A position sensor is a Device that determines the position of Hardware. This device might be a GPS or SLAM style logic device |
| CPrimitiveLineSegmentEditor | Shown when user is editing lines, to assist them in adjusting the line in 3D space |
| CPrimitiveVertexEditor | Allows the user to adjust properties for a particular Geometry Vertex node |
| CPrintPreview | A dialog that shows a PrintPreview of a given widgets, reports, or images. User can modify print settings and print directly from this dialog |
| CProgressInfo | A light-weight base class for Log that allows processes to update, without the need for additional include overheads |
| CProgressWidget | Displays the progress, either horizontally as a bar or as a roand spin dial. Contains various options for display and can be added as a LogStream to a Log |
| CProj4CoordinateConverter | |
| CProj4CoordinateConverterFactory | |
| CProject | A Model which represents a user-project. A project is a series of Scenes grouped together within a software session. Typically there will only ever be one project in a software session |
| CProjectEditor | A popup Editor dialog for showing options or information related to Project model objects. This dialog is shown when the user first creates a project and can be accessed from the top of the SceneTree widget |
| CProjectFileManager | Manages writing to the NDV file and any folder operations for projects. Also responsible for creating auto-save backup files at given intervals |
| CPropertiesButton | |
| CPropertyChangeListener | Listens for a change of a particular property to a given target (DEPRECIATED) |
| CPropertyChangeManager | Used to listen for changes to properties (DEPRECIATED) |
| CPropertyChannelFilter | Filters geoemetry based on properties of the geometry |
| CProxyModelViewFilter | Filters and sorts Models from a ModelManager for views such as in a table or in a tree view |
| CQCaptureManager | An interface used to manage multiple CaptureRequests and scedule their completion |
| CQCustomColorDialog | A dialog devoted to allowing the user to select a custom color |
| CQCustomComboBox | A compact way to present a list of options to the user |
| CQCustomDial | Provides a rounded range control (like a speedometer or potentiometer) |
| CQCustomDockWidget | Provides a wrapper for a widget that can be docked inside a Container or floated as a top-level window within the application |
| CQCustomImage | |
| CQCustomLabel | Displays translated text. No user interaction functionality is provided. The visual appearance of the label can be configured in various ways |
| CQCustomLineEdit | A line edit allows users to enter and edit a single line of plain text with useful editing functions, including undo and redo, cut and paste, and drag and drop |
| CQCustomMessageBox | A message box displays a primary text to alert the user to a situation, an informative text to further explain the situation, and an optional detailed text to provide even more data if the user requests it. The interface for this object allows from either a set of predifined user options (OK, Load, Cancel, etc) or a set of program defined responses that the user can choose from |
| CQCustomProgressBar | Allows for showing of progress bar in horizontal format. Defaults to look and feel of system progress bar |
| CQCustomScrollArea | A scroll area is used to display the contents of a child widget within a frame. If the widget exceeds the size of the frame, the view can provide scroll bars so that the entire area of the child widget can be viewed |
| CQCustomSlider | The slider is the classic widget for controlling a bounded value. It lets the user move a slider handle along a horizontal or vertical groove and translates the handle's position into a percent value 0.0 to 1.0 |
| CQCustomSplitter | A splitter lets the user control the size of 2 child widgets by dragging the boundary between them |
| CQCustomStackedWidget | The main class for a layout where all widgets occupy the same same and only one widget is shown at a time |
| CQCustomStackedWidgetBase | A base class for a series of widgets where all widgets occupy the same same and only one widget is shown at a time |
| CQCustomTableWidget | Provides a standard way to show table data within the application |
| CQCustomTabWidget | A tab widget provides a tab area and a "page area" that is used to display pages related to each tab. By default, the tab bar is shown above the page area, but different configurations are available |
| CQCustomTextEdit | A widget that is used to edit and display both plain and rich text in a multi-lined format |
| CQCustomToolBox | A toolbox is a widget that displays a column of tabs one above the other, with the current item displayed below the current tab. Every tab has an index position within the column of tabs |
| CQCustomTooltip | Provides tool tips (balloon help) for any widget that usually shows up when a mouse is hovered over a widget for a set amount of time |
| CQCustomTranslator | Allows QT to call into the native application translator when needed to translate UI auto-generated items |
| CQCustomValidator | Responsible on most user input fields for correcting the input when possible or allerting the user that the input is incorrect. Used on all QCustomLineEdit widgets and derivatives |
| CQDeviceChangeEvent | The event that is triggered when a USB device is plugged in or unplugged |
| CQModelViewCapture | Used to capture a 2D image of a DesignObjectLookup from a specific perspective |
| CQTAbstractResourceListener | |
| CQTDesignObject | A pointer to a DesignObject within a QTModelManager that recieves and emits update signals based on the state of the object |
| CQTErrorBrowser | A dialog that groups together a series of error dialogs that might have occured at the same time |
| CQTErrorDialog | A dialog typically shown as a tab that displays an exception to the user. Typically interfaced via QTErrorDialog::CreateErrorDialog |
| CQTGraphicsWidget | A Widget wrapper around a QTGraphicsWindow that allows it to be used inside the UI framework |
| CQTGraphicsWindow | A Window used to render 3D graphics. This container allows for a different graphics backend to be used than the rest of the UI |
| CQTIconManager | Manages all Icons and Pixmaps used by the UI in the NDEVR Engine. Icons may be fetched remotely so callbacks are used to specify the action to take when the resouce is retrieved |
| CQTModelManager | A wrapper around DesignObjectLookup that provides signal and slot functionality and adds rendering capabilities to the model heirarchy |
| ►CQTModelManagerView | A Qt compatible ItemModel for interfacing with a DesignObjectLookup |
| CModelCache | |
| CQtNetworkAccessManager | Allows the application to request network data using the Qt Framework |
| CQtNetworkRequest | Contains information specific for making a network request within the Qt Framework |
| CQTResourceListener | |
| CQTSoundManager | Adds Sound generated via the Qt Framework to the application |
| CQTTools | Manages static logic dealing with Qt and relating to the application |
| CQTVertexManagerView | A Qt compatible AbstractTableModel for showing properties around a series of Geometry Vertex objects |
| CQTVibrationManager | When supported, such as on Android/IOS, will vibrate the device |
| CQtVulkanSession | A VulkanSession within the Qt space |
| CQTWidgetImage | A Qt compatible wrapper for an image for use with QWidgetModel |
| CQuaternion | Https://www.3dgep.com/understanding-quaternions/ |
| CQueueBuffer | Stores objects in a first-in, first out queue based Buffer with push and pop functions |
| ►CQuickVisualization | Allows for the creation of Models that represent points or linework quickly and efficiently |
| CVertexVisualizationOptions | |
| CQWidgetModel | A 3D Model that mirrors a QWidget object |
| CRadialDimension | Logic for storing a radial dimension in a CAD-friendly way for exporting and importing |
| CRadialObject | A radial object |
| CRandom | Dummy class for including random number generator functions |
| CRandomColorGenerator | Generates random colors based off of some specified settings |
| CRandomColorOptions | Used with RandomColorGenerator to generate random colors |
| CRangeSensor | A RangeSensor is a Device that determines the distance of a target at a certian orientaton. Usually based on LiDAR or photogrametry |
| CRasterInfo | Stores information for painting pixels at a time into a 2D texture used with MaterialRaster |
| CRasterization | Creates a raster of the terrain using the Cloth simulation |
| CRay | |
| CRDesignLock | Used to lock a particular model for editing (DEPRECIATED) |
| CReferenceCustomUnit | A unit that mirrors another set unit |
| CReferenceUnit | |
| CRegexFunctions | Logic for creating regular expressions for certain situations |
| CRegistryKeyAction | Information about a specific registry action to be taken, typically at install-time |
| CRenderer | An object that renders a specific Camera object, typically run on a different thread than the main UI thread. Rendering takes place between calls to the GraphicsUpdater. If there is more than one QTGraphicsWindow, there may be more than one Renderer running at a time |
| CReplyTimeout | Handles timing out certain operations such as downloads |
| CReportGeneratorDialog | |
| CReportGeneratorSettings | |
| CReportHandler | Handles creating a report page from some given data. A report page is a QWidget object that is formatted for printing to a printer or PDF page |
| CReportIterator | Iterates through a series of reports for drawing, sending to a PDF or printing |
| CReportJSONMaker | Creates a JSON data structure that can be used for generating a report in MSWord |
| CReportManager | Storage class for all ReportHandlers |
| CReportOptions | |
| CReportTemplate | A simple Template for a report |
| CResizeVisibleAnimation | Resposible for animating widgets by having them grown as they become visible, or shrink as they become invisible. For some operating systems will also apply a fade effect |
| CResource | A core part of the engine, stores variables that can be listened to with ResourceListener which will recieve updates when changed |
| CResourceBase | A base class for templated resources |
| CResourceListener | A class that can subscribe to any number of Resources which will get updates when the Resource(s) have been modified |
| CResourceMirror | Creates logic that mirrors two resources. Meaning changing either resource will modify the other resource |
| CResourceResolver | This class resolves resources data identified by a string. The data absolute path is then passed on to an on_finished function |
| CRGBColor | Represents a color in the RGB space with optional alpha transparency |
| CRibbon | The UI ribbon is a horizontal menu bar typically located at the top of the application interface or along the side. It organizes commands and tools into tabs and groups for easy access. Each tab contains related functionality, categorized into sections such as File, Edit, View, etc. Within these sections, buttons, dropdowns, and other controls allow users to interact with the application features efficiently. The ribbon improves usability by presenting frequently-used commands in a visually organized manner |
| CRibbonGroup | Represents the "Tab" of a widget. For example sections such as Home, View, Edit, Measurements would all be RibbonGroups and children of a Ribbon object |
| CRibbonSubGroup | Represents a sub-section of "Tab" of a ribbon represting a grouping of buttons or widgets within a tab that provide similar functions |
| CRLock | Used to lock a particular variable for reading. Any number of readers can be created when no write locks are on a variable, otherwise will wait |
| CRockWorksFactory | Writes and reads a Rockworks file Adds support for reading and writing BlockModel enteties to RockWorks |
| CRockWorksSetup | Setup parameters for RockWorks. Used to setup types of solid making algorithms used by RockWorks |
| CRockworksSolidModInfo | Stores cell information for Rockworks Block Models Used to setup types of solid making algorithms used by RockWorks |
| CRTree | |
| CRWLock | Maintains a pair of associated locks, one for read-only operations and one for writing. The read lock may be held simultaneously by multiple reader |
| CSaveOptions | Options for saving an NDEVR project |
| CScaledOffsetUnit | A unit that has both a scale and an offset (think degrees celcius vs fahrenheit) |
| CScaledUnit | A unit that describes a simple scale (think meters vs feet) |
| CScanner | Contains methods for easily reading objects in an ascii stream |
| CScene | The root Model that is responsible for storing the underlying data for all Scene Models |
| CSceneTree | |
| CSceneTreeModelDelegate | Responsible for rendering an entry into a SceneTree widget |
| CSceneTreeWidget | |
| CScrollGesture | Handles scrolling or flicking within the application |
| CSectionContent | The core container for objects using the NDEVR API Widget Docking system. Contains information used to correctly display the content |
| CSectionIconTab | Provides a tab that contains an icon and some buttons used for either a tab if the section content is attached to a Container, or as the drag bar if the content is floating |
| CSectionTab | Provides a tab that is used for either a tab if the section content is attached to a Container, or as the drag bar if the content is floating |
| CSectionWidget | SectionWidget manages multiple instances of SectionContent. It displays a title TAB, which is clickable and will switch to the contents associated to the title when clicked |
| CSectionWidgetTabsScrollArea | Custom scrollable implementation for docked tabs using the NDEVR API Widget Docking system |
| CSelectionArea | An area of N-dimensional space that is considered selected |
| CSelectionButtonFactory | |
| CSelectionEffect | Applies certain effects to a model that has been selected |
| CSelectionHighlightBar | Provides a highlighted animation for selecting docked tabs using the NDEVR API Widget Docking system |
| ►CSelectionInfo | Responsible for turning a user interaction into a selection within a DesignObjectLookup |
| CClosestModelInfo | |
| CSelectionWidget | |
| ►CSerialConnectionDialog | A ConnectionDialog that allows the user to modify a Serial port connection |
| CSettings | |
| CSerialPortConnection | A ConnectionBackend that allows the software to interface with QSerialPort for communicating with SerialPort devices |
| CSerialPortConnectionDialogFactory | A ConnectionDialogFactory which enables the creation of a SerialConnectionDialog |
| CSerialPortConnectionFactory | A ConnectionFactory that enables the creation of a SerialPortConnection for interfacing with a QSerialPort |
| CSerialPortInfo | A structure containing information needed to establish a SerialPortConnection |
| CSet | Container that stores unique elements in no particular order, and which allow for fast retrieval or insertion of individual elements based on their value |
| CSetBase | A dummy base class for all Set templates |
| CSettingsDialog | The main Settings dialog for the application. Submenus can be added by the WindowManager or directly |
| CSH3DFactory | Writes to Sweet Home 3D file using the IOFactory interface |
| CShapeConstructors | Logic for writing various basic shapes to a Geometry object. Shapes will be appended to the end of the geometry |
| CShowPropertiesSettings | Stores settings for setting up and displaying a DesignObjectDialog such as whether the dialog is part of a larger workflow or used for Model creation |
| CSHPFactory | |
| CSizeOperationsWidget | A popup Editor dialog for showing options or information related to the size of a Model object |
| CSLAMEngine | Provides logic to perform SLAM on an object |
| CSLAMEngineFactory | Creates a SLAM engine when required |
| CSLAMEngineManager | Registers engines which can be used in the SLAM process |
| CSLAMFrame | A frame of data that can be processed by a SLAM engine to determine relative location |
| CSlicePlane | Represents a single plane to slice the data across |
| CSlicerArgs | Arguments for performing a Geometry slice operation |
| CSlicerOutputOptions | Simple in and out files used for Slicer Used with slicer IO operations |
| CSliceVertex | Stores an index to a particular vertex used with ConcaveToConvexPolygon. The Slice index is used with ConcavePolygon to break it into convex polygons or triangles |
| CSmoothDialog | A widget allowing the user to select options and execute smoothing a 3D mesh |
| CSmoothing | Contains basic logic to smooth 3D meshes |
| CSnapPoint | Contains information about a particular point of interest created from a user mouse interaction |
| CSnapsEditorWidget | |
| CSnapsManager | Manages which points are considered interesting based on defined criteria |
| CSocketConnection | A core ConnectionBackend for QAbstractSocket supporting TCP and UDP connections |
| CSocketConnectionFactory | A ConnectionFactory that enables the creation of a SocketConnection for interfacing with a QAbstractSocket |
| CSocketIO | Provides the ability to communicate over a network using SocketIO (https://socket.io/docs/v4/) |
| CSocketIOChannel | A specific channel of communication within the SocketIO framework |
| CSocketIOConnectionFactory | A ConnectionFactory that enables the creation of a SocketIODriver for interfacing with a SocketIO |
| CSocketIODriver | A ConnectionBackend that allows the software to interface with SocketIO for communicating with across networks |
| CSoftwareService | Software Services provide an interface for adding to or changing the software behavior via functionality added from modules |
| CSoftwareServiceManager | Software Service Managers take a Software service to modify the behavior of the software |
| CSolidMaterialEditor | A popup Editor dialog for showing options or information related to Materials used with solid rendering such as light reflectivity |
| CSortedLogViewTable | Sorts the logged entries in time-order |
| CSound | Contains the definition for a sound resource |
| CSoundFactory | Produces sound on the host Device, if possible. Can also create speech from given text |
| CSoundManager | Handles iterating through sound factories until one is able to produce sound given the input sound resource |
| CSpeedLimit | Used to describe the speed limit of a road and used with StreetInfo object |
| CSpline | A spline is a function used to interpolate or smooth data. Splines are a series of polynomials joined at knots |
| CSplineData | Logic for storing a spline data in a CAD-friendly way for exporting and importing |
| CStackTracer | Traces the stack to give the call-stack of a thrown exception |
| CStatementParser | Turns a particular string into an Equation The String should not contain invalid characters |
| CStationEditor | A popup Editor dialog for showing options or information related to StationModel objects |
| CStationOptions | Stores ApplicationOptions related to user preferences for Stations |
| CStatusBar | A simple widget that shows a Status and optionally a progressbar |
| CSTDOutputStream | A LogStream that writes to cout console |
| CStepsRecorder | If availabled, records user interactions using Windows Steps Recorder |
| CStreetInfo | Stores all information relating to a road or street |
| CStreetName | A Model which contains information about the name of a street, road, highway, etc |
| CString | The core String class for the NDEVR API |
| CStringSplitter | Logic for splitting a string into two |
| CStringStream | Logic for reading or writing to a string or a user friendly, TranslatedString |
| CStringValidator | Logic for validating a string given a specific regex |
| CStyleData | Logic for storing a style data in a CAD-friendly way for exporting and importing |
| CSubtitleFileReader | Class which can be used to read a subtitle file and return the subtitle that should be played at a specific time |
| CSubtitleFileWriter | Class which can be used to write a subtitle in real time to a file, which can be played back alongside a video being recorded concurrently |
| CSunDial | A decorated dial class that allows the user to set the lighting direction |
| CSurfaceCondition | Used to describe the condition of a surface for a StreetInfo object |
| CSurfaceType | Used to describe the type of surface for a StreetInfo object |
| CSVD | Performs the singular value decomposition of a general matrix, taken and adapted from Numerical Recipes Third Edition svd.h |
| CSVGIconEngine | Allows the NDEVR engine to process and display SVG icons within the UI |
| CTable | Provides access to a set of named columns all with the same number of rows. Columns can also be floating, meaning they do not share the same number of rows as the table, but can still be accessed |
| CTableChange | Records changes to a table or column noting the bounds of the data adjusted. Useful for optimized saving or mirroring of data |
| CTableColumn | A virtual storage type that is used with Table class to store data where the actual mechanism for storage can be abstracted away |
| CTableColumnBuffer | A base class for a Table column with N-number of rows held in a Buffer object. Allows for virtual memory access with the caller not needing to know how the data itself is stored |
| CTableColumnColorType | A TableColumnBuffer of Colors Allows for virtual memory access with the caller not needing to know how the data itself is stored |
| CTableColumnString | A TableColumnBuffer of Strings Allows for virtual memory access with the caller not needing to know how the data itself is stored |
| CTableColumnTypeBuffer | A TableColumnBuffer of buffers. Meaning each row has some potentially unique N-number of columns Allows for virtual memory access with the caller not needing to know how the data itself is stored |
| CTableMatrixType | A TableColumnBuffer column of Matrices Allows for virtual memory access with the caller not needing to know how the data itself is stored |
| CTableType | A Table that can create columns of specific types |
| CTableVectorType | A TableColumnBuffer that also has some number of defined rows stored in a Vector object Allows for virtual memory access with the caller not needing to know how the data itself is stored |
| CTableVectorType< 1, t_type > | An obtimized single column TableVectorType that stores data in a simple buffer Allows for virtual memory access with the caller not needing to know how the data itself is stored |
| CTableVectorType< 1, UUID > | A TableVectorType optimized for storing UUID objects Allows for virtual memory access with the caller not needing to know how the data itself is stored |
| CTcpServer | A TcpServer allows the software to recieve socket connections from external sources |
| CTemperatureSensor | A Device responsible for determining the temperature of either the environment or a specific component. Temperatures may have warning limits to alert the user at critical points |
| CTemperatureWidget | A button that displays information about multiple TemperatureSensors when clicked. Button changes color based on the status of specified TemperatureSensor objects |
| CTerminalDialog | Provides the user access to sending or recieving data to a specified connection over a terminal interface |
| CTextBlock | Text that is formatted the same way, typically part of a bigger group of text |
| CTextData | Logic for storing a text data in a CAD-friendly way for exporting and importing |
| CTextToSpeechRequest | Allows the user to make a request for text-to-speech. If the speech cannot be produced, the backup sound is played |
| CThemeChanger | An animation that slowly changes the color over the entire UI |
| CThread | A thread is a single sequence stream within the software |
| CThreadFunctions | Functions for interfacing with the current thread. If threading is disabled |
| CThreadQueue | Executes a queue of commands in a single thread |
| CThreePartAngleUnit | An angle unit that contains two-parts (Degrees, Minutes, Seconds) |
| CTightDecoder | Decodes a VNC stream from TightVNC |
| CTime | Represents a timestamp with utilities for manipulation and conversion |
| CTimeRequest | A request to get the time from the network |
| CTimeSpan | Stores a time span, or difference between two times, with an optional start time |
| CTimeZone | Simple struct for storing timezone definition data |
| CTimeZoneManager | Converts TimeZone data |
| CToggle | A Button that toggles between on and off. In desktop mode this looks like a checkbox and in touch mode has a distinct look and feel |
| CToolbar | Class which displays progress and the current action being performed. Typically shown at the bottom of a view, or at the top with the ribbon |
| CTooltipTextManager | Provides common tooltips for usage with the software |
| CTopDownLineworkChart | Creates an NDEVRRadialChart chart for models containing linework |
| CTouchDesktopThemeButton | A button for allowing the user to switch between Desktop/Touch mode which affects the size of all of the widgets and text |
| CTouchScrollManager | Provides behavior for flicking and other scroll behavior common to the NDEVR API |
| CTraceData | Logic for storing a trace data in a CAD-friendly way for exporting and importing |
| CTranslatedString | Any text displayed to the user should be defined as a TranslatedString which allows the program to look up a translation, if available |
| CTranslationCombo | Provides possible translations via a combobox to allow the user to select a language for the software |
| CTranslator | Contains logic for translating a string into a defined language |
| CTriangle | A triangle is a polygon with three edges and three vertices. It is one of the basic shapes in geometry. This triangle with vertices A, B, and C is which can be accessed using vertex(...) |
| CTriangleBase | Base class for N-dimensional triangles |
| CTriangleIterator | A class to easily iterate each triangle over a Geometry of triangles or meshes |
| CTroubleshootingDialog | |
| CTwoPartAngleUnit | An angle unit that contains two-parts (Degrees, Minutes) |
| CTwoPartUnit | A unit that has two parts (Think feet, inches) |
| CTwoSidedCSFFilter | Filters data into a top and bottom half based on the CSF surfacing logic |
| CTypeInfo | Stores information about a type, relevant for certain templated functions. To get information about a type at runtime use ObjectInfo |
| CTypeInfoRegex | Logic for creating a regex for a given type of data |
| CUnit | A definition of how to describe and display data. Units can be of any type |
| CUnitDefinitions | Returns common and uncommon definitions of units that can be used by the software |
| CUnitManager | Handles a grouping of units that can describe any number of data categories |
| CUnitOption | A definition of how to describe a particular set of data to a custom category of unit |
| CUnitsDialog | A dialog which can be used to set various units for different unit categories, such as selecting the various properties by which to show angles |
| CUpdateButton | A button which allows the user to check for software updates or update the software |
| CUpdateChecker | Provides logic for checking a source, typically online, for an update to the software |
| CUpdateCheckManager | Provides place to set an update checker for checking for software updates |
| CUTF8Iterator | Iterates over a UTF8 encoded string and returns the values as UTF16 |
| CUUID | A universally unique identifier (UUID) is a 128-bit number used to identify information in computer systems. The term globally unique identifier (GUID) is also used |
| CUVChannelEditWidget | A widget allowing the user to set the properties for a single channel of UVType for a Material |
| CVariableReference | An optimized class for storing a reference to a variable of some type up to 8 bytes in size without ownership or allocations on the stack |
| CVector | A fixed-size array with better performance compared to dynamic containers |
| CVector< t_dims, bool > | An boolean specifc Vector which stores vectors of bools in optimal space. t_dims: The number of dimensions used in a vector |
| CVectorFunctions | Dummy class to include functions related to vector math |
| CVectorizeImageParams | Arguments used for creating vectorizations of an image |
| CVehicleDatabase | |
| CVehicleModel | |
| CVehicleRecord | |
| CVehicleSearchItem | |
| CVehicleSelector | |
| CVehicleTableFilterProxyModel | |
| CVehicleTableModel | |
| CVehicleTableView | |
| CVertex | A vertex or point. A specific type of Vector used primarily for spacial location information |
| CVertexColorIterator | Allows for the calculation of colors for any vertex given a Material and Geometry |
| CVertexIterator | A class to easily iterate each vertex of a Geometry |
| CVertexTable | A table showing a list of vertices in a Geometry objects |
| CVertexTableDelegate | A Qt compatible ItemDelegate for showing properties around a Geometry Vertex object |
| CVideoCardInformation | Contains information about a video card, including manufacturer and some level of capabilities |
| CViewportData | Logic for storing a viewport in a CAD-friendly way for exporting and importing |
| CViewportFactory | A service which can generate Viewports based on Camera data |
| CViewportFormat | Stores information for how to construct a viewport |
| CViewportLayout | Stores information for how to construct a group of viewports such as those in the center 3D panel |
| CViewportOptions | Stores the options, added to the user settings, that control Viewport and camera options in the application. All options retained across application restart |
| CVirtualCameraView | A Viewport for rendering 3D objects in the scene with the NDEVR Graphics Engine. Users interact with this view via the ContextMenuCallback and MouseController. A QTGraphicsWindow renders the content |
| CVisibleCommand | A specified type of DesignCommand that can make objects visible or invisible in a 3D space such as a viewport |
| CVncCameraView | |
| CVncClientWidget | |
| CVncDevice | |
| CVncScreen | |
| CVulkanBitflagObject | Stores bools to be sent to both the Vertex and Fragment shaders in the Vulkan space |
| CVulkanBuffer | Stores bools to be sent to both the Vertex and Fragment shaders in the Vulkan space |
| CVulkanCameraManager | A structure for managing Viewport interactions with in the Vulkan Graphics Space |
| CVulkanCameraViewFactory | Provides the interface for automatically creating VulkanGraphicsWindow when the request for a VirtualCameraView is sent through |
| CVulkanDevice | A GraphicsDevice for managing Vulkan limitations and actions. See: https://docs.vulkan.org/spec/latest/chapters/devsandqueues.html |
| CVulkanGraphicsWindow | A QTGraphicsWindow for rendering using Vulkan |
| CVulkanImageData | A pointer to an Image and functions relating to that image within the Vulkan logic space |
| CVulkanImageManager | Manages all images within the Vulkan space |
| CVulkanImageResources | Data for pointing to a specific Image target within the Vulkan Graphics space |
| CVulkanImageView | Manages a view within the Vulkan logic space. See: https://vulkan-tutorial.com/Drawing_a_triangle/Presentation/Image_views |
| CVulkanInstance | The connection between the NDEVR API and the Vulkan library. See: https://vulkan-tutorial.com/Drawing_a_triangle/Setup/Instance Creating this connection involves specifying some details about NDEVR library to the driver |
| CVulkanMaterialManager | Logic for creating the data in Vulkan for a specific Material |
| CVulkanQueue | A wrapper around a VulkanQueueCore that allows for thread-safe access to a specific queue |
| CVulkanQueueCore | A queue of commands or actions to be executed in order by the Vulkan engine |
| CVulkanRenderDefinition | Creates specific information for performing a render pass within Vulkan |
| ►CVulkanRenderObject | A root render Object for Vulkan, which consists of a set Material, Model, and Geometry that is used together to optimally create a 3D render |
| CGeoProperties | |
| CModelProperties | |
| ►CVulkanRenderPipeline | A GraphicsPipeline that renders a single Viewport for Vulkan |
| CFrameResources | |
| CSwapChainSupportDetails | |
| CVulkanSession | Creates and manages the resources necessary for converting a DesignObjectLookup into 3D rendered data in the Vulkan engine |
| CVulkanShader | A shader program used to render data in Vulkan |
| CVulkanShaderManager | Manages all active shaders in a VulkanSession |
| CVulkanVertexManager | Manages all vertices in a specific Scene object for interfacing with Vulkan |
| CVulkanVertexUniformObject | Information sent to the Vertex shader as a Uniform object |
| CVulkanXRDevice | A GraphicsDevice for managing OpenXR and Vulkan limitations and actions. See VulkanDevice |
| CVulkanXRInstance | He connection between the NDEVR API and the OpenXR library, using Vulkan as the engine backend |
| CWDesignLock | Used to lock a particular model for editing (DEPRECIATED) |
| CWebMercatorTile | A "Tile" containing data for |
| CWebMercatorTileService | A wrapper for logic that uses a web engine to provide an Image Tile service |
| CWebSocketConnection | A ConnectionBackend that allows the software to interface with QWebSocket for communicating with WebSocket devices |
| CWebSocketConnectionDialog | A ConnectionDialog that allows the user to modify a WebSocketConnection |
| CWebSocketConnectionDialogFactory | A ConnectionDialogFactory which allows for the creation of a WebSocketConnectionDialog |
| CWebSocketConnectionFactory | A ConnectionFactory that enables the creation of a WebSocketConnection for interfacing with a QWebSocket |
| CWebTarget | A url target and optional username and password for a network request |
| CWidgetInit | Provides a way to lazily initialize widgets when needed but still pass them to container dialogs. Useful for adding things to Settings dialogs or other large structures where they may never be initialized |
| CWidgetInitialization | The primary logic for initializing an application within the NDEVR engine by calling module functions in the appropriate order and initializing any common resources or services |
| CWidgetIterator | Provides a way to iterate over a series of widgets, useful for printing dialogs or turning Widgets into reports or PDF files |
| CWidgetOptions | Stores the options, added to the user settings, that control Widgets and low level UI options in the application. All options retained across application restart |
| CWinchDeploymentDialog | |
| CWindowContainer | A (hacky) class for storing a window into a container. This is used if the rendering engine for a particular widget is different from the one used by the application. The hackiness comes from Qt's limited support for this functionality which results in the need to hack around the errors in Qt's core library |
| CWindowManager | Manages all windows and logic surrounding dialogs and views for displaying and managing any environment within the application |
| CWindowOptions | Stores the options, added to the user settings, that control Window and high level UI options in the application. All options retained across application restart |
| CWLock | Used to lock a particular variable for writing. Only one write lock can be created when no read locks are on a variable, otherwise will wait |
| CXDataWriter | |
| CXLSXKeyPointMagneticAngleReading | The structure used by the library for storing key points of data used to write to a MagneticCalibrationSpreadsheet |
| CXLSXMagneticAngleAverageReading | The structure used by the library for storing averaged points of data used to write to a MagneticCalibrationSpreadsheet |
| CXLSXMagneticAngleReading | The structure used for storing data to write to a MagneticCalibrationSpreadsheet |
| CXRCameraView | A view that allows interfacing with OpenXR for Augmented and virtual reality |
| CXRFunctions | Common helper functions for easier interfacing with the OpenXR engine |
| CXRHand | Support for a virtual hand, typically mirroring a user hand in the OpenXR space |
| CXRInputManager | Translates input from the OpenXR interface into NDEVR API actions and events |
| CXRManager | Manages the OpenXR engine at a high level |
| CXRPose | A matrix-like class storing both offset and orientation |
| CXRSide | OpenXR uses two viewports, one for the left eye and one for the right eye |
| CXRVulkanPipeline | A GraphicsPipeline that renders a single Viewport for Vulkan and OpenXR. See VulkanRenderPipeline |
| CXYZColor | In opposition to the previous models, the CIE XYZ model defines an absolute color space. It is also known as the CIE 1931 XYZ color space and stands for: X, which can be compared to red Ranges from 0 to 0.9505 Y, which can be compared to green Ranges from 0 to 1.0 |
| CZippedRadialMeshOptions | Logic for setting up a mesh that is broken apart by latitude and longitude lines with a set angle difference between them |
| CZlibInStream | |
