|
Class |
Description |
|---|
 AcPlDSDData |
This utility class reads and writes DSD files. It holds an array of AcPlDSDEntry objects in addition to DSD sheet set information. |
| AcPlDSDEntry |
This container class holds information specific to a sheet (in a sheet set). AcPlDSDData holds a collection of AcPlDSDEntry objects to configure a publish job. |
| AcPlHostAppServices |
This class defines an interface that plot host applications must implement to provide basic plotting services at runtime. Applications derive from this interface and provide an implementation of the methods listed. |
| AcPlObject |
This class is a base class from which other client-instantiable plot API classes derive. It provides boilerplate implementation for runtime type casting, memory allocation, and other internal capabilities. Applications should not derive directly from this class. |
| AcPlPlotConfig |
Instances of this class represent a single device or PC3 file installed on the system. AcPlPlotConfig exposes utility methods for media size list, description fields, paper size matching, custom paper size creation, and persistence. |
| AcPlPlotConfigInfo |
This is a lightweight class containing information about a device. A collection of AcPlPlotConfigInfo objects is returned by AcPlPlotConfigManager::getDevicesList(). |
| AcPlPlotConfigManager |
This class exposes access to plot configurations, plot style tables, devices, and PC3 files available on the system. This class is a singleton with a global method that returns a global instance of the object. |
| AcPlPlotEngine |
Applications use an AcPlPlotEngine interface to plot one or more documents to a device or a file, to collect plot information for a background plot, or to preview the plot of a single page. Engine instances are returned by methods on the AcPlPlotFactory class. Only one engine object can exist at a time, so applications should create engine instances just before they are needed, operate on them, and destroy them (by calling destroy()) as soon as they are no longer needed. Engines have a notion of state, and they move between states via nested begin and end calls. The... more |
| AcPlPlotErrorHandler |
This interface class exposes error-handling capabilities to client applications. The host application provides a stock error handler that is always present and is used by the hardcopy subsystem if no application error handler is provided. Applications can derive from this class to handle errors fired by the plotting subsystem. Any error not handled is passed up the error handler chain until it is handled.The AutoCAD hardcopy subsystem uses a chain of error handlers derived from a common class. The AutoCAD application error handler is at the end of this chain. It handles errors that can cause AutoCAD to terminate,... more |
| AcPlPlotErrorHandlerLock |
The AcPlPlotErrorHandlerLock class facilitates locking of the application error handler inserted into the plot configuration manager's error handler chain. The design allows only one application-provided error handler to be inserted in the chain a time. The lock class provides a mechanism for ensuring that applications do not step on each other's error handlers. It also removes error handlers from the chain when the lock is destroyed or released. |
| AcPlPlotFactory |
The AcPlPlotFactory class creates plot engines for use by applications. Only one engine can exist at a time, so applications should create engines just before they are needed and destroy them (by calling AcPlPlotEngine::destroy()) when they are no longer needed. |
| AcPlPlotInfo | AcPlPlotInfo is a utility class that provides methods for building information about how and what to plot and, ultimately, acts as a vehicle to transport this information to the plotting pipeline. Applications must provide the object ID of the layout to be plotted to this object before passing it to an AcPlPlotEngine object for processing. Applications can provide overrides, in the form of an AcDbPlotSettings object, to be used for plotting the layout in place of the settings on the layout itself. Applications can also override the output device by providing an AcPlPlotConfig object designating the device to plot to.... more |
| AcPlPlotInfoValidator |
The AcPlPlotInfoValidator class merges plot settings from a layout object, an AcDbPlotSettings object (settings overrides), and an output device override into a new plot settings object. The validator returns a set of codes indicating any problems found during the merge operation.The validator supports paper-matching policies in its validation algorithmn. Depending on the setting of the policy, the validator may try to find a matching paper size if the canonical paper name provided in the layout or overrides does not exist on the device. The validator also has policies to create a custom paper size, if possible, in case the... more |
| AcPlPlotLogger |
This class is used by the application to journal the normal progress of a plot job. This class also receives notification of errors and warnings, along with their message content, from the AcPlPlotLoggingErrorHandler class.The default AcPlPlotLogger service can be acquired from AcPlHostAppServices::getPlotLogger().It is the responsibility of the plotting application to call startJob(), startSheet(), endSheet(), and endJob() explicitly. |
| AcPlPlotLoggingErrorHandler |
This class is a specialization of the AcPlPlotErrorHandler class that performs logging operations using an AcPlPlotLogger interface. In all other respects, this class behaves exactly the same as the AcPlPlotErrorHandler class. |
| AcPlPlotPageInfo |
Returns information about the objects contained on a plotted page. Applications can use this information as a starting point for estimating the time required to plot the page (or, more precisely, to determine whether to warn the user that the page will take a long time to plot). An object of this type is returned by the AcPlPlotEngine::startPage() method. |
| AcPlPlotProgress |
The AcPlPlotProgress interface defines the behaviors that a plot progress dialog must implement. Applications can derive from this class or instantiate a default implementation of a plot progress dialog using acplCreatePlotProgressDialog(). Applications pass the dialog to the AcPlPlotEngine, which manages the dialog during the plotting operation. |
| AcPlPlotProgressDialog |
This class implements a default plot progress dialog supplied as part of the ObjectARX SDK. Applications can instantiate an instance of this class for their own use when plotting by calling acplCreatePlotProgressDialog(). |
| AcPlPlotReactor |
Applications derive from this class in order to be notified when AutoCAD or other applications perform plotting operations using an AcPlPlotEngine. Applications must instantiate their derived class and add it to the reactor list using the AcPlPlotReactorMgr::addReactor() method. Then AutoCAD will notify the reactor when an operation is performed by calling the corresponding method on the reactor. |
| AcPlPlotReactorMgr |
This class manages a list of AcPlPlotReactor instances and provides methods for applications to add and remove reactor instances from the list. Applications do not instantiate this class, but can access the global AcPlPlotReactorMgr instance using the acplPlotReactorMgrPtr() global function. |
