| _NEW_DOCINFOA | |
| _NEW_DOCINFOW | |
| ABC | |
| ABFXBayerColour | |
| ABFXBayerMono | |
| ABFXBrightnessContrast | |
| ABFXDiffusionColour | |
| ABFXDiffusionMono | |
| ABFXFlipX | |
| ABFXFlipY | |
| ABFXHalftoneMono | |
| ABFXMakeGreyscale | |
| ABFXOctree | |
| ABFXPopularityColour | |
| ABFXRemoveDither | |
| ABFXResize | |
| ABFXRotate180 | |
| ABFXRotate270 | |
| ABFXRotate90 | |
| ABFXSharpenBlur | |
| ABFXSpecialEffect | |
| AboutDlg | The about dialogue shows information on the Camelot program version number and details on the environment in which Camelot is executing |
| AbstractTextChar | This is the base class for all VisibleTextNodes which have an associated Unicode character |
| AccusoftBitmapEffect | Base class for all accusoft bitmap effects |
| AccusoftBMPOILFilter | Provide the OIL parts of the Accusoft BMP filter |
| AccusoftOILFilter | Provide the OIL parts of the Accusoft filters |
| AcornDrawFilter | Encapsulates an RISC OS Draw input filter system |
| Action | This class represents an Action which is an individual job which is executed to accomplish an operation. An operation contains lists of actions to perform Undo, Redo and Smart Duplication |
| ActionApplyPlugInToBitmap | When executed, this sets up an action to redo/undo an apply a plug-in to a bitmap |
| ActionColourChange | When executed, this copies the IndexedColour 'Defn' over the top of the IndexedColour 'Target', so that Target is redefined. This is used to undo/redo colour edits. A flag 'ChangeIsinvisible' is used to tell whether to broadcast a ColourChangingMsg COLOURUPDATED or COLOURUPDATEDINVISIBLE when the change is applied |
| ActionHideColours | When executed, sets/clears an IndexedColour's 'deleted' flag, so that it becomes {un}hidden - this is then un/redoable by using a HideAction with the opposite 'HideFlag' value |
| ActionList | An ActionList is a list object which holds actions which can be executed. It is used by Operation objects to hold UNDO, REDO and Smart duplicate actions |
| ActionPageResize | When executed, this sets up an action to redo/undo a page resize |
| ActionSetDefaultGrid | When executed, this sets up an action to redo/undo a default grid resize |
| ActiveDlgStateItem | Stored on an ActiveDlgStateStack. See this class for a definition of its purpose |
| ActiveDlgStateStack | An ActiveDlgStateStack holds ActiveDlgStateItems. Whenever a MODAL dialog is closed we will need to restore the previously active window. What's more if the previously active window is a MODAL dialog , then we must disable the mainframe and other popups owned by the mainframe; so that the dialog continues to behave modally. This stack stores this information |
| AdditionalVirtKey | Used to store 'additional' known virtual key codes so the range of handled keys can be extended at runtime |
| AddPressurePointsAction | An action which adds points to the Pressure list of a BrushAttValue |
| AddTimeStampPointsAction | An action which adds points to the timestamping list of a BrushAttValue |
| AddWebFoldersParam | |
| AdobeColourSwatchFilter | Adobe Colour Swatch palette filter |
| AdobeColourSwatchOILFilter | Provide the OIL parts of the Adobe Colour Swatch file filter |
| AdobeColourTableFilter | Adobe Colour Table palette filter |
| AdobeColourTableOILFilter | Provide the OIL parts of the Adobe Colour Table file filter |
| AI5EPSFilter | A filter that imports EPS files in Adobe Illustrator 7.0 EPS format |
| AI5EPSOILFilter | Provide the OIL parts of the Illustrator 5.0 EPS filter |
| AI5Gradient | Used to hold the definition of an Illustrator 5 gradient fill, while we are importing an AI5 file |
| AI8EPSFilter | Allows us to import Adobe Illustrator 8.0 files. (at the time of writing only the version 7.0 documentation was available so some omissions are inevitable) |
| AI8EPSOILFilter | Provide the OIL parts of the Illustrator 8.0 EPS filter |
| AIBitmapProcessor | Helps with the import of Adobe Illustrator 8.0 files. (at the time of writing only the version 7.0 documentation was available so some omissions are inevitable). It creates a list of bitmaps from the input stream |
| AIEPSFilter | A filter that imports EPS files in Adobe Illustrator EPS format |
| AIEPSGradientScanRenderRegion | RenderRegion used to scan through the tree, looking for gradient fills to be cached for Illustrator export |
| AIEPSOILFilter | Provide the OIL parts of the Illustrator EPS filter |
| AIEPSRenderRegion | A render region for exporting EPS files in Adobe Illustrator 7.0 EPS format |
| AIGradientProcessor | Helps with the import of Adobe Illustrator 8.0 files. (at the time of writing only the version 7.0 documentation was available so some omissions are inevitable). It creates a list gradient fills and allows the filter to extract them |
| AIHighlight | Helps with the import of Adobe Illustrator 8.0 files. Holds the definition of a highlight to be used in subsequent fills. (not interpreted at present) |
| AILayerProcessor | Helps with the import of an Adobe Illustrator layer. These are defined by a pair of instructions: |
| AldusFormatOILFilter | Provide the OIL parts of the Aldus-format filter |
| AlignParam | |
| Allocator< T > | |
| Allocator< void > | |
| AllowOpScan | Performs an AllowOp test and update on all the objects which are members of highlighted 'Used Name' items in the Attribute gallery; performs the same, but only on members of a specified set. Notes: The present implementation is not reentrant or thread-safe |
| AllowOpScan::IsLitUsedName | |
| AllowOpSingleScan | |
| AluPix32 | |
| AnimatedBitmapItem | Saves out the list of bitmaps currently in the animation sequence |
| AnimatedGIFImage | Stores details on the GIF image which is part of an export animation sequence |
| AnimationColoursTab | Allows the user to set various Animation Colours |
| AnimationPropertiesTab | Allows the user to set various Animation properties |
| AnimExOptns | Invokes the Animation Export Options dialog. This is a two tab form of the GIFAnimationPropertyTabsDlg. The two tabs present are:- Animation colours and the animation properties |
| AnimPropertiesParam | Allows the transfer of data from our Frame Gallery to a current spread object |
| Application | Represents an instance of the Camelot application |
| AppliedAttribute | At the moment it allows applied attributes to appear in a list, but will probably supersede the MultiCommonAttrItem class |
| ApplyAction | When executed this action will show a node. It will also generate a HideNodeAction action adding it to the opposite Action list |
| ApplyAttribsToSelectedParam | Parameters for the OpApplyAttribsToSelected operation. See OpApplyAttribsToSelected::DoWithParam for a description |
| ApplyPropScan | |
| ApplyScan | Applies all the highlighted 'Used Name' items in the Attribute gallery to all the selected objects (if they don't already have them); a single name to all the selected objects if they don't already have it; 'applies' a NodeSetProperty for a set, with default SGNameProps, to the NodeSetSentinel |
| ApplyScan::ApplyItems | |
| ApplySingleScan | |
| AppPrefsDlg | |
| ArrangeAlignment | Align object dialog |
| ArrowRec | A class defining a Line ArrowHead Record |
| ArtWorksEPSFilter | A filter that imports EPS files in ArtWorks EPS format |
| ArtWorksEPSOILFilter | Provide the OIL parts of the ArtWorks EPS filter |
| ArtWorksEPSRenderRegion | A render region for exporting ArtWorks EPS format files |
| async_fstream | Converts fstream to use an async_filebuf |
| AsynchBitmapImportParam | |
| AsynchClipartImportParam | |
| AsynchDownload | Asynchronous download class - downloads a url to a local file using HTTP Used by the download manager |
| AsynchDownload::AsynchBindStatusCallback | |
| asynchstreambuf | Asynch version of streambuf It is assumed that two versions of the file will be open i.e. read and write. The read and write will run in seperate threads. Any access to the file that might fail due to lack of data will cause the read thread to sleep until more data is available. It is assumed that the write thread will never seek - this would corrupt the BytesAvailable count |
| ATMFont | A class description of our ATM fonts. Mainly uses all base class functions at the moment, apart from the type |
| ATMFontMan | A static class to allow access to Type 1 fonts. There are few functions in this class which should be called directly. The OILFontMan provides the generic interface of font calls within this application |
| AtomicTagList | Keeps a list of all the atomic tags present in the imported file |
| AtomicTagListItem | An item that appears in the AtomicTagList |
| AttrBevel | Base class for bevel attributes |
| AttrBevelContrast | Bevel indent attribute |
| AttrBevelIndent | Bevel indent attribute |
| AttrBevelLightAngle | Bevel indent attribute |
| AttrBevelLightTilt | Bevel indent attribute |
| AttrBevelType | Bevel indent attribute |
| AttrBitmapChange | Change Bitmap Attribute class. This Attribute never exists in the Tree. It is used for changing a Bitmap Fill |
| AttrBitmapColourFill | Bitmap Graduated Colour Fill Attribute class |
| AttrBitmapDpiChange | Change Fill Transp Type Attribute class. This Attribute never exists in the Tree. It is used for changing the Transp type of an existing Fill Geometry |
| AttrBitmapFill | Bitmap Fill Attribute class |
| AttrBitmapTessChange | Change Fill Transp Type Attribute class. This Attribute never exists in the Tree. It is used for changing the Transp type of an existing Fill Geometry |
| AttrBitmapTranspFill | Bitmap Graduated Colour Fill Attribute class |
| AttrBrushType | BrushType attribute BrushType attributes are very simple, and merely contain a BrushTypeAttrValue, which is the entity which holds all the info and does all the work |
| AttrChangedMsg | This message is sent whenever an attribute changes in some way. It is used to update the Grad Fill Info Bar |
| AttrCircularColourFill | Radial Graduated Fill Attribute class |
| AttrCircularTranspFill | Radial Graduated Fill Attribute class |
| AttrClipView | |
| AttrColFillRampChange | An attribute to control the changes of colour on a fill ramp |
| AttrColourChange | Change Fill colour Attribute class. This Attribute never exists in the Tree. It is used for changing the colours of an existing Fill Geometry |
| AttrColourDrop | 'Drop a colour on an object' Attribute class. This Attribute never exists in the Tree. It is used for changing the colours of an existing Fill Geometry |
| AttrConicalColourFill | Conical Graduated Colour Fill Attribute class |
| AttrConicalFill | Conical Fill Attribute class |
| AttrConicalTranspFill | Conical Graduated Transparency Fill Attribute class |
| AttrDashPattern | Dash Pattern Attribute class |
| AttrdCharBoundsCacheEntry | Get the bounds of a char specified by the char descriptor at default size |
| AttrEndArrow | End Arrow Attribute class |
| AttrFeather | |
| AttrFillEffect | Fill effect Attribute class |
| AttrFillEffectAltRainbow | Alternate Rainbow (HSV) fill effect Attribute class |
| AttrFillEffectFade | RGB Fade fill effect Attribute class |
| AttrFillEffectRainbow | Rainbow (HSV) fill effect Attribute class |
| AttrFillGeometry | Fill Geometry Attribute class |
| AttrFillMapping | Fractal Transparency Fill Attribute class. Fill mapping Attribute class |
| AttrFillMappingLinear | Linear fill mapping Attribute class |
| AttrFillMappingSin | Sinusoidal fill mapping class Attribute class |
| AttrFlatColourFill | Flat Colour Fill Attribute class |
| AttrFlatFill | Flat Fill colour Attribute class |
| AttrFlatTranspFill | Flat Transparency Fill Attribute class |
| AttrFourColColourFill | FourCol Graduated Colour Fill Attribute class |
| AttrFourColFill | FourCol Graduated Fill Attribute class |
| AttrFourColTranspFill | Four point graduated transparency Fill Attribute class |
| AttrFractalChange | Change Fractal Attribute class. This Attribute never exists in the Tree. It is used for changing a Fractal Fill |
| AttrFractalColourFill | Fractal Colour Fill Attribute class |
| AttrFractalFill | Fractal Fill Attribute class |
| AttrFractalGrainChange | Change Fill Transp Type Attribute class. This Attribute never exists in the Tree. It is used for changing the Transp type of an existing Fill Geometry |
| AttrFractalTileableChange | Change Fractal Tileable Attribute class. This Attribute never exists in the Tree. It is used for changing the Transp type of an existing Fill Geometry |
| AttrFractalTranspFill | Fractal Transparency Fill Attribute class |
| AttributeAgglomerator | An AttributeAgglomerator finds the Common Attributes among the nodes provided by an RenderableNodeEnumerator. This allows us to derive classes to retrieve more specialized attributes, namely AttrUser's. Notes: This code was copied from Range. It should either replace the code there or be thrown out when plug-in attributes are supported |
| AttributeEntry | |
| AttributeGroup | The current attribute group object consists of a group identifier, and a list of attribute nodes which belong to the group. It is used by the AttributeManager |
| AttributeGroupItem | AttributeGroupItem |
| AttributeManager | The attribute manager is currently responsible for managing the application of current attributes. It contains a list of Attribute groups along with instances of current attributes which belong to each group. An attribute group is identified by the RuntimeClass of an object |
| AttributeRec | Encapsulates an item in the RenderStack class |
| AttributeValue | To encapsulate rendering attributes. Derivations of NodeAttribute will hold an instance of this class (or derivation of it) to store the attribute information - this instance field should always be called 'Value'. An AttributeValue object is capable of being pushed onto and popped off the render context stack, and being rendered. This is accomplished by using virtual functions to perform these operations |
| AttrImagesetting | Base class from which all imagesetting attributes are derived |
| AttrJoinType | JoinType Attribute class |
| AttrLinearColourFill | Linear Graduated Colour Fill Attribute class |
| AttrLinearFill | Linear Graduated Fill Attribute class |
| AttrLinearTranspFill | Linear Graduated Transparency Fill Attribute class |
| AttrLineWidth | Line Width Attribute class |
| AttrMakeFlatTransp | Force object to be 50% transparent This Attribute never exists in the Tree. It is used for changing the Transp of an existing Fill Geometry |
| AttrMitreLimit | Mitre Limit Attribute class |
| AttrMould | Mould Attribute class |
| AttrNoiseColourFill | Noisy colour Fill Attribute class |
| AttrNoiseScaleChange | Change Noise fill class This Attribute never exists in the Tree. It is used for changing a Noise fill |
| AttrNoiseTranspFill | Noisy transparent Fill Attribute class |
| AttrOverprintFill | Attribute indicating if overprint-Fill is enabled or disabled |
| AttrOverprintLine | Attribute indicating if overprint-line is enabled or disabled |
| AttrPrintOnAllPlates | Attribute indicating if "print on all plates" is enabled or disabled |
| AttrQuality | Quality NodeAttribute class |
| AttrRadialColourFill | Radial Graduated Colour Fill Attribute class |
| AttrRadialFill | Radial Graduated Fill Attribute class |
| AttrRadialTranspFill | Radial Graduated Transp Fill Attribute class |
| AttrRecordItem | Used to record the state of an AttributeEntry array |
| AttrRecordList | Used to store a stack of AttributeEntry states. Used by filters that need to keep an attribute state stack (eg the RTF filter) |
| AttrRemoveStrokeTransp | Removes the transparency from objects. This Attribute never exists in the Tree. It is used for changing the Transp of an existing Fill Geometry |
| AttrRemoveTransp | Removes the transparency from objects. This Attribute never exists in the Tree. It is used for changing the Transp of an existing Fill Geometry |
| AttrSquareColourFill | Square Graduated Colour Fill Attribute class |
| AttrSquareFill | Square Graduated Fill Attribute class |
| AttrSquareTranspFill | Square Graduated Transparency Fill Attribute class |
| AttrStartArrow | Start Arrow Attribute class |
| AttrStartCap | Start Cap Attribute class |
| AttrStrokeColour | Stroke Colour Attribute class |
| AttrStrokeColourChange | Change Stroke colour Attribute class. This Attribute never exists in the Tree. It is used for changing the colours of an existing Stroke |
| AttrStrokeTransp | Stroke Transparency Attribute class |
| AttrStrokeTranspChange | Change Stroke transparency Attribute class. This Attribute never exists in the Tree. It is used for changing the transp of an existing Stroke |
| AttrStrokeTranspTypeChange | Change Stroke transparency Attribute class. This Attribute never exists in the Tree. It is used for changing the transp of an existing Stroke |
| AttrStrokeType | StrokeType attribute StrokeType attributes are very simple, and merely contain a StrokeTypeAttrValue, which is the entity which holds all the info and does all the work |
| AttrTextureColourFill | Texture fill attribute class. Acts as a base class for common code used by texture fills such as FractalColourFill and NoiseColourFill DO NOT INSTATIATE AN OBJECT OF THIS TYPE! |
| AttrTextureTranspFill | Fractal Colour Fill Attribute class. Transparency base class for textures |
| AttrThreeColColourFill | ThreeCol Graduated Colour Fill Attribute class |
| AttrThreeColFill | ThreeCol Graduated Fill Attribute class |
| AttrThreeColTranspFill | ThreeCol Graduated Transparency Fill Attribute class |
| AttrTranspChange | Change Fill colour Attribute class. This Attribute never exists in the Tree. It is used for changing the Transp of an existing Fill Geometry |
| AttrTranspFillGeometry |
|
| AttrTranspFillMapping | Fill mapping Attribute class |
| AttrTranspFillMappingLinear | Linear fill mapping Attribute class |
| AttrTranspFillMappingSin | Sinusoidal fill mapping class Attribute class |
| AttrTranspFillRampChange | An attribute to control the changes of transparency on a fill ramp |
| AttrTranspTypeChange | Change Fill Transp Type Attribute class. This Attribute never exists in the Tree. It is used for changing the Transp type of an existing Fill Geometry |
| AttrTxtAspectRatio | AttrTxtAspectRatio specifies the aspect ratio of text |
| AttrTxtBase | AttrTxtBase is the base class from which all text attribute nodes are derived |
| AttrTxtBaseLine | AttrTxtBaseLine: specifies an absolute offset from the base-line |
| AttrTxtBold | AttrTxtBold specifies if text is bold or not |
| AttrTxtFirstIndent | AttrTxtFirstIndent: specifies the first line indent |
| AttrTxtFontSize | AttrTxtFontSize: specifies the size of a font (height) |
| AttrTxtFontTypeface | AttrTxtFontTypeface specifies a font typeface |
| AttrTxtItalic | AttrTxtFontTypeface specifies if text is italic or not |
| AttrTxtJustification | AttrTxtJustification specifies how text is justified |
| AttrTxtLeftMargin | AttrTxtLeftMargin: specifies the left margin |
| AttrTxtLineSpace | AttrTxtLineSpace: specifies the size of a font (height) |
| AttrTxtRightMargin | AttrTxtRightMargin: specifies the right margin |
| AttrTxtRuler | AttrTxtRuler: specifies the ruler |
| AttrTxtScript | AttrTxtScript: Specifies sub/super script |
| AttrTxtTracking | AttrTxtTracking specifies text tracking |
| AttrTxtUnderline | AttrTxtUnderline specifies if text is underlined or not |
| AttrTypeItem | AttrTypeItem's are held in AttrTypeSets |
| AttrTypeSet | A set of AttrTypeitems |
| AttrUser | User Attribute Node |
| AttrValueChange | Change Fill colour Attribute class. This Attribute never exists in the Tree. It is used for changing the colours of an existing Fill Geometry |
| AttrVariableWidth | VariableWidth attribute VariableWidth attributes are very simple, and merely contain a VariableWidthAttrValue, which is the entity which holds all the info and does all the work |
| AttrWebAddress | The new Web Address attribute. This is distinct from the old Web Address attribute from CorelXARA 1.5, which was a type of AttrUser |
| AttrWindingRule | Winding Rule Attribute class |
| AutoCleanOILFilter | |
| AutoDeleteCCObject | Simplifies cleanup of temporary CCObject derived objects |
| AUX_DATA | |
| AvailablePropertiesList | Provides a visible list of template handlers |
| AvailableProperty | This abstract class represent an item in the "Available Properties" list |
| BarControl | This defines a control and its associated OpDescriptor within a bar. It holds separate horz and vert versions of the control in case the appearence and/or functionality changes with the orientation of the bar |
| BarControlBase | Base class from which all bar control classes are derived |
| BarControlInfo | A class that encapsulates the minimum data required to specify a control on a bar. The info is platform independant |
| BarCreate | Abstract class for creating DialogBarOps and derived classes. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile |
| BarCreationDlg | Dialog to make building button bar rollovers easier |
| BarDataType | Attributes of bars |
| BarItem | A virtual class used for deriving all types of bar item |
| BarLineFeed | Defines a new line after the item before this one. Can be viewed as a 'LF/CR' char pair when look at as a formatting item |
| BarMsg | |
| BarNewPage | Defines a gap between the item before this one and the one that follows. Can be viewed as a 'space' char when look at as a formatting item |
| BarRedefineStateDlg | |
| BarSeparator | Defines a gap between the item before this one and the one that follows. Can be viewed as a 'space' char when look at as a formatting item |
| BarStatesDlg | Dialog to make building button bar states |
| BarTable | Provide an array of window handles for all the existing Camelot bars. This enables us to get bubble help to behave correctly, i.e. when the cursor is over the bar, the bubble help goes away, but the delay timer for bubble help is not restarted |
| BarToolButton | |
| BaseBar | |
| BaseBitmapFilter | Base class for bitmap filters. (Currently export only). Inherited classes tend to be in the OIL layer. The base class fails on both imports & exports, so you only need to override the half that you implement |
| BaseCamelotFilter | This filter is for the new web file format which is the minimilistic form of the new version 2 native file filter. Derive off VectorFilter as this is what this file format defines |
| BaseDocument | A simple base class document object |
| BaseFileDialog | To provide a custom File Save / Open Dialog that goes to the correct directory etc |
| BaseNameObjectsDlg | Base class UI dialogs which create and rename sets of objects in the Attribute gallery |
| BasePMFilter | Provides most of the the handling for the PPM, PGM and PBM filters |
| BaseSelectScan | Base class for scans which select objects which are in the SGNameItem sets |
| BaseTextAction | Base class of all text actions |
| BaseTextClass | The root of the TextObject hierarchy |
| BecomeA | Class that encapsulates the params needed by virtual Node::DoBecomeA() |
| BevelAttributePathProcessor | This is the path processor which is used by the AttrBevelType node to do passbacks etc |
| BevelAttributeValueContrast | Sets the indent attribute |
| BevelAttributeValueIndent | Sets the indent attribute |
| BevelAttributeValueLightAngle | Sets the indent attribute |
| BevelAttributeValueLightTilt | Sets the indent attribute |
| BevelAttributeValueType | Sets the indent attribute |
| BevelComboMap | |
| BevelHelpers | |
| BevelInfoBarOp | Class for handling the Bevel tool's information bar |
| BevelInfoBarOpCreate | Class for creating BevelInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| BevelPathProcessor | This is the bevel path processor. It is used to combine all the paths rendered so that the next bevel node can render them |
| BevelRecordHandler | Handles the reading of all bevel attribute records in the v2 file format |
| BezierTool | This class handles the Free Hand Tool that is used to draw lines that follow the path of the Mouse Pointer |
| BezToolInfoBarOp | Class for handling the bezier tool's information bar |
| BezToolInfoBarOpCreate | Class for creating BezToolInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| BfxALU | Arithmetic and logic unit for bitmap effects |
| BfxALULUT | |
| BfxBrightnessContrast | Provides storage for details on a BfxBrightnessContrast plug-in |
| BfxBrightnessContrastDlg | |
| BfxColourDepth | Provides storage for details on a BfxColourDepth plug-in |
| BfxColourDepthDlg | |
| BfxColourThresholdPixelOp | Pixel operator |
| BfxColourThresholdPixelOpPseudo | Pixel operator |
| BfxDlg | |
| BfxErrorRegionList | |
| BfxErrorRegionListItem | Stores error region list for tracing |
| BfxFlipAndRotate | Provides storage for details on a BfxFlipAndRotate plug-in |
| BfxFlipAndRotateDlg | |
| BfxHandler | Provides BFX plug-in handling characteristics. It handles defining what file types BFX plug-ins have and how to parse them. As these are the built in filters, they are just added when the handler is inited |
| BfxMsg | This is a foolish message to bring up a bitmap effects dialog |
| BfxOp | Handles insertion of bitmap effect nodes into the tree |
| BfxOpParam | |
| BfxPixelOp | |
| BfxPixelOp24 | |
| BfxPixelOp32 | |
| BfxPixelOpPseudo | |
| BfxPlugIn | Provides storage for details on a BFX plug-in |
| BfxPlugInContextMenu | Implements the Bfx plug-ins context sensitive menus |
| BfxPlugInDlg | |
| BfxPlugInOp | Operation so that a BFX plug-ins can be invoked and used |
| BfxPlugInUndoOp | Undoable Operation so that a Bfx plug-ins can be invoked and used |
| BfxPositivePixelOp | Pixel operator |
| BfxPositivePixelOpPseudo | Pixel operator |
| BfxResize | Provides storage for details on a BfxResize plug-in |
| BfxResizeDlg | |
| BfxSpecialEffects | Provides storage for details on a BfxSpecialEffects plug-in |
| BfxSpecialEffectsDlg | |
| BfxThresholdPixelOp | Pixel operator |
| BfxThresholdPixelOpPseudo | Pixel operator |
| BGR | |
| BGRT | |
| BidirectionalIterator< T, Distance > | |
| BidirectionalIteratorTag | |
| BITMAP | |
| BitmapClipMap | Describes and handles import/export mappings for bitmaps |
| BITMAPCOREHEADER | |
| BitmapDownloadParam | Download operation parameter structure - passes the minimum necessary information to the Op |
| BitmapDragInformation | Contains info that a Bitmapdrag may find useful |
| BitmapEffect | Base class for all bitmap effects |
| BitmapEffectAtom | Base class for all bitmap effect atoms |
| BitmapEffectBase | Base class for all bitmap effects |
| BitmapEffectSILT | |
| BitmapExportDocument | A special document used for exporting single bitmaps It contains a single layer with a single NodeBitmap object |
| BitmapExportOptions | Base class for storing information about the bitmap we're exporting |
| BitmapExportPaletteControl | |
| BitmapExportPaletteInterface | |
| BitmapExportParam | Passes infomation about bitmap(s) to export |
| BitmapExportPreviewDialog | |
| BITMAPFILEHEADER | |
| BitmapFillAttribute | Specifies a bitmap fill attribute for an object |
| BitmapFilter | Allows filter families to contain all bitmap formats. All filters that load pure bitmap files (TIFF, JPEG, BMP etc) should be derived from this class. Some file formats contain mixes of vector and bitmap graphics (e.g. EPS) - in this case, always derive from the VectorFilter |
| BitmapFilterFamily | A filter for all bitmap file types. e.g. BMP, JPEG, PCX etc |
| BitmapImportOptions | Base class for storing import options It's not actually used much though.. |
| BitmapImportParam | |
| BitmapImportResults | Provides the results for the import Notes: m_bValid should be checked for TRUE after any construction because the constructor can fail Scope: public |
| BITMAPINFO | |
| BitmapInfo | |
| BITMAPINFOHEADER | |
| BitmapList | A list of Kernel Bitmaps used by a document |
| BitmapListChangedMsg | This message is sent whenever the document bitmap list changes in some way |
| BitmapListComponent | Provide a component that contains a list of kernel bitmaps in use by a document |
| BitmapListComponentClass | Provide a class that will add Bitmap components to new documents |
| BitmapPreviewData | |
| BitmapPropertiesRecordHandler | Handles the reading of bitmap properties records |
| BitmapPtr | A simple class containing a pointer to a kernel bitmap, so we can build lists with them |
| BitmapRecordHandler | Provide a bitmap record handler for the new native and web file formats. This asks the bitmap document component to import the bitmap definitions for us |
| BitmapSavePool | A list of Kernel Bitmaps to save out |
| BitmapSequence | Maintains a sequence of bitmaps |
| BitmapSequenceInfo | Describes a BitmapSequence |
| BitmapSGallery | The Bitmap SuperGallery class |
| BitmapSmoothingRecordHandler | Handles the reading of document bitmap smoothing flag record |
| BitmapSource | Objects of this class encapsulate the original source for a bitmap. Scope: public |
| BitmapTranspFillAttribute | Specifies a bitmap fill attribute for an object |
| BlankInfoBarOp | Class for handling the tool's information bar |
| BlankTool | A template tool class |
| BlendAttrParam | Class that encapsulates the params needed by virtual NodeAttribute::Blend() |
| BlendBecomeA | This is the class that is passed to other nodes when blenders try and get them to to turn into other types via their DoBecomeA() method |
| BlendedBrushDefinition | Stores a vector Brush definition created by blending two other brush definitions. Unlike regular brush definitions these are not stored in the brush component, instead they are attached to a BlendPathProcessorBrush for the purposes of rendering and are then destroyed They are also created differently, rather than passing in a subtree of nodes instead they are given already blended blendpaths and attribute maps |
| BlendedPathProcessorBrush | This class of path processor is generated when two brushed nodes are blended. It differs from a regular PPB in that it does not retrieve its ink objects from a brush definition stored in the brush component, instead it has its own pointer to a BlendedBrushDefinition object |
| BlenderInfoItem | Holds info on a given blender. This is used when blending a blend to a blend, or a blend to an object, as all the NodeBlenders in a given NodeBlend have to be temporarily deinitialised while the objects are contatinated |
| BlendHelpers | This encapsulates the blend functions which are needed to blend compound nodes (e.g. shadows etc) |
| BlendInfoBarOp | Class for handling the tool's information bar |
| BlendInfoBarOpCreate | Class for creating BlendInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| BlendNodeParam | Class which encapsulates data for blending between nodes We need all these so we don't duplicate code between this node and the blender (unfortunately) |
| BlendPath | This contains a NodePath, plus other data, generated by an object that is blended |
| BlendPathBecomeA | This gets a list of all the blenders in pNodeBlend. The it calls Deinit() followed by Reinit() on the blenders. The Reinit() is sent the actual object pointers to the objects they blended |
| BlendPathOffset | Stores the translation of the blendpath to the centre of its parent object |
| BlendRecordHandler | Handles the reading of all blend records in the v2 file format |
| BlendRef | Contains all the data that a NodeBlender needs about another node in the tree which it is blending |
| BlendSubRenderContext | Used during rendering to store the render context of a blender node if it has taken too long to render so far |
| BlendTool | The blend tool class |
| BlendToolRef | A class that represents a start or end of a blend. The start ref is used when a click occurs. The end ref is used at the end of a drag |
| BlobbyBar | |
| BlobbyDlg | |
| BlobbyOp | |
| BlobbyTabDlg | |
| BlobManager | Class to Manage the various types of selection blobs in Camelot. Currently Camelot knows about the following forms of selection blob :- |
| BlobStyle | Class for holding which blobs are required and which are not. Objects of this class are passed into the Blob Manager to tell it which of the blobs a tool wants to display and should be used something like this :- MonoOn BlobStyle ThisToolsBlobs; ThisToolsBlobs.Object = TRUE; // Display Object blobs in this tool ThisToolsBlobs.Fill = TRUE; // Display Fill blobs in this tool BlobManager->ToolInterest(ThisToolsBlobs); MonoOff |
| BmapPrevDlg | |
| BmpDlg | |
| BmpDlgParam | This will allow data (for delay between frames in animation) to be passed to and from the Bitmap Properties Dialog |
| BMPExportOptions | Base class for storing information about the bitmap we're exporting |
| BMPFilter | Encapsulates a Windows BMP export filter. Will probably import one day too |
| BMPOILFilter | Provide the OIL parts of the BMP filter |
| BmpPrefsDlg | |
| BodgeTextClipMap | Describes and handles import/export mappings for UNICODE text |
| BodgeUnicodeClipMap | Describes and handles import/export mappings for UNICODE text |
| BrookTroutOILFilter | Provide the OIL parts of the DBrookTroutCX filter which loads in the file as a BMP |
| BrowserPreviewOptions | |
| BrowserPrvwChgdMsg | Messages detailing specific changes to the Browsser preview properties |
| BrushAttrItem | Represents a brush attribute user-interface item within the line gallery |
| BrushAttrRecordHandler | |
| BrushAttrValue | Brush attribute value |
| BrushBecomeA | This class is passed to inknodes when we wish to turn them into blendpaths that we can use to make brushes. This is essentially a simplified version of BlendBecomeA |
| BrushBecomeAGroup | Theres no real facility for extracting the brush objects and passing them back, however this provides some sort of workaround, as it will store all the brush objects in a group |
| BrushComponent | A document component for handling Brush definitions |
| BrushComponentClass | The class that gets a Brush doc component going on start up We need to register our class as a document component and this is where we do it all |
| BrushData | A repository for all kinds of data that the brush uses. More of a struct than a class at the moment |
| BrushDefinition | Stores a vector Brush definition A static list of these items is held in the BrushComponent |
| BrushDefMsg | A message broadcast when a brush definition is edited. This enables things that represent the brush definition (such as the combo in the freeinfobar) to update themselves |
| BrushMsg | A message broadcast by a brush when it becomes selected as the default brush |
| BrushPointInfo | To store information about brush objects, including pressure |
| BrushRef | 'wrapper' for the blendref class for use with the brush. Contains the information that the nodebrushmaker needs to draw the brush objects |
| BrushRefBlender | An instance of this class is designed to take two BrushRef objects and blend together their paths and attributes, churning out a BlendedBrushRef object at the end. It essentially rips off a lot of what the NodeBlender does, except that instead of rendering anything or existing in the tree it just produces a blended object |
| BrushSubRenderContext | Used during rendering to store the render context of a brush node if it has taken too long to render so far |
| BubbleHelpWnd | Provide a special window class for bubble help windows. This window has a number of special properties. It knows how big to make itself, and where to position itself - you just create one, tell it what text to display and then tell it to show itself. It's fabby, believe you me. It registers a special window class with the CS_SAVEBITS flag so that the window update is really snappy when it goes away (this flag tells Windows to cache the windows under the bubble help window in a bitmap, and then blit that back onto the screen when the bubble goes away - the same as menus do automatically) |
| BuildMouldAction | When executed this action will get the mould to rebuild itself |
| Button | Represents a button in a DialogOp |
| CacheBlock | |
| CachedFontItem | A font item cached by the font manager |
| CachedFractal | A Fractal that has been cached |
| CachedObject | All objects that we want to add to the ObjectCache must be derived from a CachedObject base class |
| CacheEntry | DownloadCache support structure. Encapsulates an entry into the cache file table |
| CacheRemovalAlgorithm | DownloadCache support structure. Implements the cache removal algorithm. When the cache fills up, files with lower priority will be discarded first (see CacheEntry::Priority); for files of equal priority we compare the time stamps |
| CALSOILFilter | Provide the OIL parts of the CALS filter which loads in the file as a BMP |
| CamArtProvider | A derived event handler which providers art for bitmap buttons and other controls within Camelot Notes: In the OIL See Also: |
| CamCache | |
| CamelotEPSFilter | A filter that imports EPS files in Camelot EPS format |
| CamelotEPSFilter::_BitmapAttrs | |
| CamelotEPSOILFilter | Provide the OIL parts of the ArtWorks EPS filter |
| CamelotEPSRenderRegion | A render region for exporting files in the native EPS format |
| CamelotFileRecord | This derived class does all the things that are Camelot-specific |
| CamelotNativeEPSFilter | This filter will be almost the same as Camelot EPS, only it will hold a little more information and store data slightly more efficiently. Mainly, it will save out bitmaps as binary. It won't really be valid EPS as it will not always be ascii. The Native file format is being done this way as it will take little or no effort to do this |
| CamelotNativeFilter | This filter is for the new Native file format which comes after the version 1.1 ready for version 2. The BaseCamelotFilter provides common functionality for both this and the web file filter as they are essentially the same thing |
| CamelotNULLNativeFilter | This is a dummy filter that is used to calculate the size of the file that will be exported |
| CamelotNULLWebFilter | This is a dummy filter that is used to calculate the size of the file that will be exported |
| CamelotRecordHandler | This is the class that encapsulates a camelot-specific record handler in the new v2 format |
| CamelotTreeItemData | Hold pointer to CCObject associated with a wxTreeCtrl item |
| CamelotWebFilter | This filter is for the new web file format which is the minimilistic form of the new version 2 native file filter. The BaseCamelotFilter provides common functionality for both this and the web file filter as they are essentially the same thing |
| CamErrorDialog | The underlying function for [Tool-Module]Inform[Warning-Error] |
| CamIPCServer | |
| CamLaunchProcess | Launch a long-running asynchronous process |
| CamPlatformDependent | A derived clas for implementing wx-platform depedent Oil activity Notes: In the OIL See Also: |
| CamProcess | |
| CamProfile | To time various bits of the Camelot subsytem Notes: In the OIL See Also: CamProfiler |
| CamProfiler | To report on time taken in various CamProfile sections Notes: In the OIL See Also: CamProfile |
| CamResource | To control the translation of resources within Camelot Notes: In the OIL See Also: |
| CamResourceFixNameEntry | |
| CamResourceRemember | |
| CapabilityTree | This is the class representing the wntire capability tree |
| Capture | Hold current bitmap cacheing state during rendering and functionality to store bitmaps in cache, detect limits of cached spans, etc |
| CaptureHandler | An event handler to centralise the mouse handling during a drag |
| CarbonCopyOp | This class allows OpClone and OpDuplicate to share common code. Both are derived from it |
| CaretNode | Some Notes about the Caret |
| CBaseBrushNameDlg | Base class for the dialog that is used to name or rename brushes |
| CBDDItemInfo | |
| CBDragInfo | |
| CBeveler | Does the bevelling |
| CBevelFill | Abstract base class for all fill types |
| CBevelFillFlat | Do a flat fill |
| CBevelFillFrame | Do a rounded fill |
| CBevelFillPoint | Do a pointy fill |
| CBevelFillRound | Do a rounded fill |
| CBevelFillRuffle | Do a ruffle fill |
| CBevelFills | Encapsulates all the bevel filling stuff |
| CBevelFillSmooth | Do a smoothed fill |
| CBevelFillSquare | Do a rounded fill |
| CBGDDBrushItem | |
| CBGDDCachedItem | |
| CBGDDItemInfo | |
| CBGDDKernelBitmapItem | |
| CBGDDResourceItem | |
| CBGDDStrokeItem | |
| CBGDDWxBitmapItem | |
| CBiasGainDlg | |
| CBiasGainGadget | |
| CBitmapCache | |
| CBitmapCacheKey | |
| CBitmapDropDown | |
| CBitmapGridDropDown | |
| CBitmapManip | Performs bitmap manipulations |
| CBMPBits | Converts & removes Solid on Black 32bit problems! |
| CBrushEditDlg | |
| CBrushGadget | |
| CC_CLASSINIT | This type is important because it is used to build up the runtime class information used by CCObject and CCRuntimeClass. What happens is that any class declared as dynamic has a static instance of an object of this type. This static object is declared by the CC_IMPLEMENT_{DYNAMIC,DYNCREATE} macro. Declaring this object as static means that its constructor is called at program startup (very early on in the initialisation. The constructor is the important part - the object is declared passing in a pointer to the runtime class object (CCRuntimeClass) associated with the class in question. The CC_CLASSINIT then adds this object to the list of classes maintained and used by the CCRuntimeClass class |
| CCachedBitmap | |
| CCamApp | |
| CCamDoc | This is the wxWidgets class for a document type object in the OIL (it was originally part of wxWidgets example app. docvwmdi). It is very simple - its main use is getting hold of the relevant Document object from the kernel layer. wxWidgets calls various member functions when processing commands from the File menu. This class calls down into the kernel to do the actual work |
| CCamDocTemplate | Allows the customisation of the process MFC uses to create, load, and associate its view and document classes |
| CCamFrame | |
| CCamView | This OIL class implements many window functions, such as scrolling and sizing the editing windows. As such, it acts as an intermediary between the kernel and the host operating system. It is derived from the wx class wxView, which provides comprehensive methods for managing the client area of a window |
| CCArchive | Archive class used to save and load the Camelot tree |
| CCArray< TYPE, ARG_TYPE > | |
| CCAsynchDiskFile | File class that can be used for asynchronous loading. It contains an asynchstreambuf (see above) |
| CCAttrMap | Class that encapsulates lists of attributes in Camelot |
| CCBinHexFile | Translates data from binary to BinHex format |
| CCBufferFile | Provides a CCStreamFile which can fills two buffer's simultaneously on reading: one is the working buffer (passed to read()), the other is an accumulative buffer (passed in init()). This provides a useful interface with which to fill BitmapSource's Notes: The current implementation follows iostream's handling of eof() and provides only a read() member to fill the buffers |
| CCClientDC | |
| CCClipBoardFile | Will be used to access Windows text clipboard files |
| CCCoreUI | Base class for a UI element |
| CCDC | |
| CCDiskFile | Represents a file class that can offer buffered disk file I/O in both text and binary modes. Derived from the CCLexFile class so you can use lexical analysis functions on it |
| CCDummyDC | |
| CCFile | Represents an abstract file class from which all other file classes will be derived. It therefore acts as a generic interface to file handling of all sorts. A routine can read or write to a CCFile object without caring whether it is a real file on disk, or to the clipboard, or to a block of RAM somewhere. This class contains many pure virtual functions, which should be implemented by the derived classes. The basic functions of this class are supplemented by the derived class CCLexFile, which provides functions to perform lexical analysis on a file object. (Note that CCLexFile is also an abstract base class.) The main use of this class will be for the export and import filters. The class and its derivatives in this file used to just call InformError() about any errors that were encountered by the routines. The caller had no control over this so the liklyhood was that users would see a number of errors instead of just one. This is still the default but now all error handling goes through a GotError function which can be made to call InformError() and/or throw an exception. This is controlled by two protected BOOL values and can be either set in the constructor or via the public SetReportErrors and SetThrowExceptions calls. GotError also tries to force the bad(), fail() functions to fail on the next call so that no more file accesses should happen |
| CCGmtTime | Creates a time object which can be interogated about the current time. If you create a static version of this object you will most likely need to use the GetCurrentTime() function on the object from time to time, otherwise it will inevitable become out of date as time and tide waits for no man. This is not a class to use to time funtions and such. Its accuracy is to the nearest second only. This version returns Greenwich Mean Time rather than Local time |
| CCLexFile | |
| CCListGadget | Wrapper class for the Win95 listview control |
| CCListGadget::ListEntry | |
| CCMallocCriticalSection | |
| CCMemFile | Represents a memory IO file - IO is in byte units |
| CCMemTextFile | Represents a character memory IO file which can cope with unicode |
| CCObject | CCObject is derived from SimpleCCObject, so it provides the same new and delete operators. It also provides facilities for dynamic class information, and dynamic construction of objects |
| CCOleAccusoftStream | CCOleStream that manages the Accusoft stream switching as well |
| CCOleStream | Represents an IStream within an OLE Structured Storage. Uses the custom iostream class costream for its implementation |
| CColourBar | The CColourBar window - a window like the status bar, which contains a strip of colours that can be used in the selected Document |
| CCPaintDC | |
| CCPanose | Class to hold and manipulate Panose numbers See also: class FontMan, class ATMFontMan, class TTFontMan |
| CCPen | This provides support for Pressure Sensitive Pen devices. Its job is to keep track of the current pressure of a pen. It will automatically mutate itself into either a Real or Pretend pen, depending on what is availble when it is created. If it is a real pen, then it gets it's pressure from mouse messages. If it is a pretend pen, then the pressure is adjusted using either the keyboard (temporarily Keypad +/-) or by using a joystick |
| CCPrintDialog | To provide a custom Print Dialog |
| CCPrintInfo | To provide a custom Print Info class |
| CCPrintToFileDialog | |
| CCreateBevelTrapezoids | |
| CCResourceFile | Will be used to access Windows resource files |
| CCResTextFile | Will be used to access Windows resource text files - such as those used in the for Camelot Menu Scripts |
| CCRuntimeClass | Provide run-time class information and dynamic class creation for objects derived from CCObject |
| CCStatusBar | To override various part of the CStatusBar |
| CCStreamFile | Represents a file class that uses an iostream type object for direct I/O. CCDiskFile is derived from this, using a standard fstream object for I/O. CCMemFile should be derived from this, but isn't, using a standard strstream object. CCOleStream is also derived from this, using a custom costream object for I/O |
| cctime | |
| CCTime | Creates a time object which can be interogated about the current time. If you create a static version of this object you will most likely need to use the GetCurrentTime() function on the object from time to time, otherwise it will inevitable become out of date as time and tide waits for no man. This is not a class to use to time funtions and such. Its accuracy is to the nearest second only. This version returns local time |
| CCTimeBase | The base class local time generator. Normal time generators should be derived from this |
| CCUserAttrMap | |
| CCustomList | |
| CCustomListRowWnd | |
| CCustomListScrollableArea | |
| CCWobJob | |
| CDC | |
| CDistanceSampler | Derived class which has a method to sample data over distances. Basically what you want to do is initialise the object, set the sample distances, then pass in data to the CollectData method and this object will sample at the appropriate rate |
| cdr3DCoord | |
| cdr3DMatrix | |
| CDRActionGroupEnd | A group end |
| CDRActionList | A list object to store actions which need to be taken after lists in the CDR file have ended |
| CDRActionListItem | A listitem object to store actions which need to be taken after lists in the CDR file have ended |
| CDRActionTransform | A transform action |
| CDRArrowheadStore | A storage object for arrowheads from a CDR file import |
| CDRArrowheadStoredItem | A list item object for arrowheads from a CDR file import |
| CDRAttributeStore | A storage object for attributes from a CDR file import |
| CDRAttributeStoredItem | A list item object for attributes from a CDR file import |
| CDRBBoxList | A list of bounding boxes for the CDR filter |
| CDRBBoxListItem | A bounding box list item |
| CDRBitmap | Does conversion of Corel format bitmaps |
| CDRBitmapStore | A storage object for bitmaps from a CDR file import |
| CDRBitmapStoredItem | A list item object for bitmaps from a CDR file import |
| CDRColour | Translation of colours from CDR files |
| cdrExtrudeInfo | |
| cdrfArrowhead | |
| cdrfBBox | |
| cdrfBitmapData | |
| cdrfBitmapData3 | |
| cdrfBitmapHeader | |
| cdrfBitmapHeader4 | |
| cdrfBitmapPaletteEntry | |
| cdrfBitmapPaletteEntry4 | |
| cdrfColour | |
| cdrfColourV3 | |
| cdrfCoord | |
| cdrfEllipseData | |
| cdrfFillFlat | |
| cdrfFillGradColour | |
| cdrfFillGraduated | |
| cdrfFillHeader | |
| cdrfFillPattern | |
| cdrfFillTexture | |
| cdrfFillV3 | |
| cdrfFillVector | |
| cdrfFontDefn | |
| cdrfFontDefnV4 | |
| cdrfFontStyleTableEntryV3 | |
| cdrfFontStyleTableHeaderV3 | |
| cdrfFontTableEntryV3 | |
| CDRFillInfo | |
| CDRFilter | Corel Draw file importing class |
| cdrfLensDefn | |
| cdrfLinkTableEntryTextOnPath | |
| cdrfLinkTableEntryTextOnPathV3 | |
| cdrfLinkTableEntryTextV4 | |
| cdrfLinkTableHdr | |
| cdrfMasterLayerInfo | |
| cdrfMasterLayerInfoV3 | |
| cdrfOffsetHeader | |
| CDRFontnameStore | A storage object for fontnames from a CDR file import |
| CDRFontnameStoredItem | A list item object for fontnames from a CDR file import |
| CDRFontnameStoredItemEnumer | A class for those tricky font enumerations in the CDR filter |
| cdrfOutline | |
| cdrfOutlineV3 | |
| cdrfPageInfo | |
| cdrfPageInfoV3 | |
| cdrfParaDefnV4 | |
| cdrfParaTextHeaderV4 | |
| cdrfPathCoordHeader | |
| cdrfPatternBitmapHeader | |
| cdrfPerspectiveEntry | |
| cdrfPerspectiveTransform | |
| cdrfRectangleData | |
| cdrfStyle | |
| cdrfStyleReference | |
| cdrfTextCharStyledV3 | |
| cdrfTextCharStyledV4 | |
| cdrfTextCharV3 | |
| cdrfTextCharV4 | |
| cdrfTextHeaderV3 | |
| cdrfTextHeaderV4 | |
| cdrfTextInfoChar | |
| cdrfTextInfoFontDefn | |
| cdrfTextInfoHdr | |
| cdrfTextInfoParaHdr | |
| cdrfTextInfoParaInfo | |
| cdrfTextListCharStyledV4 | |
| cdrfTextListCharV4 | |
| cdrfTextOnPathInfo | |
| cdrfTextStoryCoordData | |
| cdrfTextStyleAlignment | |
| cdrfTextStyleFont | |
| cdrfTextStyleHdr | |
| cdrfTextStyleSpacing | |
| cdrfTransform | |
| cdrfTransformEntryV3 | |
| cdrfTransformEnvelope | |
| cdrfTransformEnvelopeV3 | |
| cdrfTransformExtrude | |
| cdrfTransformExtrudeV3 | |
| cdrfTransformHeader | |
| cdrfTransformMatrix | |
| cdrfTransformMatrixV3 | |
| cdrfTransformMatrixV4 | |
| cdrfTransformV3 | |
| cdrfTransformV4 | |
| CDRLayerList | A list object to store layers in a page during the conversion process |
| CDRLayerListItem | A list object to store layers in a page during the conversion process |
| cdrMatrix | |
| CDROILFilter | Provide the OIL parts of the CDR filter |
| CDRPageList | A list object to store all my pages in during the conversion process |
| CDRPageListItem | A list object to store all my pages in during the conversion process |
| cdrPerspective | |
| CDRTextOnPathLink | A bounding box list item |
| CDRTextStyle | |
| CDRTiledFillInfo | |
| CDRTransformConvertor | |
| CDRTransformConvertor3 | |
| CDRTransformConvertor4 | |
| CDRTransformConvertor5 | |
| CDRVectorStore | A storage object for vectors from a CDR file import |
| CDRVectorStoredItem | A storage item for vectors from a CDR file import |
| CFileException | |
| CFileInfoList | |
| CFileInfoList::CListRow | |
| CGadgetImageList | Kernel-usable class represeting a list of images |
| CGadgetImageList::ResIDListItem | |
| CGridComboUserData | |
| CGridDropDown | |
| ChangeBitmapPtrAction | An action which undoes the modification of Grad Fill data. This action can be used for undoing changing control points |
| ChangeBlendAction | An action which changes the one-to-one flag of a blend |
| ChangeBlenderAction | An action which changes the blender |
| ChangeBlenderOpParam | Holds the info needed to change the blender in a certain way |
| ChangeBlendOpParam | The param passed to OpChangeBlend::DoWithParam |
| ChangeBlendStepsAction | An action which undoes the modification of a path's filled bit (or redoes it) It can also be used to undo the IsStroked flag as well |
| ChangeBrushAction | An action which changes one of the members of a brush attribute |
| ChangeBrushDefAction | An action which changes one or all of the members of a brush definition |
| ChangeBrushDefOpParam | The param passed to OpChangeBrushDefinition::DoWithParam, identical to ChangeBrushOpParam except for 1) it has a brush handle member and 2) it takes its old and new values from its brush definition instead of a path processor |
| ChangeBrushOpParam | The param passed to OpChangeBrush::DoWithParam |
| ChangeContourAttributeProfileAction | An action which undoes the modification of a path's filled bit (or redoes it) It can also be used to undo the IsStroked flag as well |
| ChangeContourColourTypeAction | An action which undoes the modification of a path's filled bit (or redoes it) It can also be used to undo the IsStroked flag as well |
| ChangeContourObjectProfileAction | An action which undoes the modification of a path's filled bit (or redoes it) It can also be used to undo the IsStroked flag as well |
| ChangeContourProfileParam | The op param for the creation of contours |
| ChangeContourStepsAction | An action which undoes the modification of a path's filled bit (or redoes it) It can also be used to undo the IsStroked flag as well |
| ChangeContourToInnerAction | Changes the node to an inner contour node & regenerates |
| ChangeContourToOuterAction | Changes the node to an outer contour node & regenerates |
| ChangeContourWidthAction | Forces a regeneration of the bevel in all nodes in the list Used by NodeBevelcontroller::OnChildChange to force redraws in undos/redos |
| ChangeContourWidthParam | Parameter for the change countour operation |
| ChangeEffectResAction | An action to record/restore the current state of the LiveEffect EditList |
| ChangeFeatherEffectAction | |
| ChangeFeatherEffectProfileAction | |
| ChangeFeatherProfileAction | |
| ChangeFeatherProfileOpDesc | |
| ChangeFeatherSizeSliderOpDesc | |
| ChangeFillProfileAction | Action for changing fill profiles |
| ChangeGrid | An abstract class used for changing aspects of a grid |
| ChangeGridDivisions | An abstract class used for changing aspects of a grid |
| ChangeGridSubdivisions | An abstract class used for changing aspects of a grid |
| ChangeGridType | An abstract class used for changing aspects of a grid |
| ChangeGridUnits | An abstract class used for changing aspects of a grid |
| ChangeLyrAttribAction | When executed the ChangeLyrAttribAction changes a layer's Status |
| ChangeShapeDataAction | An action to toggle a (Boolean or double) value of a regular shape |
| ChangeShapePathAction | An action to change a path in a regular shape |
| ChangeShapePointAction | An action to change a point in a regular shape |
| ChangeTranspFillProfileAction | Action for changing transp fill profiles |
| Chapter | Chapters group together pages which are automatically created from the same master page |
| CharDescription | The CharDescription structure is used to identify a character within the FontCache. To extract the CharCode from a CharDescription To extract the Typeface Handle from a CharDescription To extract the Bold state from a CharDescription To extract the italic state from a CharDescription |
| CharMetrics | Parameter passing of char metrics |
| CharOutlineCache | A cache for a character outline. This cache can only be accessed via the OILFontMan character outline calls |
| CHelpDownloadWebDialog | |
| ChildWindowParameters | |
| CHSVChanger | Similar to its parent class but adds the following options:
- alter HSV values in existing colours, with no replacement colour
- replace named colours (as parent class) and make HSV changes to all colours whether named or not
|
| CInformErrorDialog | |
| CInitBrushNameDlg | |
| ClassCategoryProbe | |
| ClassRegistryEntry | Represents an entry in CLSID section of the registry, consisting of a key, subkeys, and some values |
| ClickModifiers | |
| ClipartImportParam | This class represents the Undo-able operation to import and open clipart files |
| ClipboardMapping | A class which describes and implements an available mapping between internal and external data formats. Each filter which can provide a useful clipboard export/import format will register with the ExternalClipboard instance, using an ClipboardMapping object to describe the available mapping, and to provide functions which will invoke that filter on windows clipboard data |
| ClipboardView | Simple view class for use when rendering (exporting) the clipboard |
| ClippedInkFlags | |
| ClipRegionAttribute | See also: |
| ClipViewRecordHandler | Handles the reading of all ClipView records. See also: |
| ClosestFontEnumerator | |
| CMap< KEY, ARG_KEY, VALUE, ARG_VALUE, BaseClass > | |
| CmdControl | A CmdControl is an abstract class from which all types of interface controls inherit. These controls include MenuItems, Keyboard Accelerators, Buttons etc. They all have one main thing in common and that is that they are built out of Operations. Unlike Tools Controls have only one operation behind them.Base class for Camelot menu items. Unfortunately neither Mario or Andy ever got round to documenting this stuff, ha ha ha |
| CMediaReplayDetect | |
| CMemoryException | |
| CMX16ClipMap | |
| CMX16OILFilter | Provide the OIL parts of the CMX filter |
| CMX32ClipMap | |
| CMX32OILFilter | Provide the OIL parts of the CMX filter |
| CMXClipMap | Describes and handles import mapping for some "QuarkXPress Picture Data"Describes and handles import/export mappings for CMX files |
| CMXExportDC | Export device context for CMX files |
| CMXExportDC::CMXFutureDataCacheEntry | |
| CMXFileRecord | |
| CMXFilter | Import filter for CMX format |
| CMXFilter16 | |
| CMXFilter32 | |
| CMXFutureIndex | |
| CMXFutureLength | |
| CMXFutureNumber | |
| CMXFutureUpdater | |
| CMXGroupRecord | |
| CMXImportArrowheads | |
| CMXImportArrowShape | |
| CMXImportColourList | |
| CMXImportColourListItem | |
| CMXImportDotDash | |
| CMXImportFilter | |
| CMXImportFilterDataSet | |
| CMXImportFont | |
| CMXImportLineStyle | |
| CMXImportOILFilter | Provide the OIL parts of the CMX import filter |
| CMXImportOutline | |
| CMXImportPen | |
| CMXImportProcedure | |
| CMXLensBBox | |
| CMXNestedTagRecord | |
| CMXNode | |
| CMXNodeInfo | Hold information on a node displayed in the tree dialog |
| CMXNodeTypeStatistics | Holds info relating to a node of a particular type (i.e. tag value) |
| CMXNodeTypeStatisticsList | Class that maintains statistics on the nodes added to the tree |
| CMXReferArrow | |
| CMXReferArrowheads | |
| CMXReferBitmap | |
| CMXReferBitmapFill | |
| CMXReferColour | |
| CMXReferDefaultDotDash | |
| CMXReferDefaultScreen | |
| CMXReferDotDash | |
| CMXReferLayer | |
| CMXReferLens | |
| CMXReferLineStyle | |
| CMXReferListItem | |
| CMXReferListItemOffset | |
| CMXReferMasterIndex | |
| CMXReferMasterLayer | |
| CMXReferOutline | |
| CMXReferPage | |
| CMXReferPen | |
| CMXRenderRegion | |
| CMXTreeDlg | |
| CMXTreeDlgRecordHandler | |
| CNameBrushDlg | |
| CNamedColourReplacer | This is a somewhat specialised class whose purpose is to temporarily replace the Named colours in a ColourFillAttribute. Its stores the colours that are replaced and can be called upon to put them back at a later time. It was designed for use with the Brush attribute, where we wish to be able to replace named colours in the brush objects, and then change them back. If you can think of any other uses for it then feel free |
| ColBarDefaultSizeInfo | |
| ColEditContextMenu | Implements the colour editor context sensitive menus |
| ColEditorDragInfo | Contains info that a colourdrag may find useful - used for drags from the colour editor |
| ColEditorDragTarget | Handles dragging of colours into the colour editor window. Multiple instances of this class are created to handle the different areas of the colour editor (which one they are working on is determined from the gadget ID for which the target is created) |
| ColEditState | |
| ColourBarMsgHandler | Intercepts messages for the Colour Bar (Keeps the Colourabout which document is selected) |
| ColourChangeInfo | |
| ColourChangingMsg | This message is sent whenever certain events of importance happen in the colour system. Most of these events relate to IndexedColour lists, or individual IndexedColours. See Develop:Camelot.doc for details |
| ColourCIET | |
| ColourCMYK | |
| ColourContext | |
| ColourContextArray | |
| ColourContextCMYK | Object class representing colour contexts based upon the CMYK colour model (Cyan, Magenta, Yellow, Key) |
| ColourContextGreyT | Object class representing colour contexts based upon the GreyT colour model (Greyscale intensity, Transparent) |
| ColourContextHSVT | Object class representing colour contexts based upon the HSVT colour model (Red, Green, Blue, Transparent) |
| ColourContextList | Defines a list of colour contexts, as must be kept on a global basis. This is a perfectly normal list, except it has a special function to add a ColourContext item to the list, which ensures that no duplicate colour contexts are ever used, and that the usage count for any shared context is properly updated |
| ColourContextRGBT | Object class representing colour contexts based upon the RGBT colour model (Red, Green, Blue, Transparent) |
| ColourContextWebRGBT | This class inherits from class ColourContextRGBT, and although (at the moment) does not add any new functionality - provides us with an appropriate way of allowing us to edit RGBT in hexadecimal (i.e. rrggbb or 0xrrggbb web format). Reasons for this are: 1) so that I did NOT have to keep copying and pasting code for all the places that a colour model combobox appears. 2) allow us to integrate correctly with the edit dialog (thereby not doing 2). 3) make the addition of subsequent ColourContexts easier (since you won't have to worry about this class at all); and 4) cause I felft like it |
| ColourDragInformation | Contains all information about a colour being dragged |
| ColourDropDown | Colour drop down class - provides a dropdown list of named colours with colour patch and name, for use in the colour editor etc |
| ColourDropMsgHandler | Intercepts messages for the Colour Drop Downs to allow them to stay up to date when documents change etc |
| ColourEditDlg | |
| ColourEditDlgParam | The OpParam to use when Invoke()ing the ColourEditDlg You shouldn't ever need to use this - just call the static function ColourEditDlg::InvokeDialog if you want a colour editor |
| ColourFillAttribute | The base class for a fill geometry attribute, such as flat, linear, radial, conical, etc. This provides the basic interface for fill rendering |
| ColourGeneric | |
| ColourGreyT | |
| ColourHSVT | |
| ColourImportContext | Provides a colour context to use when importing colours, which allows us to easily import arbitrarily nested linked colours |
| ColourInfo | |
| ColourLineDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag. WinoilDragTargets are used as a base class from which to derive drag targets for WINOIL entities (an optional wxWindow*) |
| ColourList | A colour list is held by each document to store the list of available IndexedColours for use by that document. (This colour list is displayed in the ColourBar/ColourGallery via the ColGalDisplayList which references colours held in the ColourList) |
| ColourListComponent | Provide a component that is linked to a ColourList object. This allows us to save out colour lists using the serialisation facilities of the DocComponent base class |
| ColourListComponentClass | Provide a class that will add Colour List components to new documents |
| ColourManager | This class provides miscellaneous shared functions for use by various colour entities. The provided functions are currently: |
| ColourMatrix | |
| ColourMatrix::elements_t | |
| ColourNameDlg | |
| ColourNameParam | Allows the user to edit the name of a colour |
| ColourPacked | |
| ColourPicker | Encapsulates OS-specific colour picker dialogue system, giving a kernel interface for using whatever colour picker(s) are available |
| ColourPickerDragInformation | Contains all information about a colour being dragged |
| ColourPlate | Used as a descriptor defining how a colour context should separate/filter a colour as it is converted |
| ColourRamp | This class holds a list of colour records, each of which describe a colour position in a colour ramp. The list contains the usual add/delete entry members and other suitable interfaces to allow colour ramps to be edited. The list is used inside GradFillAttribute to describe multicoloured fills |
| ColourRecordHandler | Provide a colour record handler for the new native and web file formats. This asks the colour document component to import the colour definitions for us |
| ColourRGBT | |
| ColourSGallery | The Colour SuperGallery class |
| ColourVector | |
| ColRampItem | Defines a single entry in a colour ramp. An entry is simply made up of a single doc colour definition |
| CombineBecomeA | This is the class that is passed to other nodes when the combine op gets them to to turn into other types via their DoBecomeA() method |
| CommandMap | Provides a mapping from a token (i.e. an integer) to the string representation of that token. An array of these objects is used to map an EPS command string onto the enumerated type used for the token representation within Camelot |
| CommonAppliedAttribute | Represents an applied attribute of which there is only one for the objects given by the iterator |
| CommonAttributeItem | This ListItem is used by Range::FindCommonAttributes |
| CommonAttrMap | |
| CommonAttrMultiSet | A CommonAttributeSet. See Range::FindCommonAttributes |
| CommonAttrsChangedMsg | Respond to this message whenever you need to call Range::FindCommonAttribute or Range::FindCommonAttributes to display up-to-date common attribute information to the user. Because FindCommonAttributes returns Current Attributes in some situations, this message is broadcast whenever any of the following msgs are receved by the SelRange |
| CommonAttrSet | |
| CommonTransInfo | |
| CompatibleFilter | A simple ListItem derived class to allow a list of filters to be maintained - the list holds all the filters that claim to understand a particular file (see FilterFamily). It is not derived from the Filter class itself because although the Filter class is derived from ListItem too, we want to store a list of pointers to existing filters, rather than actual instances of the Filter class. For each entry, a 'compatibility rating' is held, to allow the FilterFamily class (the client of this class) to choose the most compatible filter from the list |
| CompatibleFilterList | Simple list class to allow a list of compatible filters to be maintained |
| CompoundNodeBlendBecomeA | Gets the compound node to wrap up any nodes passed to the passback in a copy of its tree structure |
| CompoundNodeTreeFactory | Encapsulates all data needed to create a new compound node of a particular type Abstract base class to be inherited from |
| CompoundNodeTreeFactoryList | A list of the compound node factories necessary to regenerate the shadow/ bevels/other compound nodes after bevelling |
| CompoundNodeTreeFactoryListItem | Item in the CompoundNodeClassFactoryList |
| CompressionRecordHandler | Provide a compression record handler for the new native and web file formats. This asks the ZLib code within side the CCFile class to turn compression on or off |
| ConcurrencyController | Ensures no update conflicts with concurrent users to Camelot |
| ConcurrentRenderer | |
| config_s | |
| ConicalFillAttribute | Specifies a conical fill attribute for an object, including the vector that defines the centre of the cone, and the angle of the fill |
| ConicalTranspFillAttribute | Specifies a conical fill attribute for an object, including the vector that defines the centre of the cone, and the angle of the fill |
| ContextItem | Provides information on a context level - see ColourImportContext for more detail |
| ContextMenu | Encapsulate the concept of pop-up, context-sensitive menus at the kernel level |
| ContourBecomeA | This is used to turn all nodes which are to be contoured into a single path |
| ContourBecomeA2 | ContourBecomeA2 class provides a greener alternative to ContourBecomeA |
| ContourDragBecomeA | This is used to turn all nodes which are to be contoured into a single path for dragging |
| ContourInfoBarOp | Class for handling the tool's information bar |
| ContourInfoBarOpCreate | Class for creating ContourInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| ContourNodePathProcessor | The path processor which is used to sum all paths to be contoured |
| ContourNodeTreeFactory | Creates a new contour node with the given parameters |
| ContourRecordHandler | Handles the reading of all contour records |
| ContourTool | The Contour tool class Notes: Copied from the blend tool |
| ContourWidthListItem | ListItem for use in ChangeContourWidthAction's list |
| ControlEntry | Contains the information for a particular control. The data members are: MonoOn wxWindow* Window - the handle of the control. OpDescriptor *pOpDesc - pointer to the OpDescriptor associated with this control. WNDPROC WndProc - pointer to the normal WndProc for the subclassed control. MonoOff |
| ControlHelper | Provide a system for subclassing controls on Camelot bars which offers various facilities such as bubble help/status bar text and commit handling. To use this system you use the Notifyxxx() functions to keep the class up to date with which bars/controls exist. This module will subclass these controls and do some preprocessing of Windows messages in order to do bubble help/commit handling etc. You can 'fake' bubble help on a window that doesn't really have controls in it, by using the 'ad-hoc' bubble help function, DoBubbleHelpOn() |
| ControlHelpInfo | Used to specify details of a control that is to be added to the list of sub-classed controls. The fields are: MonoOn pOpDesc - pointer to the OpDescriptor for this control. If this field is non-NULL, then all the ID fields are ignored. Id this field is NULL, then the ID fields are used to define the bubble help text and status bar text to be displayed for this control. BubbleID - ID of the string resource to be used for bubble help. StatusID - ID of the string resource to be used for status bar text. ModuleID - defines where to find the above resources. Parent - internal use; any value you put in here will be ignored. MonoOff |
| ControlInfo | A list of ConrolInfo ListItem's are stored 'in' a dialog box. They are used to store information which is required in a subclassed controls proc. Currently Edit controls and Button controls create a ControlInfo item when they are subclassed |
| ControlList | |
| ControlList::ListEntry | |
| ControlPts | |
| ControlTable | Stores/manipulates an array of ControlEntry objects, in order to keep track of all the controls we have currently subclassed |
| Conv24to32 | A 24 to 32 bpp converter |
| Conv24to8 | |
| Conv32to1 | |
| Conv32to24 | |
| Conv32to32 | |
| Conv32to4 | |
| Conv32to8 | |
| Conv8to32 | An 8 to 32 bpp converter |
| Convert | This class is used to convert things from one form to another. Mainly contains static functions. Started life as a series of conversion functions before being made to see the light and profess the one and only true class. At present in the Winoil class as it needs converting to TCHARs and using the MFC forms of scanf and sprintf . |
| ConvertPathToShapesBecomeA | The become A structure for the above operation Adds a node into the tree which is the stroked path of the particular node passed into the PassBack function Notes: When stepping through, you MUST store the next node before calling DoBecomeA - since the tree will be changed when PassBack is called in this class |
| Coord | Structure holding a 32-bit cartesian coordinate |
| CopyBecomeA | This is the BecomeA class that is passed to other nodes when we need to make 'pathified' copy of a subtree. The effect is to create a bunch of nodes which copy identically the specified tree |
| CopyObjectsToClipboardAction | When executed as an undo action nothing happens except for the creation of a redo CopyObjectsToClipboardAction |
| Corel3EPSFilter | An import filter to import EPS files as saved by Corel Draw! 3.x |
| Corel3EPSOILFilter | Provide the OIL parts of the Corel 3.x EPS filter |
| Corel4EPSFilter | An import filter to import EPS files as saved by Corel Draw! 4.0 |
| Corel4EPSOILFilter | Provide the OIL parts of the Corel 4.x EPS filter |
| CorelEPSFilter | A base class filter that implements the core functionality required for a Corel EPS import filter. Other filters are derived from this - this class is never instantiated as it is incomplete |
| CorelEPSFilter::CCAPI | |
| CorelPaletteFileOILFilter | Provide the OIL parts of the Corel Palette file filter |
| CorelPaletteFilter | Corel Palette file importing class |
| CPathPointInfo | |
| cpl_header | |
| CProfileBiasGain | |
| CProgressBar | Progres bar display window for "busy" operations |
| CreateContourParam | The op param for the creation of contours |
| CreateDisplayScan | Scans the 'selected' document and creates/refreshes the groups and items of the Attribute gallery's display |
| CreateDisplayScan::ClearCounters | |
| CreateDisplayScan::CreateItems | |
| CreateDisplayScan::DelItemIfUnref | |
| CreateDisplayScan::FoldGroupIfEmpty | |
| CreateMouldParam | The OpParam to use when Invoke()ing the CreateNewMould operation |
| CRenderWnd | This OIL class is rendered into. It passes all input to its parent CCamView window |
| CriticalSection | |
| CSampleData | Base class to hold an array of CSampleItems |
| CSampleItem | Brush sample data item class, records position, distance along the path and pressure at the point when it is recorded |
| CScrollerButton | This OIL class extends standard Windows bitmapped buttons so that they respond to clicks with the right mouse-button, and send notification messages as long as they are held down |
| CScrollerCorner | This OIL class is the little square in the bottom-right of a window featuring horizontal and vertical scroll bars. It is currently completely useless (except visually, of course) |
| CScrollerThumb | This OIL class represents a scroll bar "thumb", which sends drag messages to its parent CScroller object |
| CShadowerFlat | 'Wrapper' for the COM interface CShadowerFlat, which is itself a 'Facade' for the flat shadow generation system. Simply delegates to its owned COM component. See also: CShadowerFlat ( in CShadowerFlat.cpp ) To calculate/estimate the bound of an unshadowed pixmap, given the bound of a (hypothetical) shadowed pixmap,
- the inverse of CalcShadowBound(). Calculate the rectangular bound of the shadow that would be produced by DrawShadow() given a particular transparency/alpha map. Call this, use the results to allocate a shadow map, then call DrawShadow(). Draw the shadow cast by a particular transparency/alpha map
|
| CSlice | Simple class, stores the data required for each slice |
| CSnap | Performs the snapping required by Camelot |
| ct_data_s | |
| CTemplateManager | |
| CTransparencyReplacer | Similar to CNamedColourReplacer, this class takes a transparency attribute, changes its values, and then changes them back |
| CUniversalParam | Simple class that makes it possible to have parameters that can either be a pointer or an INT32 in a 64bit safe manner |
| CurrentAttrChangedMsg | This message is sent whenever the current attributes are updated |
| Cursor | Encapsulates OIL cursors, hiding OS specific functions behind a standard sensible interface |
| CursorIdent | Used in the cursor stack - holds a pointer to a cursor and an identifying ID |
| CursorMask | |
| CursorStack | A stack of Cursor objects, which is part of the kernel (NB Cursor objects are part of the OIL) |
| Curve | |
| CurveEdge | |
| CurveFitObject | Fits bezier curves to a serious of coordinates. Call the constructor, Initialise and finally FitCurve to fit a bezier curve to the coords |
| CustomizeBarDlg | |
| CustomProperty | Provides a "custom" visible template handler so the user can enter raw user attributes |
| CViewFileDropTarget | |
| CWindowIDItem | A very simple class which contains a CWindowID. A list of CWindowIDItems are stored in the DialogPosition list |
| CWinScroller | |
| CWxBitmap | The Windows implementation of the OILBitmap class. Based on a non-compressed DIB. Kernel code should not call on functions in this class except via the OILBitmap interface |
| CXaraFile | Encapsulates the v2 file format functionality. It provides a standard way for reading and writing v2 format files |
| CXaraFileEllipse | Class for exporting ellipses in the new file formatAbstract class holding code for exporting ellipses in the new file format |
| CXaraFileMapTagToHandler | This class implements a fast way of looking the handler that handles a given tag |
| CXaraFileNodeBitmap | Saving code for node bitmapsAbstract class holding exporting for node bitmaps |
| CXaraFileNodeGroupRefList | Holds a list of nodes and corresponding group objects |
| CXaraFileNodeGroupRefListItem | An item that appears in the CXaraFileTextStoryGroupRefListHolds a list of text stories and corresponding group objects.An item that appears in the CXaraFileNodeGroupRefList |
| CXaraFilePathRecordRefList | Holds a list of node path objects, and the corresponding record numbers of the records that represent the paths in the file |
| CXaraFilePathRecordRefListItem | An item that appears in the CXaraFilePathRecordRefList |
| CXaraFilePolygon | Abstract class holding exporting code for polygons in the new file formatAbstract class holding exporting code for polygon for the new file format |
| CXaraFileRecord | This is the class that encapsulates a record in the new v2 format |
| CXaraFileRecordHandler | This is the class that encapsulates a record handler in the new v2 format |
| CXaraFileRectangle | Abstract lass holding exporting code for rectangles in the new file formatAbstract class holding exporting code for rectangles for the new file format |
| CXaraFileRegularShape | Abstract Base class for exporting regular shapesAbstract class holding importing and exporting code for regular shapes to and from the new file format |
| CXaraFileTxtAspectRatio | Export code for the new file format |
| CXaraFileTxtBaseLine | Export code for the new file format |
| CXaraFileTxtBold | Export code for the new file format |
| CXaraFileTxtCaret | Exporting code for text caret objects for the new file format |
| CXaraFileTxtChar | Exporting code for text char objects for the new file format |
| CXaraFileTxtEOL | Exporting code for text EOL objects for the new file format |
| CXaraFileTxtFirstIndent | Export code for the new file format |
| CXaraFileTxtFontSize | Export code for the new file format |
| CXaraFileTxtFontTypeface | Export code for the new file format |
| CXaraFileTxtItalic | Export code for the new file format |
| CXaraFileTxtJustification | Export code for the new file format |
| CXaraFileTxtKern | Exporting code for text kern objects for the new file format |
| CXaraFileTxtLeftMargin | Export code for the new file format |
| CXaraFileTxtLine | Exporting code for text line objects for the new file format |
| CXaraFileTxtLineSpace | Export code for the new file format |
| CXaraFileTxtRightMargin | Export code for the new file format |
| CXaraFileTxtRuler | Export code for the new file format |
| CXaraFileTxtScript | Export code for the new file format |
| CXaraFileTxtStory | Exporting code for text stories for the new file format |
| CXaraFileTxtTab | Exporting code for tab objects for the new file format |
| CXaraFileTxtTracking | Export code for the new file format |
| CXaraFileTxtUnderline | Export code for the new file format |
| CXaraTemplateFile | CXaraFile derived class for handling Flare template files This translates the records written by the standard native format export into the text based format |
| CXFNode | |
| CXFNodeTypeStatistics | Holds info relating to a node of a particular type (i.e. tag value) |
| CXFNodeTypeStatisticsList | Class that maintains statistics on the nodes added to the tree |
| CXFTreeDlg | |
| CXFTreeDlgRecordHandler | |
| CXMLUtils | |
| DashPatternAttribute | Attribute for dash pattern style of paths |
| DashPatternHeader | The header for the dash pattern structure contained in Acorn Draw files. It is usually followed by a series of dash and gap lengths in the file |
| DashRec | |
| DashType | |
| DaveDlg | |
| DColourCIET | |
| DCXOILFilter | Provide the OIL parts of the DCX filter which loads in the file as a BMP |
| DDeckerBottom | Defines the start of the bottom row of double decker bar controls |
| DDeckerEnd | Defines the end of a row of double decker bar controls |
| DDeckerTop | Defines the start of the top row of double decker bar controls |
| DeactivateBrushDefAction | Does most of the dirty work for the above operation |
| DeathMsg | This message is sent just before camelot's death. When a long-life operation receives this message it should tidy-up then call End() |
| DebugTreeDlg | |
| DebugTreeInfo | Encapsulates the platform dependent parts of the debug tree dialog. It provides a simple way of linking a datum to a particular item in the debug tree dialog's list box. This kind of facility can often be supported by the GUI, hence it is in the OIL layer |
| DeflateState | A deflate state object for the deflater for the file compressor and decompressor |
| DialogBarOp | |
| DialogBarOpCreate | Class for creating DialogBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile |
| DialogColourInfo | Most host operating systems supply applications with a set of colours to be used for rendering special parts of dialogues, e.g. window background, plinth colours, default text foreground/background colours, selection highlight colours, etc |
| DialogEventHandler | A derived event handler to wire up wxDialog derived classes to DialogManager Notes: In the OIL See Also: |
| DialogHelpTuple | |
| DialogManager | |
| DialogMgrGadget | This is a base class representing a gadget in a DialogOp. It should not be instantiated |
| DialogMsg | A DialogMsg is sent whenever the user interacts with the gadgets in a dialog box, It is only sensible to send this message to DialogOp objects |
| DialogOp | The abstract DialogOp class is used as the base class for all Dialog box classes in Camelot. It provides methods required to create dialogs and to communicate with gadgets |
| DialogPosition | DialogPosition ListItem's are stored in the DialogManager's DialogPositionList they record the position of a dialog box before it is destroyed. They are used to restore the position of the dialog when it is created the next time |
| DialogTabOp | The abstract DialogTabOp class is used as the base class for all tabbed Dialog box classes in Camelot. It is a simple specialisation of a DialogOp |
| DialogView | Simple view class for dialogs to use when rendering via a Camelot RenderRegion |
| DIBClipMap | Describes and handles import/export mappings for bitmaps |
| DIBConvert | |
| DIBUtil | Contains static functions for handy DIB manipulation. Never instantiate one of these. That would be silly |
| DimScale | This class is used to scale millipoint dimension values to and from a user-set preference. E.g. the user may specify that 1 mile = 2 centimetres. This class will record the units (in this case miles) and the scale factor used to convert internal millipoint values to and from the units the user wishes to work in |
| DirPath | Represents and validates a directory pathname, rather than a file pathname |
| DitherBlock | |
| DlgDiscardString | This simple class holds a pointer to a string which must be deleted when a dialog is deleted |
| DlgEvtTimer | |
| DLGITEMTEMPLATE | |
| DLGTEMPLATE | |
| DocChangingMsg | This message is sent when something about a document changes. This includes: MonoOn BORN (pChangingDoc) - When a doc has been created ABOUTTODIE (pChangingDoc) - When a doc is starting to be destructed KILLED (pChangingDoc) - When a doc has been destructed |
| DocColour | This class defines a colour. A DocColour stores an original definition of a colour, a cache containing the definition of the colour in the last colour context in which it was used, and sundry information. DocColours have been designed to be small things to put in attributes |
| DocComponent | An implementation of an instance of a document component, such as a colour table, or a list of arrowheads. These are the objects that are instantiated for each Document object that exists, and are held in a list in each Document object |
| DocComponentClass | This provides a class of objects which implement an interface to a particular kind of document component - for example a colour table, or a list of arrowheads. Each kind of object should register with the application on startup, and then when a document is created, each of these objects is asked to add an instance of a DocumentComponent object to it. The DocumentComponent objects are the actual implemtations of the components. For example, they contain the colours for a colour list, and so on. This class, the DocumentComponentClass, is merely for registering the existence of a new kind of document component, and providing a mechanism for inserting them into new documents |
| DocCoord | |
| DocInfoComponent | Provide a component that allows us to save out the information for this document using the serialisation facilities of the DocComponent base class |
| DocInfoComponentClass | Provide a class that will add document information components to new documents |
| DocInfoRecordHandler | Provide a units record handler for the new native and web file formats. This asks the units document component to import the unit definitions for us |
| DocOps | This class represents All the File operations |
| DocPrintMark | A document print mark item. This item references a cached print mark held by the print mark manager |
| DocPrintMarkList | Provide a class that will add Print mark components to new documents |
| DocPseudoEnumerator | |
| DocRect | This class is used to represent a rectangular region. It uses a union to enable the client to access the rectangle as two DocCoords (lo and hi) or as four INT32s (lox, loy, hix, hiy). An anonymous union is used, which is a defined C++ feature and so portable |
| DocTreeSource | Concretisation of NodeScan::Source for all NodeRenderableInks in a document's object tree (generally), or in the 'selected' document's tree (specifically) |
| Document | To represent a platform independent document object |
| DocumentFontDropDown | DocumentFontDropDown class itself. This uses the FontDropDown class to provide a font drop down but overides some of the functionality so that it works out the fonts in the current document rather than the fonts avalaible in the system |
| DocumentRecordHandler | Handles the reading of all document records in the v2 file format |
| DocUnitList | Encapsulates units within Camelot. All units (i.e. default and user-defined ones) are an instance of this class. Each document has its own list of units controlled by an instance of DocUnitList within the Document class. Therefore you should get hold of the DocUnitList within the current doc when you want to add/delete/edit/find a unit |
| DocView | Used to hold non-oil data about views onto a document. When a CCamView object exists there is always a DocView object on the other side of the OIL- interface and they are linked. However, the DocView object is not destroyed when the CCamView object is destroyed so that it records the state of views while they are closed |
| DocView::CCAPI | |
| DocViewMsg | This message is sent when a DocView is about to be destroyed or has just been created/loaded. It contains a pointer to the appropriate view object (pDocView), and a state indicating if the view is being destroyed or is being created etc. (State). Both members are public. See the file DOCVIEW.H for more information |
| oilHardwareManager::DoubleUnion | |
| DownloadCache | Implements the file cache used by the InternetManager Comment: The interface is static so it can be accessed from anywhere in the program with the scope resolution operator :: |
| DownloadCache::CacheMonitor | |
| DownloadOp | File download operation. This class is intended as a base class for new Internet-related operations - it has little use on its own. The older internet operations used in Webster 1 are derived straight from Operation and were a bit difficult to implement |
| DownloadOpParam | Download operation parameter structure - passes the minimum necessary information to the Op All operations derived from DownloadOp should be invoked with parameters derived from this class |
| DownloadQueue | InternetManager support class. Represents a queue of asynchronous downloads, which are executed in sequence one at a time |
| DPOINT | |
| DragInformation | Objects derived from this abstract class are used to describe everything useful to know about the current global drag. They allow drag targets to decide what to do with a recieved drag |
| DragManagerOp | An instantiation of this class (created by a call to its static StartDrag method) is used to describe a current global drag. When the drag completes, this object will self destruct. While alive, this object controls the drag, passing relevant events on to registered drag targets, etc. See the documentation for a fuller description of the global drag system |
| DragMessage | This message is sent to inform the system of important global drag events. Currently the only such event is DRAGSTARTING, sent whenever a global drag is started by calling DragManagerOp::StartDrag. It informs all interested parties that they should register DragTarget objects with the drag manager to handle the drag |
| DragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag |
| DragTool | The Drag tool is a base class for the Selector and Slice tools. It acts to give these tools a common heritage, so that TransOperation, which handles dragging of objects, can maintain a pointer to them and inform them of various events during a drag. At some point in the future (ie maybe never, but we can hope...) it may be useful to pull common drag functionality up from these two tools, into a base implementation in this class |
| DrawColour | Mirrors the representation of a colour as used in Acorn Draw files |
| DrawFileHeader | Holds the information contained in the header of an Acorn Draw file |
| DrawingModeAttribute | Attribute for drawing mode - EOR, COPY etc |
| DrawingSelection | |
| DrawObjectHeader | Contains the information contained in an object header of an Acorn Draw file |
| DrawOILFilter | Provide the OIL parts of the Draw filter |
| DrawPathElement | Used to load in a path element from a Draw file. Not all of the 'Coords' array is always used - it depends on the path element |
| DrawPathHeader | Used to load in the header information for a path object in a Draw file. It holds details on the fill and line colours, the line width, and the style of the path |
| DrawPathStyle | Holds the style information for a path as used in Acorn Draw files |
| DropDown | |
| DummyOp | This class represents the Dummy operation |
| DXFOILFilter | Provide the OIL parts of the DXF filter |
| DynamicHeap | |
| DynArray | A temporary class to control a dynamic array of doccoords. This will be replaced by a template class whenever we can use the template directive |
| Edge | |
| EditableText | Allows a user to edit a list of items |
| EditableText::Observer | |
| EditButtonDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag. WinoilDragTargets are used as a base class from which to derive drag targets for WINOIL entities (an optional wxWindow*) |
| EditRegularShapeParam | The OpParam to use when calling OpEditRegularShape. Used to pass in the shape(s) to edit and what to change them to. ChangeShape points to a specific NodeRegularShape to edit or is NULL to indicate all slected shapes should be changed ShapeData points to a NodeRegularShape whose data members are copied into ChangeShape |
| EditSelectionOp | The Select All operation |
| EditTab | Allows the user to set any options which are normally associated with Editing. This includes such things as:- Nudge Size Duplicate distance x,y Default constraint angle Current attribute settings |
| EffectsStack | |
| ElementCoord | The OpParam to use when calling OpMovePathPoints. Used to pass in the path to alter and which coords to change |
| EllipseRecordHandler | Handles ellipse type records from the new file formatRecord handler for ellipses, used when importing ellipses from the new file format. Derived from the regular shape record handler, so we use all the functions in that class to complete the regular shape |
| EllipseTool | The QuickShape Ellipse tool |
| EndArrowAttribute | Attribute for end arrow type of paths |
| EndDocument | |
| EndRebuildMouldAction | When executed this action will get the mould to rebuild itself |
| EnhancedMetaFileOILFilter | Provide the OIL parts of the Enhanced MetaFile filter |
| EnumAllFonts | This class allows kernel level items to enumerate fonts. To use the class simply derive another from it and implement your own NewFont function. If you then call pMyEnumObj->Execute() your NewFont function will be called for every font the font manager and oil layer support |
| EnumFractalData | A class to compile information about the global fractal list |
| ENUMLOGFONT | |
| EnvelopeShapes | The default envelope shapes class. This class provides a bunch of static functions to create some default shapes. All shapes are defined on a (0,0),(72000,72000) coordinate system |
| EOLNode | Every TextLine that is created will have a EOLNode as its last child. This means that every TextLine will always have at least one child node |
| EORCacheClass | |
| EPSClipContext | Used to maintain clipping regions (masks) while importing Illustrator EPS. A stack of regions is maintained, similar to attribute rendering, with the usual save/restore semantics. Adding a new clipping region results in the new clipping region being merged with the current clipping region. In this way complex paths can be used to build up complex masks (this is the brain-damaged way AI EPS does it anyway) |
| EPSClipContextItem | USed to implement a stack of clipping regions for importing AI EPS with |
| EPSCommentDef | Describes an EPS/DSC comment, and describes how to handle it. There are four fields: |
| EPSCommentList | Wraps up the EPSCommentDef structs into a list class. This will allow me to have a changeable list for different versions of the file, and as a result the whole importing of comments much less restrictive, but at the penalty of a speed hit. Looking up a token will be on O(n) operation, rather than the much quicker array look-up that currently exists |
| EPSExportDC | Provide a device context for rendering to an EPS file |
| EPSFilter | Encapsulates a basic Adobe Illustrator EPS import/export filter. This filter can be used as a base class, because most EPS formats are based (more or less) on AI format. Derived filters can override whichever parts they want to implement other flavours of EPS |
| EPSFilter::_FontFlags | |
| EPSFlagsDefn | |
| EPSFontCache | |
| EPSRenderRegion | Encapsulates an EPS render region. This is used to export EPS files from Camelot. This class is specifically for Adobe Illustrator EPS files, although other EPS filters may derive their render region from this one |
| EPSSavedGraphicState | To store a graphic state for the EPS filter |
| EPSStack | Provides a heterogeneous stack for use when reading PostScript (EPS) files. Graeme (30/5/00) - I've replaced the array implementation that Tim originally used with a linked list. The array was originally there as a performance tweak, but increased CPU power has made this a less perceiveable gain. By using a linked list, I've made the implementation a little more error tolerant, which means that files containing stranglely placed bitmaps are now loaded |
| EPSStackItem | This class provides objects that make up an EPSStack object. The object is polymorphic, and can contain either a INT32, a double, or a TCHAR* string object |
| Error | Consists only of static variables, one for the ID of the error, another for the string, and another for the ID of the module that generated the error (0 if the error happened in the kernel). The string is a simple TCHAR array to avoid the need for dynamic memory allocation during error handling. These variables must be set whenever an error condition manifests itself. The class provides static functions to do this, which are called by the ERRORIF and NERROR macros |
| Error::StackWalker | |
| ErrorInfo | Describe the error/warning/question that is to be displayed. Fields are: MonoOn ErrorMsg - Resource ID of the error message. Title - resource ID of the dialogue title string (optional) Button - array of up to 4 button string resource IDs. OK - the button which is the 'OK' or default button, i.e. the one which should be activated by Enter (this in the range 1-4). Cancel - the button which is the 'Cancel' button, i.e. the one which should be activated by Esc (this in the range 1-4). Help - the index of the button which is the 'Help' button (this in the range 1-4). MonoOff |
| EssentialTagList | Keeps a list of all the essential tags present in the imported file |
| EssentialTagListItem | An item that appears in the EssentialTagList |
| ExportBitmap | Represents a bitmap object that has been saved out into the file already. This enables any other references to the bitmap to be output as we have a mechanism to remember that a bitmap definition has already been saved into the file and the record number it was saved under |
| ExportBitmapList | Holds a list of Bitmaps that have been exported when we are saving a Version 2 Native Camelot document out to file |
| ExportColour | Represents a colour object that has been saved out into the file already. This enables any other references to the colour to be output as we have a mechanism to remember that a colour definition has already been saved into the file and the record number it was saved under |
| ExportColourList | Holds a list of colours that have been exported when we are saving a Version 2 Native Camelot document out to file |
| ExportDC | Provide a device context for rendering to a file rather than the screen. This base class handles opening the file |
| ExportedBitmaps | Encapsulate the process of maintaining an list of Bitmaps already exported from the current document out to file |
| ExportedColours | Encapsulate the process of maintaining an list of colours already exported from the current document out to file |
| ExportFileDialog | To provide a custom open file dialog, which enables us to resize the drop down list of filters |
| ExportHint | Encapsulates the Export Hint for a document |
| ExportHintRecordHandler | Handles TAG_EXPORT_HINT |
| ExportSelection | Abstract classes representing selections of objects They're not actually used much though .. |
| ExpressView | Renders the current document into the device context given in OnDraw() This is primarily used for embedding documents |
| ExtendedPalette | |
| ExtendedPaletteEntry | |
| Extender | Preliminary container class for Extend() function. This performs automatic extension and stretching of nodes |
| ExtendParams | Parameter container for extension operation. See also: |
| ExtendSetsDlg | |
| ExternalClipboard | Handlers for external (Windows) clipboard functions. Interacts with the internal clipboard document |
| ExtParam | |
| ExtraUnicode | |
| FactorOutCommonChildAttrAct | When executed this action will factor out all attributes which are common to all children of the compound object. All common attributes become first children of the compound object |
| FeatherAttrValue | |
| FeatherProfileOpParam | |
| FeatherRecordHandler | Handles the reading of all feather records in the v2 file format |
| FGMItem | Associate the FillGeometry enum with the resource id of the text that gets displayed on the menu |
| FileDropInfo | |
| FileFormat | Dabbling with filters |
| FileInfo | The file info dialogue shows information on the selected document |
| FileListOp | This operation handles all the Recent file list menu options |
| FilePath | Represents and validates a file pathname, rather than a directory pathname |
| FileUtil | This class contains a library of static functions for use on Windows platforms. The functions perform general file manipulation operations, rather than single file data IO. If you want the size of a file, to locate a particular file on disc etc, then here's where you'll find all those useful routines to do it |
| FillAttrBlobState | Used to record the fill blob selection state to determine wether apply ops should be merged or not |
| FillAttrRecordHandler | Handles the reading of all fill attribute records in the v2 file format |
| FillBlobSelectionState | Used to record the fill blob selection state to determine wether apply ops should be merged or not |
| FilledStrip | |
| FillEffectAltRainbowAttribute | Specifies an 'alternate rainbow' graduation for fills, i.e. the same as a FillEffectRainbowAttribute, but it goes around the HSV cone in the opposite direction |
| FillEffectAttribute | Specifies the fill 'effect', i.e. how it passes from one colour to another. e.g. fade, rainbow, alternate rainbow |
| FillEffectFadeAttribute | Specifies a 'fade' graduation for fills, i.e. a simple fade in RGB space |
| FillEffectRainbowAttribute | Specifies a 'rainbow' graduation for fills, i.e. a fade through the HSV cone |
| FillGeometryAttribute | The base class for a fill geometry attribute, such as flat, linear, radial, conical, etc. This provides the basic interface for fill rendering |
| FillMappingAttribute | Specifies how a fill graduation behaves, e.g. linear, sinusoidal and so on |
| FillMappingLinearAttribute | Specifies a linear fill mapping for a filled object. This is used for normal graduated fills |
| FillMappingSinAttribute | Specifies a sinusoidal fill mapping for a filled object. i.e. the graduation sort of wibbles from one colour to another in a sort of whirly sinusoidal fashion |
| FillProfileOpParam | Serves as our param passing stuff for undo/redo of fill profile changing |
| FillRamp | The base class fill ramp. This class contains common functionality between colour and transparency ramps. Each ramp entry derived from RampItem will contain a selection state and a (float) parameter value. The parameter value usually ranges between 0 and 1 and hence can be used to generate a coordinate from any given fill geometry |
| FillTools | Provides functionality for generating a list of AttrFillGeometry nodes. This class is used by the profiling function GetProfileFromSelection (virtual overide) |
| Filter | Pure base class for import and export filters. Provides static functions to initialise and deinitialise all the available filters |
| FilterEntry | A simple ListItem derived class to allow a list of filters to be maintained - the list holds all the filters that claim to understand a particular file (see FilterFamily). It is not derived from the Filter class itself because although the Filter class is derived from ListItem too, we want to store a list of pointers to existing filters, rather than actual instances of the Filter class. For each entry, a 'compatibility rating' is held, to allow the FilterFamily class (the client of this class) to choose the most compatible filter from the list |
| FilterFamily | Special version of an import filter. This filter is actually a subset of the installed filters, to allow the user to easily specify a broad category of file rather than the exact file format and application version that they want to import (because they might not actually know!). It understands all the files that all the family of filters understand, by the simple expedient of being a generic interface to all of them. i.e. Given any file, this filter asks all the others how compatible they are with the file. It then chooses the filter that has the highest compatibility rating, and gets it to import the file |
| FilterFlags | Indicate what functions a filter is capable of |
| FilterList | Take out some of the functionality from filters |
| FilterManager | Take out some of the functionality from filters |
| FilterRenderCallback | Handling callbacks from RenderTree Notes: RenderTree function calls the main function in this class when it's about to render any Node |
| FindFiles | This class can be used for searching directories for files. It is basically equivalent to the |
| FitCurveNoChangeGeometry | This class uses the fit curve functionality to reduce the number of points in a path, whereas keeping the geometry as close to the original as possible |
| FitPoint | This class is really a vector class that is used by the curve fitting functions. It is also used as a coordinate class in the curve fitting functions, but these are really regarded as vectors from the origin. It has the following public member variables :- MonoOn double x; - The X coord of the vector MonoOff MonoOn double y; - The Y Coord of the vecotr MonoOff |
| fixed16 | |
| fixed24 | |
| FIXEDPOINT | |
| FlareTemplateFilter | A filter for the new flare template format (text based form of the the new version 2 native file filter |
| FlareTemplateHelper | Static function to convert Flare template file to binary Flare format |
| FlareTemplateOILFilter | The Flare template format Oil Filter (Extension etc) |
| FlashBitmapRecord | Maintains a record of the bitmaps used for fills |
| FlashButtonRecord | Maintains a record of the buttons used by the Flash file |
| FlashColour | |
| FlashExportDC | Outline for a Flash export DC |
| FlashFilter | Enables Camelot to export images in the Flash (SWF) file format |
| FlashFontRecord | Maintains a record of all text styles used, and the characters they contain. This is then used when exporting path records to create the DefineFont entries within a Flash format file when exporting the image. Elements are stored in a double-linked list |
| FlashOILFilter | Provide the OIL parts of the Flash 4 filter |
| FlashPlaceObject | Contains the information necessary to do a PlaceObject tag |
| FlashRenderCallback | Handling callbacks from RenderTree Notes: RenderTree function calls the main function in this class when it's about to render any Node |
| FlashRenderRegion | Provides the necessary functions to convert image data stored in the Camelot tree into the correct values for exporting to the Flash 4 format, and output these to the relevant device context |
| FlashShapeRecord | Contains the information necessary to render a DefineShape class to a file |
| FlashSprite | Contains the necessary data to generate a sprite object within a Flash file |
| FlashTextRecord | Maintains a record of the string being used |
| FlatFillAttribute | Specifies a flat fill attribute for an object, i.e. it is filled with one solid colour |
| FlatTranspFillAttribute | Specifies a flat fill attribute for an object, i.e. it is filled with one solid colour |
| FloatCoord | |
| oilHardwareManager::FloatUnion | |
| FontBase | A class which all Oil level fonts should be derived from. Its really an abstract class but contains some other functionaity too |
| FontCache | The FontCache maps a character description to a path for that character. There only ever needs to be a single instance of the FontCache so all data and methods are static |
| FontComponent | Provides a compoent to the document that handles the saving and loading of font definitions to and from the new file format |
| FontComponentClass | The document font componentA class that will add Font Components to new documents |
| FontComponentList | List header object for the list of font information held by FontComponent objects |
| FontComponentListItem | List item object used by class FontComponentList |
| FontDefRecordHandler | Record Handler for font definition records |
| FontDropDown | FontDropDown class itself |
| FontDropEnumFont | Class for enumerating the fonts for the font dropdown system |
| FontDropItem | Item class for the FontDrop system |
| FontFactory | Provide a centralised place for claiming commonly used fonts. All fonts allocated here are automatically released when Camelot shuts down |
| FontInfo | Parameter passing of info extracted from a LogFont |
| FontKerningPairsCache | A cache for the kerning pairs for a font |
| FontKerningPairsCacheEntry | Holds a cache of kerning pairs for a font |
| FontList | A class which can be used to create a font usage list. Create an instance of this class and pass its Build() function a particular document pointer. The function will create a list of used fonts in that particular document, each item of which will contain a font name and usage count |
| FontListItem | A class to describe the structure of an item held in the font usage list. An item simply contains a fontname and a usage count |
| FontManager | The font manager controlling class |
| FontMetricsCache | Holds a cache of char widths, ascent, descent and em for a particular font |
| FontMetricsCacheEntry | Holds a cache of char widths, ascent, descent and em for a particular font |
| FontsSGallery | The Fonts SuperGallery class |
| FormatArray | |
| FormatEntry | |
| FormatPosition | A class used for holding Format Positions |
| FormatRegion | A FormatRegion is a render region that is used during the formatting of characters. No actual rendering is done; the FormatRegion provides a simple way of managing the attribute stack |
| FormatState | Encapsulates state when wrapping/formatting a text line |
| FourColFillAttribute | Specifies a Four colour fill for an object |
| FourColTranspFillAttribute | Specifies a FourCol graduated fill for an object, including the start and end points |
| FractalFillAttribute | Specifies a Fractal fill attribute for an object |
| FractalTranspFillAttribute | Specifies a Fractal fill attribute for an object |
| FrameBehindOpDescriptor | New FrameBehindOpDescriptor class whose purpose is to allow an OpDescriptor to be created which allows us to over-ride the virtual function GetText |
| FrameInFrontOpDescriptor | New FrameInFrontOpDescriptor class whose purpose is to allow an OpDescriptor to be created which allows us to over-ride the virtual function GetText |
| FramePropertiesParam | Allows the transfer of data from our Frame Gallery to our current layer object |
| FramePropertiesTab | Allows the user to set various Frame properties |
| FrameSGallery | The Layer SuperGallery class |
| FreeHandEPSFilter | Aldus FreeHand 3.0 filter |
| FreeHandEPSOILFilter | Provide the OIL parts of the FreeHand EPS filter |
| FreeHandInfoBarOp | Class for handling the FreeHand tool's information bar |
| FreeHandInfoBarOpCreate | Class for creating FreeHandInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| FreeHandJoinInfo | Holds assorted data used to help join new path with existing paths |
| FreeHandTool | This class handles the Free Hand Tool that is used to draw lines that follow the path of the Mouse Pointer |
| FTFont | A class description of a font managed by FreeType |
| FTFontCacheEntry | Entry in the new font list cache - used as the value part of a key/value pair where the key is the face name wrapped in an ENUMLOGFONT structure |
| FTFontMan | A static class to allow access to fonts managed by FreeType |
| FTTypeList | Object used by CXaraFileRecord for recording type information while writing |
| Gadget | Base class for a UI element |
| GadgetBubbleHelp | |
| GadgetHelpInfo | |
| GadgetListItem | |
| GalDlgParam | |
| GalleryBar | A subclass of BaseBar that is the oil representation of a Gallery |
| GalleryBitmapDragInfo | A bitmap drag, which was started from the bitmap gallery |
| GalleryClipartDragInfo | A fill drag, which was started from the fill gallery |
| GalleryColourDragInfo | |
| GalleryContextMenu | Implements the SuperGallery context sensitive menus |
| GalleryFillsDragInfo | A fill drag, which was started from the fill gallery |
| GalleryFontsDragInfo | A fill drag, which was started from the fill gallery |
| GalleryLibFontsDragInfo | A fill drag, which was started from the fill gallery |
| GalleryLineDragInfo | A Line attribute drag, which was started from the line gallery |
| GalleryNameDragInfo | |
| GBlend | |
| GBrush | A GBrush is a way of getting to Gavin-created brushes, when available. It can supply GDI with better dithered brushes than it does normally. Before use, you should call Init which tells you whether a GBrush is available. If it is not, no further use can be made of it. If it is, call Start on it (cv StartRender). It can then be used, until such time as End is called on it. An in-line member function called Available can be used to determine its functionality at any time. There can only be one active GBrush in use at a time |
| GCONTEXT | |
| GDrawAsm | A C++ wrapped around the assembler in GDRAW.DLL |
| GDrawBorrower | |
| GDrawContext | To put a C++ wrapper around the GDraw DLL. Also allows non-Gavin originated GDraws (e.g. XDraw) to be dropped in as required. This class is almost a pure base class - inherited classes have to have their own functions for almost everything |
| GeneralAttrRecordHandler | Handles the reading of all attribute records in the v2 file format that are not line or fill attributes |
| GeneralRecordHandler | This is the general record handler. It handles all the general record types, such as the End Of File, file header, etc |
| GenerateIndexFile | For generating of index files |
| GenericDownloadParam | File Download param, download a file in the OpMenuImport::Do(). Download operation parameter structure - passes the minimum necessary information to the Op |
| GenericEPSFilter | A filter for all EPS files, regardless of the flavour |
| GenericFilter | A filter for all file types. This is the default filter that the user can import with |
| GEnvelope | The low level enveloper class |
| GEnvelope2x2 | The low level enveloper class |
| GeometryLinkedAttrValue | |
| GIFAnimationExportParam | Passes infomation about the GIF animation and its bitmap(s) being exported |
| GIFAnimationPropertyTabs | These encompass all the tabs available for the Animation properties dialog box to use |
| GIFAnimationPropertyTabsDlg | |
| GIFExportFileDialog | To provide a custom open file dialog for GIF Animation Export. This class has been derived because the help system uses the name of the class - in this case, "ExportFileDialog" - to determine which help page the button should link to. In order to get this help button to link to a separate "Export Animated GIF" help page, we have created a derived class of "ExportFileDialog" that the Export Animated GIF command can display |
| GIFExportOptions | Base class for storing information about the bitmap we're exporting |
| GIFImportOptions | Import options for the GIF filter. Allows a clean method of passing assorted parameters for the GIF filter. Specifically, that the BaseBitmapFilter should give us a progress bar. Scope: public See Also: BitmapImportOptions |
| GIFImportResults | Provides the results for the import of a GIF Notes: m_bValid should be checked for TRUE after any construction because the constructor can fail Scope: public |
| GIFOILFilter | Provide the OIL parts of the GIF filter which loads in the file as a BMP |
| GIFUtil | Contains functions to read in a GIF file as a DIB |
| GlobalBitmapList | A list of Greyscale bitmaps A list of all the OIL Bitmaps available in the application |
| GlobalFractalList | A list of all the Fractals available in the application |
| GMATRIX | |
| GMould | |
| GPerspective | The perspective function class |
| GrabFrameFilter | Special filter used to convert the selected frame into a bitmap |
| GradEndCol | |
| GradFillAttribute | Base class for a graduated fill attribute to be derived from. It includes one vector (stored as two coordinates) to represent the basic direction of the fill. Some fills will need more vectors (e.g. radial fills) but they can just add data fields in their derived classes |
| GradFillTool | The fill tool |
| GradInfoBarOp | Class for handling the gradfill tool's information bar |
| GradInfoBarOpCreate | Class for creating GradInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| GradTable | A kernel representation of a graduation table. (This is a table of 8-bpp dither pattern specifiers for GDraw) |
| GradTable32 | A kernel representation of a 32 bpp graduation table. (This is a table of COLORREF RGB values for GDraw) |
| GradTranspFillAttribute | Base class for a graduated fill attribute to be derived from. It includes one vector (stored as two coordinates) to represent the basic direction of the fill. Some fills will need more vectors (e.g. radial fills) but they can just add data fields in their derived classes |
| GraduationTable | |
| GraduationTable32 | |
| GRECT | |
| GRenderBitmap | A GDraw render region that uses normal DIBs for the bitmap and can save itself out into an OIL bitmap |
| GRenderBrush | A GDraw render region that uses normal DIBs for the bitmap. It serves a particularly special purpose in that it provides a number of functions that allow us to blit to the screen very quickly without getting tangled up in the render loop. This is so that we can draw brush strokes and have them appear on the screen in real time. This is achieved by maintaining not one but four static bitmaps. These work in the following way: |
| GRenderClick | Special version of a GRenderRegion that renders into a mono bitmap. It is used for hit-detection only. It can also be asked if it is 'blank' |
| GRenderClickColour | Special version of a GRenderClick that renders into a colour bitmap. It is used for colour picker hit-detection/pixel colour detection only |
| GRenderClickColourNoPaper | Special version of a GRenderClick that renders into a colour bitmap. It is used for hit-detection. The only difference between this and GRenderClickColour is that when it attaches to a CCDC that CCDC's NeedsPaper function will return FALSE |
| GRenderDIB | A GDraw render region that uses normal DIBs for the bitmap |
| GRenderOptPalette | A GDraw render region that generates an opimised palette for the output bitmap |
| GRenderPrint | A GDraw render region that uses normal DIBs for the bitmap and can output the result to a printer |
| GRenderRegion | Encapsulates rendering using Gavins routines (ie. into a bitmap). This object is created when something needs rendering using Gavins routines eg. When anti-aliasing. See RenderRegion notes for more general details of this class. This is an abstract class - see GRenderDIB or GRenderDDB for implementations |
| GRenderRegionWrapper | |
| GRenderWinG | A GDraw render region that uses normal DIBs for the bitmap and WinG to blit them |
| GridFlagsType | |
| GridInfoBarOp | Class for handling the grid tool's information bar |
| GridInfoBarOpCreate | Class for creating GridInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| GridResizeInfo | |
| GridTab | Allows the user to set any options which are normally associated with the document's default grid and hence the page rulers. This includes such things as:- Grid and rulers origin Grid and rulers spacing and divisions Grid type |
| GridTabAppPrefsDlg | To open up the application preference's dialog box with the grid tab selected. This is used by the pop up menu when on the ruler |
| GridTool | A Tool for creating and editing grids |
| GroupRecordHandler | Handles the reading of all line attribute records in the v2 file format |
| GuidelineListItem | Used to generate a sorted list of guidelines within a layer |
| GuidelinePropDlg | Allows the user to change the properties of a guideline |
| GuidelinePropDlgParams | Parameters needed for the guideline properties dlg to function correctly |
| GuidePropertiesDlg | To open up the layer properties tabbed dialog box with the guide's tab selected. This is used by the guides pop up menu |
| GuidesPropertiesTab | Allows the user to set various layer properties, such as:- |
| GX2OILFilter | Provide the OIL parts of the GX2 filter which loads in the file as a BMP |
| GZipFile | A file stream compressor and decompressor. Allows the CCDiskFile to offer compression of files. At present just used to compress the native file format |
| GZipStream | A file stream compressor and decompressor. Allows the CCDiskFile to offer compression of files. At present just used to compress the native file format |
| HaloCUTOILFilter | Provide the OIL parts of the HaloCUT filter which loads in the file as a BMP |
| HandleBecomeA | Objects of this class are passed into NodeBlender::CreateBlends() so that they can receive all the paths the blender generates in order to convert the blender into shapes (or more specifically NodePaths) |
| HandleBrushBecomeA | This class of object is used to store the paths and attribute maps generated for each individual brush object generated by a brushed ink node. It can either turn these paths into nodepaths for insertion into the tree of pass them back for whatever salicious reason |
| HandleFlags | Used to determin what to do when rendering drag handles. ie which handles should be rendered and how they relate to the drag mouse coord |
| HandleRecord | Table entries used by the HandleTable class. This class currently supports pen handles and brush handles. Other handles (e.g. Fonts) will be added as necessary |
| HandleTable | Provide a mirror of the table of handles maintained by GDI when importing a MetaFile. This is necessary because, given a GDI handle, it is not possible to ask GDI what kind of object it is, and hence work out e.g. what kind of pen/brush it is. This class therefore creates, selects, and deletes handle objects in the same way that GDI would (see EnumMetafile help in SDK documentation for further details...possibly). At the moment, this HandleTable only supports pens and brushes |
| HandleTableStruct | |
| HelpDownloadDlg | |
| HelpDownloadOp | |
| HelpDownloadParam | File Download param, download a file in the OpMenuImport::Do(). Download operation parameter structure - passes the minimum necessary information to the Op |
| HelpOps | This class is used for all the Help Operations found on the help menu |
| HideColoursInfo | An operation which will delete |
| HideNodeAction | When executed this action will hide a node. It will also generate a ShowNodeAction action adding it to the opposite Action list |
| HidePropScan | |
| HidePropScan::HideProp | |
| HideScan | Hides names of objects and their properties which are highlighted members of the 'Used Names' group in the Attribute gallery; hides a specified name of objects |
| HideScan::HideItems | |
| HideSingleScan | |
| HorizontalRuler | Encapsulates horizontal ruler |
| HorizontalTab | A horizontal tab character |
| HotKey | Encapsulates hot keys in camelot |
| HTMLExportFilter | The HTML export filter base class |
| HTMLFileList | List of Item |
| HTMLFileListItem | Item to add in the list |
| HTMLFilter | A filter for html file, recognise only tags containing bitmaps |
| HTMLOILFilter | Provide the OIL parts of the HTML filter |
| IAsynchDownLoad | |
| ICommandControl | Interface definition for the ICommandControl interface. This will be supported by a RalphDocument |
| ICreation | Interface definition for the ICreation interface |
| IErrorCallback | |
| IEventCallback | Interface definition for the IEventCallback interface. This interface will be implemented by a Harness that needs to respond to events sent from a RalphDocument. The interface is registered with a RalphDocument thru a call to IInitRalph::SetEventCallback. Note that it is not derived from IUnknown as there is no reason for it to have AddRef, Release, QueryInterface methods |
| IFFOILFilter | Provide the OIL parts of the IFF filter which loads in the file as a BMP |
| IInitRalph | |
| ImageAndBitmap | |
| ImageMagickExportOptions | |
| ImageMagickFilter | Encapsulates a ImageMagick export filter. Derives off the masked filter which provides funcitonality for doing masked bitmap export and import |
| ImageMagickFilterBMP | |
| ImageMagickFilterCUR | |
| ImageMagickFilterCUT | |
| ImageMagickFilterDCM | |
| ImageMagickFilterDCX | |
| ImageMagickFilterDIB | |
| ImageMagickFilterDNG | |
| ImageMagickFilterEPDF | |
| ImageMagickFilterEPI | |
| ImageMagickFilterEPS | |
| ImageMagickFilterEPS2 | |
| ImageMagickFilterEPS3 | |
| ImageMagickFilterEPSF | |
| ImageMagickFilterEPSI | |
| ImageMagickFilterEPT | |
| ImageMagickFilterFAX | |
| ImageMagickFilterFITS | |
| ImageMagickFilterICO | |
| ImageMagickFilterJNG | |
| ImageMagickFilterMIFF | |
| ImageMagickFilterMPC | |
| ImageMagickFilterOTB | |
| ImageMagickFilterP7 | |
| ImageMagickFilterPALM | |
| ImageMagickFilterPAM | |
| ImageMagickFilterPBM | |
| ImageMagickFilterPCD | |
| ImageMagickFilterPCDS | |
| ImageMagickFilterPCL | |
| ImageMagickFilterPCX | |
| ImageMagickFilterPDB | |
| ImageMagickFilterPDF | |
| ImageMagickFilterPGM | |
| ImageMagickFilterPICT | |
| ImageMagickFilterPIX | |
| ImageMagickFilterPNM | |
| ImageMagickFilterPPM | |
| ImageMagickFilterPS | |
| ImageMagickFilterPS2 | |
| ImageMagickFilterPS3 | |
| ImageMagickFilterPSD | |
| ImageMagickFilterPTIF | |
| ImageMagickFilterPWP | |
| ImageMagickFilterRLA | |
| ImageMagickFilterRLE | |
| ImageMagickFilterSCT | |
| ImageMagickFilterSFW | |
| ImageMagickFilterSUN | |
| ImageMagickFilterSVG | |
| ImageMagickFilterTGA | |
| ImageMagickFilterTIFF | |
| ImageMagickFilterTIM | |
| ImageMagickFilterTTF | |
| ImageMagickFilterVICAR | |
| ImageMagickFilterVIFF | |
| ImageMagickFilterWBMP | |
| ImageMagickFilterWPG | |
| ImageMagickFilterXBM | |
| ImageMagickFilterXCF | |
| ImageMagickFilterXPM | |
| ImageMagickFilterXWD | |
| ImageMagickOILFilter | The PNG File format Oil Filter (Extension etc) |
| Imagemap | This is a list of clickable areas |
| ImagemapClickableArea | This class represents a clickable area |
| ImagemapClickableCircle | This class represents a clickable circle |
| ImagemapClickablePolygon | This class represents a clickable n-sided polygon |
| ImagemapClickableRectangle | This class represents a clickable rectangle |
| ImagemapDlg | |
| ImagemapFilter | The imagemap export filter class |
| ImagemapFilterOptions | An ImagemapFilterOptions object contains all the information the ImagemapFilter needs to set itself up ready for export |
| ImagemapOILFilter | The Imagemap Oil Filter |
| ImagemapRenderRegion | The render region for the imagemap filter |
| ImagesettingAttrRecordHandler | |
| ImagesettingAttrValue | Base class from which all binary imagesetting attribute values are derived |
| IMGOILFilter | Provide the OIL parts of the IMG filter which loads in the file as a BMP |
| ImportBitmap | Represents a bitmap object that has been loaded in from the file already. This enables any other references to the bitmap to be resolved as we have a mechanism to remember that a bitmap definition has already been loaded into the file and the record number it was loaded under |
| ImportBitmapList | Holds a list of Bitmaps that have been exported when we are saving a Version 2 Native Camelot document out to file |
| ImportedBitmaps | Encapsulate the process of maintaining an list of Bitmaps already exported from the current document out to file |
| ImportedColours | Encapsulate the process of importing a number of colours into a document. This object maintains a list of colours to be imported, and implicitly handles all the merging/duplication problems that may occur |
| ImportedNewColour | A structure to hold a new colour, which can be represented in any colour model. Uses a ColourGeneric which must be cast because C++ can't do unions in any useful way |
| ImportedString | Encapsulates an imported string that's come from the a v2 format file |
| ImportedStringList | Used to manage a list of ImportedString objects |
| ImportFileDialog | To provide a custom open file dialog, which enables us to resize the drop down list of filters |
| ImportPosition | |
| IndexedColour | Definition of a colour, stored to high (128-bit) precision. DocColours in the Document may refer to IndexedColour objects from which they are defined |
| IndexedColourInfo | |
| IndGenFileBuffer | Since MSDOS seems happy returning filenames of files in a directory in a completely random fashion, we need to have some way of storing all the ones it returns us and sorting them alphabetically, so we can generate index files in a nice alphabetical order |
| inflate_blocks_state | An inflate blocks state object for use by the inflater for the file compressor and decompressor |
| inflate_codes_state | An inflate codes state object for use by the inflater for the file compressor and decompressor |
| inflate_huft_s | |
| InflateState | An inflate state object for use by the inflater for the file compressor and decompressor |
| InfoBarOp | |
| InfoBarViewOp | |
| InformationBarOp | The kernel version of info bar |
| InitBlendAction | |
| InitBlendersAction | An action which deinits or reinits a blend |
| InitNodeBlendPathAction | An action which destroys the cached info in a blend path node |
| InputManager | This provides support for all Input Devices |
| InsertFloaterAction | An action to provide the Line tool with an undoable way of inserting the floating endpoint. This isn't stored in the document, which makes life tricky |
| InsertFloaterParam | This is the OpParam object passed to OpInsertFloater to position the floating endpoint |
| InsertionNode | |
| InsertLevelStack | Holds a list of level items The class gives the list a stack-like interface |
| InsertLevelStackItem | This item holds all the info for a given insert level of the tree. It is used when building the tree on import |
| InsertPathElementAction | An action which undoes the removal of an element into path data (hence replacing the deleted data) |
| InsertTreeContext | Structure for saving and restoring tree insertion contexts. This is used by things like print marks and brush stroke definitions, which embed a subtree definition in the file, but want to import it somewhere other than into the document tree |
| InsetPathPathProcessor | Makes sure the original nodes aren't rendered, if the active flag is set |
| internal_state | |
| InternalClipboard | Camelot's internal clipboard document |
| InternalClipboardFormat | This class is a very simple class which describes an internal clipboard data format. Each ClipboardMapping uses one of these to describe the type of input data they require in order to export, and thes export mappings will only be available to the clipboard if at least one node in the InternalClipboard supports output in this internal format |
| InternetManager | Webster connection/download manager. It is responsible for schedulling downloads for execution according to the priority declared by the client on registration, ensuring that no more than a preset number of connections are open at any one time (important for users with limited bandwidth), and otherwise keeping track of their fate. The sheduling sheme is as follows:
- downloads with AsynchDownload::PRIORITY_NORMAL will be executed one at a time, as long as there are no high priority downloads queued up and the maximum number of connections is not exceeded. They all share the same progress dlg, which is hidden when there are no downloads scheduled
- downloads with AsynchDownload::PRIORITY_HIGH will be executed simultaneously, up to the maximum no of connections. Each download gets its own progress dlg
|
| InternetTab | Allows the user to set Internet-related options |
| InvalidateArbitaryAction | When executed this action will Force a redraw of the bounding rectangle it contains |
| InvalidateBoundsAction | An action which invalidates the bounds of a node |
| InvalidateRectAction | When executed this action will Force a redraw of a bounding rectangle over a certain spread |
| InvalidateRegionAction | When executed this action will Force a redraw of the bounding rectangles of each node in a range |
| InvalidateRegionIfBgRedrawAction | When executed this action will Force a redraw of the bounding rectangles of each node in a range. This version will only invalidate the region if Background Redraw is in progress |
| IOCAOILFilter | Provide the OIL parts of the IOCA filter which loads in the file as a BMP |
| IProfile | |
| Item | |
| IUnknown | |
| IViewControl | |
| JCWColourFilter | Load's Jason's private palette file format |
| JCWColourOILFilter | Provide the OIL parts of the Jason palette filter |
| JoinInfo | |
| JoinShapesBecomeA | This is the class that is passed to other nodes when the combine op gets them to to turn into other types via their DoBecomeA() method |
| JoinTypeAttribute | Attribute for join types of paths |
| JPEGBitmapSource | |
| JPEGDataDestination | Provides an overridden version of the IJG library source manager, using CCFile's |
| JPEGDataDestination::IJGDestMgr | |
| JPEGDataSource | Provides an overridden version of the IJG library source manager, using CCFile's |
| JPEGErrorManager | Provides an error handler for the IJG JPEG Library. Specifically it uses standard Camelot practices to cope with errors generated within the library. Scope: public |
| JPEGExportFilter | Provides an Accusoft-free JPEG export filter |
| JPEGExportOILFilter | OILFilter for non-Accusost version of JPEG export filter |
| JPEGExportOptions | Allows JPEG specific export options to be manipulated |
| JPEGExportPrefsDialog | Provides a dialog asking for user options in the JPEG export |
| JPEGImportFilter | Provides a JPEG import filter using the IJG JPEG LIBRARY |
| JPEGImportOILFilter | OILFilter for non-Accusost version of JPEG import filter |
| JPEGImportOptions | Import options for the JPEG import filter. Allows a clean method of passing assorted parameters for the JPEG import filter. Specifically, that the calling class should give us a progress bar. Scope: public See Also: BitmapImportOptions |
| JPEGOILFilter | Provide the OIL parts of the JPEG filter which loads in the file as a BMP |
| JPEGProgressByFilter | Provides progress update callback for the IJG library JPEG Filters using the Update member of the Filter class |
| JPEGProgressBySelf | Provides progress update callback for the IJG library JPEG Filters using a self-contained Progress object |
| JPEGProgressMonitor | Provides progress update callback for the IJG library JPEG Filters |
| KernCode | A Kern code |
| KernelBarPos | To assist in transfer of BarPosition Data between OIL and Kernel Layers |
| KernelBitmap | To encapsulate bitmaps, which are implemented in the OIL layer. Kernel code is only allowed to use this interface. OIL code is allowed to use the specific OILy functions that can be done via the OILBitmap pointer |
| KernelBitmapRef | A reference to a KernelBitmap object |
| KernelBmpListItem | Holds a pointer to a KernelBitmap for tracking the creation of bitmaps for cleanup purposes. This class should be eliminated by modifying the bitmap classes to correctly reference count and handle the concept of temporary bitmaps |
| KernelDC | Provide a base device context for rendering to something other than the screen. This includes printers, files, and PostScript devices |
| KernelDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag. KernelDragTargets are used as a base class from which to derive drag targets for KERNEL entities (usually a DialogOp and optional Gadget ID) |
| KernelStatistics | |
| KernelTimer | A class exposing a timer to the kernel Notes: In the OIL See Also: |
| KernelTimer::CamTimer | |
| KeyMsg | This is sent when a key press occurs that hasn't yet been processed by other parts of the key press handing system, such as the current too, temporary tool switching, and the hot-key system |
| KeyPress | Encapsulates key presses in camelot |
| KeyPressSysMsg | Represents a key press message that is slightly more abstract than the raw Windows message. This will hopefully aid the porting of this code to other platforms |
| KOFAXOILFilter | Provide the OIL parts of the KOFAX filter which loads in the file as a BMP |
| LaserDataOILFilter | Provide the OIL parts of the LaserData filter which loads in the file as a BMP |
| Layer | Layers optionally exist on a page, they group together objects which are drawn at a particular level in a document |
| LayerColourAction | An action which changes the colour of a guide layer |
| LayerDlg | The Layer dialog allows a user to |
| LayerDlgParam | Holds the parameters for the LayerNameDlg to perform its stuff on |
| LayerManager | The LayerManager is used to make changes to layers in the document tree. It holds a pointer to a current spread, and a list of layer details for the current spread (LyrDetLst). The layerDlg and InfoBar make changes to layers in the current spread indirectly by changing the LyrDetList. Layer changes are deferred until the CommitLayerChanges() method is called. Changes made to the LyrDetList can also be cancelled by calling the CancelLayerChanges() method |
| LayerMsg | Messages detailing specific changes to layers |
| LayerMsgHandler | Intercepts messages to ensure that layers are up to date |
| LayerNameDlg | Allows the user to edit the parts of a layer |
| LayerPropertiesDlg | To open up the layer properties tabbed dialog box with the layer's tab selected. This is used by the layers pop up menu |
| LayerPropertiesTab | Allows the user to set various layer properties, such as:- |
| LayerPropertyTabs | These encompass all the tabs available for the layer properties dialog box to use. Derived off the baseclass which has a lot of globally useful functionality for all property tabbed dialog box handlers. This is just derived of the list class |
| LayerPropertyTabsDlg | |
| LayerSGallery | The Layer SuperGallery class |
| LayerStateAction | An action which changes the state of a layer or the layer system |
| LayerStatus | This class (structure) holds layer information which can be changed by the user. The reason that this information is held in a seperate class is that it needs to be stored in both the Layer and Layer Manager classes |
| LegendLabel | This is the class for the "set origin" gadget, |
| LessBitmapCacheKey | |
| LibClipartSGallery | The LibClipart SuperGallery class |
| LibColourFlags | This DisplayTree node is used by the Colour SuperGallery It is responsible for providing the ability to handle/redraw one library colour displayed in said gallery |
| LibFillsSGallery | The LibFills SuperGallery class |
| Library | This is the main super gallery library group creation class... Creating one of these will create a single group in your gallery. It will contain items for each entry in the sub-lib |
| LibraryFile | This is the main super gallery library creation class... Creating one of these will give your gallery a set of new sub-lib groups containing DisplayItems for the entries in the sub-group |
| LibraryGallery | A base library gallery class with common library gallery stuff in |
| LibSettings | The Gallery Resource Management class.. |
| LibSettingsListItem | Memory list of section lines to speed GRMFile reading up somewhat |
| LinearFillAttribute | Specifies a linear graduated fill for an object, including the start and end points |
| LineArrowItem | Class to represent a arrowhead/tail user-interface item within the line gallery |
| LinearTranspFillAttribute | Specifies a linear graduated fill for an object, including the start and end points |
| LineAttrGroup | Specialises the SGDisplayGroup class, overriding the function that builds up the title string. This derived class can have any string as its title |
| LineAttrItem | This DisplayTree node is used by the Line SuperGallery It is responsible for providing the ability to handle/redraw one LineAttrItem displayed in said gallery |
| LineAttrRecordHandler | Handles the reading of all line attribute records in the v2 file format |
| LineCapItem | Represents a line-cap user-interface item within the line gallery |
| LineComponent | A document component for handling Line definitions |
| LineDashItem | Represents a line dash-pattern user-interface item within the line gallery |
| LineData | |
| LineDefinition | Stores a vector Line definition A static list of these items is held in the LineComponent |
| LineEdge | |
| LineGallery | The Line SuperGallery class Notes: SuperGalleries are specced in a number of docs including specs.doc ("super" gallery extensions) specs.doc (gallery basic ui) There is also howtouse.doc which describes creating a supergallery |
| LineJoinTypeItem | Represents a line-join user-interface item within the line gallery |
| LineNoArrowItem | Class to represent a no-arrowhead/tail user-interface item within the line gallery. Only used as a base class for LineNoStartArrowItem and LineNoEndArrowItem |
| LineNoEndArrowItem | Class to represent a no-start-arrowhead/tail user-interface item within the line gallery |
| LineNoStartArrowItem | Class to represent a no-start-arrowhead/tail user-interface item within the line gallery |
| LinePropertiesDlgParam | |
| LineStrip | |
| LineWidthAttribute | Represent a line width of a path. This may be a simple stroking operator such as a constant line width, or a complex one such as variable line widths or an airbrush stroke operator |
| LineWidthItem | Represents a line-width user-interface item within the line gallery |
| List | |
| ListControl | Represents a List in a DialogOp |
| ListFill | Relatively generic Gradient Fill holder class, so that gradient fills can be stored in a linked list (mainly used while scanning for grad fills) |
| ListItem | A list item is an abstract class which is used to derive all objects which are linked together in lists. It has no member functions because all useful operations are defined in the List class. The reason for doing this is that list operations may need to alter the list header |
| ListItemIdx | A ListItem that points to another ListItem. Used to created list indexes |
| ListItemOpPtr | To enable storage of pointers to operations on lists |
| ListItemPtrItem | A ListItem object which is a pointer to a ListItem, used by the MarkedStack class |
| ListListItem | A ListItem with a 'list' in it. Useful for lists of lists. The destructor deletes all items in its List |
| ListRange | This class represents a list of explicitly declared nodes (rather than the implicitly chosen nodes controlled by RangeControl flags) |
| ListStepper | This class it used to step along two lists, choosing matching pairs. This really comes into play when you have different numbers of items in the two lists, and you want to step along them without missing out any items. E.g. List A contains 4 items, list B contains 2 items this would produce the following pairs: A B 0 0 1 0 2 1 3 1 E.g. List A contains 3 List B contains 5 A B 0 0 0 1 1 2 1 3 2 4 |
| ListT< T > | Generic List |
| ListT< T >::ConstIterator | |
| ListT< T >::Iterator | |
| ListT< T >::ListNode | |
| LiveEffectRecordHandler | Handles the reading of live effects records |
| LiveEffectsInfoBarOp | Class for handling the FreeHand tool's information bar |
| LiveEffectsInfoBarOpCreate | Class for creating LiveEffectsInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| LiveEffectsTool | This class implements the Live Effects tool that allows the use to apply live bitmap effects to objects |
| LoadBrushDirect | Class is used to load a document containing the default brushes on startup. Most of the action takes place in the base class |
| LoadContext | To encapsulate all data local to a download |
| LoadDirect | This class allows the caller to load a xara document in, process the data held inside and close the document again. You should derive your own class and override the OnLoadDocument() function. You'll be given a CCamDoc and Document* which can be used to access data within the doc. On return from OnLoadDocument, the document will be destroyed |
| LoadPrintMarks | A derived class to load the print marks. Uses the winoil class LoadDirect |
| LoadRegistryEntries | This class can be used for loading a list of items into the registry |
| LocaleChangedMsg | This message is sent whenever the locale information changes, eg keyboard layout, decimal character, etc.. |
| LocalEnvironment | Provide access to the locale settings Camelot is running under |
| LocaliseCommonAttrAct | This action copies all attributes common to the group to each child object within the group which requires each attribute. The groups common attributes are deleted |
| LOGBRUSH | |
| LOGFONT | |
| LogicalCoord | |
| LOGPALETTE | |
| LyrDetails | LyrDetails objects are stored in a list within the LayerManager. They record changes made to a layer |
| MacPaintOILFilter | Provide the OIL parts of the MacPaint filter which loads in the file as a BMP |
| MakeBitmapExportOptions | Allows "Create Bitmap Copy" to provide own defaults |
| MakeBitmapFilter | Special filter used to convert the selection into a bitmap |
| MarkEditListAction | An action to record/restore the current state of the LiveEffect EditList. An action to record/restore the current state of the LiveEffect EditList |
| MarkedStack | A marked stack is a special purpose stack/list. Its properties are described: |
| MarkFormat | |
| MarkFormatRegion | The mark formatting region. Given a doc rect ie the position of the region around the page, this class can be used to work out the position of the marks which need to be formatted in this region ie those marks which have been specified by the user to fall into this position. As one adds marks, the formatting region updates itself and keeps track of all mark positions. You can then call the formatting regions render function which will use the positions so generated to render each mark within it. On rendering, each mark will be asked to render itself at a given position |
| MarkList | Holds an array of up to 8 marks formatted into a particular position eg middle centre in a particular region (of which there can be 16 around a page) |
| MarkPosition | An instance of a mark lives in a particular region and not only this, contains a format and a transform |
| MarkPosType | |
| MaskedFilter | Encapsulates a masked filter which provides funcitonality for doing masked bitmap export and import |
| MaskedFilterExportOptions | Base class for storing information about the bitmap we're exporting |
| MaskedRenderRegion | The Masked Render region is used when rendering to regions that can not do all the fabby things that GRender Regions are capable of (eg Transparancy). They are used as part of the 3 phase rendering process, in the middle phase. In this phase all the objects that are deemed to be too complicated to be rendered by the host render region are actually rendered into a GRenderRegion. Each of the individual objects that are complex are also rendered into this Mono Masked Render Region. At the end of the process this Masked Render region is used to identify the minimum area of the render region that needs to be blitted into the host render region |
| MaskPair | |
| MaskRegion | |
| Matrix | Represents a mathematical transformation matrix. Transformation matrices can transform the coordinate pairs of one coordinate space into another coordinate space. Matrices are used in Camelot for the rendering process in various ways. These include coordinate conversion, scaling, rotation and translation |
| MatrixFitToPathAction | This action is used when fitting a TextStory on a path in order to undo matrix changes |
| MatrixRemoveFromPathAction | This action is used when fitting a TextStory on a path in order to undo matrix changes |
| MemoryBlock | |
| MemTrackExtra | Holds the info that we use in the memory tracking code. It is a doubly linked list that tells us how big a block is, where it was allocated etc |
| MenuItem | MenuItems are the things that appear in menus, but in camelot they are also the menus themselves. The idea is that the menu system is a dynamically growing, living-thing where all the elements are connected in a tree like structure. The elements of the menu system or the nodes in the tree are MenuItems. MenuItems can therefore be simple or composite i.e. a menu option or a sub menu. In windows there is a third type of MenuItem: the separator, in our new improved menuing system separators will not be modelled as MenuItems. Instead a MenuItem may be specified as having a menu separator following it |
| MenuPopupOps | This class represents All the Menu Popup operations |
| MeshNodeListItem | |
| MessageHandler | If a system object must respond to system messages then its class should be derived from the abstract MessageHandler class. When a MessageHandler is constructed it gets added to a list of MessageHandlers which are all targets of system messages. To send a message to all or just a subset of MessageHandlers, you should use the static Broadcast method. The virtual 'Message' function is called whenever the MessageHandler is sent a message |
| MessageHandlerList | A MessageHandlerList contains a List of MessageHandler objects derived from the same runtime class |
| METADATA | |
| MetaFileClipMap | A class which describes and implements an available mapping between internal and external data formats |
| MetaFileFilter | Encapsulates a filter for importing Windows MetaFiles (16-bit only at the moment) |
| MetaFileFilter::CImportInfo | |
| MetaFileOILFilter | Provide the OIL parts of the MetaFile filter |
| MetafileView | Simple view class for metafiles to use when rendering via a Camelot RenderRegion |
| MillipointKerningPair | Same as windows structure KERNINGPAIR but using millipoints |
| MiscTab | Allows the user to set any options which are either too specific to have an associated tab or just do not fit any where else. This includes such things as:- Save preferences on exit switch and save preferences now button. Nudge Size Duplicate distance x,y Default constraint angle Current attribute settings |
| MitreLimitAttribute | Attribute for mitre limits of paths |
| ModifyElementAction | An action which undoes the modification of a single element of path data. This action can be used for undoing changing coordinates or flags or verbs. This action is not really suitable if you have a lot of path data to change - ModifyPathAction is more efficient because it encodes multiple elements. This action was written because for single elements, ModifyPathAction is too complicated to call |
| ModifyFilledAction | An action which undoes the modification of a path's filled bit (or redoes it) It can also be used to undo the IsStroked flag as well |
| ModifyFlagsAction | An action which undoes the modification of a path element's flags. This is a smaller action that ModifyElementAction and is more economic for undoing selection change |
| ModifyPathAction | An action which undoes the modification of path data. This action can be used for undoing changing coordinates or flags or verbs. Other actions will exist for adding or deleting elements from paths. This action is useful for undoing large amounts of path editing (e.g. dragging several points around) but is less useful for undoing the alteration of single coordinates. Another Action might be created later for undoing single element alterations |
| ModInfo | Holds details about a module. This class will always be derived from the latest version of the ModInfo_vnn class. Having this class means that the source only needs to be changed in one place when the ModInfo spec changes.Text string describing the purpose of the module |
| ModInfo_v1 | Holds details of a Module. See ModInfo for details |
| Module | The Module type reflects the latest Module specification. Do NOT subclass from Module, but use the latest Module revision (e.g. Module_v42). The Module type should only be used by the Kernel and OIL layers, never by Modules themselves |
| Module_v1 | Module interface definition. See Module for details |
| ModuleList | Used by the kernel to hold information on all the modules it currently knows about. It has an overloaded Add function which will only add modules if their ID has not already been used by another module |
| ModuleListItem | Used by the kernel to hold information on a particular module |
| MonotonicTime | This class stores samples of the ever-increasing system ticker (the "monotonic clock" in Archy speak) and stores them. The samples can then be manipulated by member functions |
| MouldAttribute | Specifies wether the attributes are moulded or not |
| MouldBecomeA | This is the class that is passed to other nodes when the mould tool is trying to turn them into other types via their DoBecomeA() method |
| MouldEnvelope | The envelope mould node. Provides control over a coons patch shape made from 4 connected 3rd order bezier splines |
| MouldEnvelope2x2 | Another envelope mould. Provides control over a coons patch shape made from 2x2 4 connected 3rd order bezier splines |
| MouldEnvelopeBase | The envelope mould node. Provides control over a coons patch shape made from 4 connected 3rd order bezier splines |
| MouldGeometry | An abstract base class for mould shapes |
| MouldInfoBarOp | Class for handling the tool's information bar |
| MouldInfoBarOpCreate | Class for creating MouldInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| MouldPerspective | The perspective mould class. This mould implements a rectangular transform with true perspective |
| MouldRecordHandler | Handles the reading of all mould records in the v2 file format |
| MouldTool | A template tool class |
| MouldTransform | Defines the mould transform class. This class is used by a moulder when it needs to ask other objects to transform themselves geometrically. It provides various functions for nodes to call to transform coordinates or paths |
| MovePointsParams | |
| Msg | The base Msg class from which all messages must be derived |
| MSIconsOILFilter | Provide the OIL parts of the MSIcons filter which loads in the file as a BMP |
| MSPaintOILFilter | Provide the OIL parts of the MSPaint filter which loads in the file as a BMP |
| MSPaletteFilter | Microsoft Windows palette filter |
| MSPaletteOILFilter | Provide the OIL parts of the Windows Palette file filter |
| MTRand | |
| MultiAppliedAttribute | Represents an applied attribute of which there is only one for the objects given by the iterator |
| MultiCommonAttrItem | This ListItem is used by Range::FindCommonAttributes |
| MultipleBitmapSelection | |
| MyFontEnumerator | |
| NamedExportProp | Class to manage the UI and execution of batch-export properties |
| NameDialog | Allows the user to edit the parts of a layer |
| NameDialogParam | Allows a string (the Name) to enter and emerge from a NameDialog, and tells us if the dialog was cancelled |
| NamedSliceProp | Class to manage the UI and execution of slice properties |
| NamedStretchProp | |
| NamedTickboxProp | Abstract base class for the various kinds of properties associated with SGNameItems that have a UI of a (tri-state) tick-box |
| NameGallery | Core object of the Camelot naming system |
| NameGallery::BarSizeType | |
| NameGallery::NameGalleryTimer | |
| NameGroupIter | Base classes for iterations and searches over all groups and all items in the name gallery |
| NameItemIter | Abstract base classes for iterations and searches over all groups and all items in the Name gallery |
| NameIterOp | Specialisation of base class to combine a node and an operation |
| NameObjectsDlg | |
| NativeClipMap | Clipboard mapping class for Native files -- wired into the system in winoil.cpp |
| NativeEPSOILFilter | The Native File format Oil Filter (Extension etc) |
| NativeExportDC | This class makes use of the base class for almost everything. Its real purpose is just to overide the Binary and Bitmap areas of the DC. In EPSExportDC these are converted to Hex strings and here they are output directly as binary.. |
| NativeFileOpParams | |
| NativeOILFilter | The Native File format Oil Filter (Extension etc) |
| NativePrefsDlg | |
| NativeRenderRegion | The render region class for the native file save |
| NewBrushMsg | A message broadcast when a new brush is created from the Brush edit dialog. It should be picked up by the Freehand infobar and used to update its brush list |
| NewColour | Represents a new colour object to be added to a document after a file has beeen imported. It holds information on whether the colour name will need to be mangled |
| NewColourDlg | |
| NewColourInfo | |
| NewColourList | Holds a list of colours that are imported while importing a file into a Camelot document |
| NewColourParam | Allows the user to create a new colour (based on another one) |
| NewPathCreatedMsg | This message is sent whenever a new path is created. The only client of this message (at the moment) is the Line tool, which needs to clear it's floating endpoint when a new path is created |
| NEWTEXTMETRIC | |
| Node | This abstract class describes the fundamental type of object which can be linked into a camelot tree. All other objects which are linked into the tree are derived from this class |
| Node::NodeFlags | |
| NodeAnimatingBitmap | |
| NodeAttribute | Abstract class from which various Attribute nodes are derived |
| NodeAttributeClassItem | This ListItem holds an attribute's runtime class |
| NodeAttributePtrItem | This ListItem holds a ptr to an attribute |
| NodeBarProperty | Child node of NodeSetSentinel that stores individual property records for a bars |
| NodeBevel | Does the bevelling |
| NodeBevelBegin | Denotes the beginning of a bevel |
| NodeBitmap | A class for including bitmap objects within the tree |
| NodeBitmapEffect | Bitmap effects nodes are type of Post-Processors. They process the bitmap output of their child nodes |
| NodeBlend | The NodeBlend class |
| NodeBlender | A NodeBlender is the class that actually renders the blend stages of a blend object. It also generates NodePath objects when the user does a 'make shapes' on a blend |
| NodeBlendPath | Defines the structure of a node blend path object. This object exists only as a child of a blend object |
| NodeBrush | The NodeBrush class |
| NodeBrushMaker | The NodeBrushMaker class |
| NodeBrushPath | The NodeBrushMaker class |
| NodeClipView | ClipView node. This node works in tandem with NodeClipViewController to provide clipview functionality. It sits underneath a NodeClipViewController, between the keyhole node and the clipped nodes, so that it is rendered after the keyhole node. Its Render() method saves GDraw's current clipping region and applies a new region, derived from the keyhole node's outline. See also: |
| NodeClipViewController | ClipView controller node. This is the node which does all the hard work with respect to clipview functionality. Initially at least, it is really a more-or-less normal group, with special rendering qualities. The bottom-most (in a z-order sense) NodeRenderableInk in the group is rendered, then its path is used to create a clipping region, into which all other members of the group are rendered |
| NodeCompound | Encapsulates everything to do with compound nodes |
| NodeCompoundBlendBecomeA | |
| NodeContour | Contour node |
| NodeContourController | Contour node controller class |
| NodeDocument | This class represents the root of a document tree. It contains the extents of the entire document as two DocCoords (LowExtent, HighExtent). LowExtent is the Coordinate position of the low corner of its first chapter whilst High Extent is the coordinate position of the high corner of its final chapter |
| NodeEffect | Encapsulates everything to do with post processor nodes PostProcessor nodes are compound nodes which take the rendered output of their children and change it in some way. They are compound nodes so that they have a user-controlled position in the rendering order |
| NodeEllipse | This is the Ellipse shape. It is based on the NodeSimpleShape, which means that it is fitted into a parallelogram. It is actually made up of 4 bezier curve sections |
| NodeFeatherEffect | Feather effects are specialised types of LiveEffect |
| NodeGrid | An abstract class defining the common elements of grid nodes |
| NodeGridIso | A class defining an isometric grid node |
| NodeGridRect | A class defining a rectangular grid node |
| NodeGroup | Group Node |
| NodeGuideline | Defines the NodeGuideline Class |
| NodeHidden | Nodes are generally never deleted from the tree, instead they are hidden. To hide a node a NodeHidden is inserted into the tree at the old position of the hidden node, the HiddenNode holds a pointer to the hidden node. The static ShowNode function of NodeHidden will delete the NodeHidden and relink the hidden node into the tree |
| NodeListItem | Stores a pointer to a Node. Used to build a list of nodes in the current range. The actual node can be accessed through the public member variable pNode |
| NodeListItemWithComplexity | This is used to ensure that blends print correctly. If a particular NodeBlender was classified as simple, and is later used with a blend that is complex, then complex blend steps will not render. This class allows us to reclassify a simple node as a complex one |
| NodeListItemWithDocPtr | This is used to allows blends of compounds to manage memory correctly. The class stores a pointer to the owning document - so that when the document dies, we only kill nodes associated with that document |
| NodeListItemWithIndex | |
| NodeLiveEffect | Bitmap effects nodes are type of Post-Processors. They process the bitmap output of their child nodes. They are "Live" in that as soon as their children change they re-process the output |
| NodeLockedEffect | Bitmap effects nodes are type of Post-Processors. They process the bitmap output of their child nodes. They are "Locked" in that they capture the output once then ignore changes to their children (because they cannot reproduce the processing) |
| NodeMould | This class defines the structure of a mould node object. This object is the parent of a MouldGroup node and a Moulder node. Objects being moulded are placed inside MouldGroup and all resulting moulded objects are placed inside the Moulder node |
| NodeMouldBitmap | This class controls the renderable mould objects. ie those objects which are moulded and rendered in one action. It will live under Moulder objects along with NodePaths eg |
| NodeMoulder | Defines the structure of a moulder object. The moulder exists only as a child of a mould object, controlling the production and manipulation of moulded versions of associated siblings. ie for each child (C) of a mould object, we create a moulder object (M). M controls the actual production and rendering of paths and bitmaps generated by C |
| NodeMouldGroup | Defines the structure of a mould group object. This object lives inside a NodeMould and keeps track of all mould source objects |
| NodeMouldPath | Defines the structure of a node mould path object. This object exists only as a child of a mould object, controlling the editing of the mould manifold |
| NodePath | Puts path objects into the tree |
| NodePointer | |
| NodeRect | A Node rect represents a rectangle object in the tree. It is derived from NodeSimple Shape that contains most of the functionality it needs. Simple Shapes are a group of nodes that are based around a parallelogram. The shape is fitted into a parallelogram so that it can be transformed while keeping its own identity (ie, it does not have to be turned into a NodePath) |
| NodeRegularShape | A NodeRegularShape represents an regularly shaped object. It encompasses NodeSimpleShape (but is not derived from it as it needs to do more things) |
| NodeRenderable | This abstract class describes a node which is renderable. See the Node class for an important note about producing derived classes of Node |
| NodeRenderableBounded | As NodeRenderable, but with a bounding box describing the area this object occupies. This class also includes functions for use with attribute optimisation |
| NodeRenderableInk | This abstract class describes a renderable ink node. A property of Ink nodes is that they should be rendered after their children have been rendered |
| NodeRenderableInkDetailsItem | This ListItem is used by the Object Registry. It has the RuntimeClass of a NodeRenderableInk node, along with the following information which is likely to grow |
| NodeRenderablePaper | This abstract class describes a renderable paper node. A property of paper nodes is that they need to be rendered before their children |
| NodeScan | Abstract base class for scans over sequences of nodes |
| NodeScan::Source | Abstract base class for interfaces to SelRanges, Document trees etc whose nodes can be scanned over. Notes: If your derived class defines data members then remember to define a copy constructor and consider concurrency issues! |
| NodeSet | Provide a mechanism for marking a set of nodes for redrawing. This mechanism is independent of the number of render regions associated with a particular tree, as it stores a list of pointers to nodes, rather than marking the nodes themselves. The NodeSet can be instructed to mark or unmark all nodes in the set. This allows us to selectively render these nodes without interfering with other render regions, because when we start rendering, we mark the nodes, render the marked nodes, unmark the nodes, and then we have stopped rendering. This means we only ever mark nodes while the render region is actively rendering, and as there can only ever be one render region actively rendering at one time (including the possibility of background rendering) then we don't get any interaction between render regions |
| NodeSetProperty | Child node of NodeSetSentinel that stores individual property records for a set of objects (SGNameItem) |
| NodeSetSentinel | Dummy node that has one instance of each different Wix ObjectName attribute also applied to it. Every document has one of these nodes after the last default attribute and before the first chapter. Whenever a new name is first applied to any objects in the document, it is also applied to this node; similarly, whenever a name is deleted (ie. hidden) from a document, it is also deleted from this node. Hence, during the normal course of creating or deleting objects with particular names, even if the last object which has a name is deleted by the user, the name still exists as a single attribute applied to this node, will remain an active item in the Attribute gallery, and can be saved out in the native format. And when the user creates or deletes names that never refer to any objects, the action always result in tree manipulations and are properly integrated into the undo system |
| NodeSimpleShape | A NodeSimpleShape is the base class for several primitive shapes that are bounded by a Parallelogram. This class contains 2 Pure Virtual functions that need to be re-written in base classes. These should be the only functions that need re-writting in most cases. They build a path for the shape given a bounding parallelogram |
| NodeThreeBoolListItem | |
| NodeToOutlinesBecomeA | The class that handles the convertion of a node to outlines. It receives all the paths passed back from the node, and appends them to a group object |
| NodeTypeEntry | |
| NoiseBase | |
| NoiseFillAttribute | Specifies a noise fill attribute for an object |
| NoiseFractalFill | A noise based fill. Really simple |
| NoiseGen1 | |
| NoiseMan | |
| NoiseTranspFillAttribute | Specifies a noise fill attribute for an object |
| NormCoord | Normalised vector/coordinate When normalised, the vector is always of unit length |
| Notifiable | Allows UIElements to interact with proxies |
| Notifier | Allows UIElements to interact with proxies |
| NotifyingGadget | This is an abstract class representing a gadget that notifies other Notifiable objects. Avoids multiple inheritance |
| NotifyNobody | Dummy Notifiable object used to initialize references |
| NotSelectSource | Concretisation of NodeScan::Source for all NodeRenderableInks NOT in the application's selection range |
| NullQualifier | A suffix qualifier is one of the form <...><QualifierToken>, e.g. 5.00% |
| NULLXaraFile | Dummy CXaraFile that swallows up all bytes written to it |
| ObjChangeFlags | Defines physical changes which have occured on an object. These should be as high level as possible. If your object has changed in a subtle way, try and choose the field which best matches the change. Try not to invent a new field for your change as like as not no one will respond to it |
| ObjChangeMask | Defines what messages if any are passed to parent objects. The starting message is not defined here as this is used to allow nodes to actually set the mask. All flags are initialised to FALSE and should be set by nodes to TRUE when they want to receive a message. If any parent node requires a message then all will get the message. Note the mask is verified and corrected so that messages will be sent correctly in sequence |
| ObjChangeParam | Provides a derivable structure for passing to a nodes OnChildChange virtual function. To create this class parameter simply call Define with the necessary change variables |
| ObjChangeParamWithToken | Identical to a ObjChangeParam object, except that there is an additional field that contains the OpToken |
| ObjChangePathEdit | A derived change parameter for use in path editing. It is exactly the same as ObjChangeParam apart from providing a path pointer, for use during eor drags, to describe the current state of the dragged path. Obviously this cannot be determined from the tree object until it has been updated when the drag finishes |
| ObjectCache | Base class for the cache. The cache replacement policy algorithms are implemented in the derived classes such as ObjectCacheRand...etc |
| ObjectCacheFIFO | FIFO cache replacement policy See also: class ObjectCache |
| ObjectCacheRandom | Random cache replacement policy See also: class ObjectCache |
| ObjectCacheWeakest | Provides a delete algorithm cache replacement policy according to the size of the object. See also: class ObjectCache |
| ObjectItem | ObjectItems are held in ObjectSets |
| ObjectRegistry | The object registry currently records the attributes which are required by each NodeRenderableInk node in Camelot. Such a list is required during attribute optimisation, to determine the attributes to collect to make a subtree attribute complete |
| ObjectSet | A set of NodeRenderableInk objects |
| ObjInfo | |
| Octree | |
| OctreeElement | Colour octree |
| OffscreenAttrValue | |
| OILBitmap | To encapsulate the OILy end of bitmaps. Each OIL layer inherits from this and puts real functionality into the class. Things defined in this class must remain kernel-ly |
| OilCoord | |
| OILDockingBar | This is the base class for FixedDockBars and FloatingBars, |
| OilDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag. OilDragTargets are used as a base class from which to derive drag targets for WINOIL entities (an optional HWND) |
| OILEnumFonts | A class which allows kernel level and tool functions to inherit the ability to enum fonts. The class will call each OIL level font manager to enum their own specific set of fonts and the results will be returned to the derived NewFont() function |
| OILFilter | This class is used to encapsulate the platform specific features of a filter. Every Filter object has a pointer to an OILFilter object. For example, under Windows, it holds the file extensions that this file understands |
| OILFilterFamily | Automate the production of the OIL parts of a filter family object |
| OILFixedDockingBar | |
| OILFloaters | This class handles the OIL-specific parts of Floaters. They handle the low-level creation/deletion details, |
| OILFontMan | The base font class controller inside the WinOil. The kernel should make calls to this font manager class only. The class acts as a switching layer calling other OIL level font managers dependent on the type of font in use |
| OILHorizontalRuler | |
| OILModule | This class hides the mechanism of loading modules via whatever OS calls are required. For example, under Windows it loads DLLs and interrogates them, whereas on the Arc something quite different could happen. It also provides a link between a kernel 'Module' item and the OIL transport mechanism used to load it |
| OILPanose | Specification of the OIL related Panose code Abstract, static class, holding OIL related Panose code |
| OILPreferences | This class, like the Preferences class, is only ever instantiated once. It is a collection of routines to be used to handle the OIL side of reading and writing preferences. This class is used internally by the Preferences class - no other class should need to use it |
| OilRect |
|
| OILRuler | This is the base class for Horizontal and Vertical rulers, It looks after the basic's - creating windows etc.. and handles all mouse events fo the rulers |
| OILTool | |
| OILVerticalRuler | |
| OpAddBlendPath | Adds a blend path to the selected blends |
| OpAddNewPath | This op actually adds a new path to the current document. The path has been created and edited with OpPenCreatePath() which will handle EOR drawing It can now be instantiated as a physical object by this op |
| OpAddPath | The base class for various addpath operations. This is not really an operation in its own right as it does not provide an init and getstate function. Its use is to provide common functions required by distinct addpath operations |
| OpAddPathToPath | This op will add an element to an existing path within the tree. The new element and context path should be passed into the do function as parameters |
| OpAddShapes | Op that invokes the Add Shapes operation performed by OpCombineShapes |
| OpAddWebFolders | |
| OpAddWebLibrary | |
| OpAffectFontChange | An operation to update all text stories in all documents |
| OpAlign | Undo-able Op to Align objects |
| OpAnimationProperties | |
| OpApplyAttrib | Virtual base class for ops that apply attibutes |
| OpApplyAttribsToSelected | This class represents the OpApplyAttribsToSelected operation. It applies the specified set of attributes to all selected objects |
| OpApplyAttribToNode | This class represents the OpApplyAttribsToSelected operation. It applies the attribute to a specified object |
| OpApplyAttribToSelected | This class represents the OpApplyAttribToSelected operation. It applies the specified attribute to all selected objects |
| OpApplyAttrInteractive |
|
| OpApplyCentreJustifyToStory | This operation is the centre justify option on the TextStory pop-up menu |
| OpApplyClipView | Operation to apply ClipView to the selection. See also: |
| OpApplyFeatherEffect | Operation to apply Bitmap Effect to the selection. See also: |
| OpApplyFullJustifyToStory | This operation is the full justify option on the TextStory pop-up menu |
| OpApplyGlobalAffect | An operation to scan all objects in all documents, calling a user defined function to perform a none undoable operation on them |
| OpApplyJustificationToStory | This operation is the base class of the operations that sit on the TextStory pop-up menu |
| OpApplyLeftJustifyToStory | This operation is the left justify option on the TextStory pop-up menu |
| OpApplyLiveEffect | Operation to apply Bitmap Effect to the selection. See also: |
| OpApplyNamesToOne | |
| OpApplyNamesToSel | |
| OpApplyNameToNone | |
| OpApplyRightJustifyToStory | This operation is the right justify option on the TextStory pop-up menu |
| OpAsynchBitmapImport | This operation will attempt to download and import a bitmap located on a web server |
| OpAsynchClipartImport | This class represents the Undo-able operation to import and open clipart files over the Internet |
| OpAsynchFontInstall | This operation will attempt to download and install fonts from a web server to the local machine |
| OpBackground | Allows the background layer to be set up and changed |
| OpBackgroundParam | Param passed to OpBackground::DoWithParams() |
| OpBarCreation | This class makes several copies of the selection, putting them onto particular named layers. Each copy is named button1, button2, etc.. Each layer is created and named Default, Mouse, Clicked or Selected. The copy can be 'mutated' to appear slightly different on each layer. The selection is deleted |
| OpBaseConvertPathSegment | This is the base class for the two operations that convert curve segments into line segments and vice-versa |
| OpBevel | |
| OpBitmapDownload | |
| OpBitmapImport | |
| OpBlendAntialias | This changes the one-to-one flag of all selected blends |
| OpBlendNodes | |
| OpBlendOneToOne | This changes the one-to-one flag of all selected blends |
| OpBlendTangential | This changes the Tangential flag of all selected blends |
| OpBreakAtPoints | This class will break paths at selected points. The effect of this will be to either open a closed path or split a open path into two subpaths, or both dependent on the number of selected points in the path. There must be at least one selected point for this operation to complete correctly |
| OpBreakShapes | This class will break compound paths into two or more simple paths. It will work when there are one or more compound paths selected |
| OpBringToFront | This class represents the BringToFront operation |
| OpBrowserPreview | Performs an operation to preview the animation in a browser |
| OpCentredDragBox | This is a base class for drag operations that would like a drag box to be centred on the initial click point, such as (optionally) the zoom tool. Apart from providing a new default CalcDragBox function, it is used the same way as OpDragBox |
| OpChangeBarExtends | |
| OpChangeBarProperty | |
| OpChangeBarPropParam | |
| OpChangeBlend | This changes aspects of all selected blends |
| OpChangeBlendDistance | This changes the distance between steps of the selected blends |
| OpChangeBlendSteps | This changes the number of steps of the selected blends |
| OpChangeBrush | Base class for operations to change various features of the brush |
| OpChangeBrushDefinition | This operation exists so that we can make undoable edits to the brush definitions stored in the brush component |
| OpChangeContourAttributeProfile | This changes the number of steps of the selected blends |
| OpChangeContourColourType | This changes the number of steps of the selected blends |
| OpChangeContourObjectProfile | This changes the number of steps of the selected blends |
| OpChangeContourStepDistance | This changes the step distance of the selected blends |
| OpChangeContourSteps | This changes the number of steps of the selected blends |
| OpChangeContourToInner | Changes all contours to inner - used by the button on the infobar |
| OpChangeContourToOuter | Changes all contours to outer - used by the button on the infobar |
| OpChangeContourWidth | Forces a regeneration of the bevel in all nodes in the list Used by NodeBevelcontroller::OnChildChange to force redraws in undos/redos |
| OpChangeFeatherProfile | |
| OpChangeFeatherSize | |
| OpChangeFeatherSizeParam | |
| OpChangeFillProfile | |
| OpChangeLayerColour | Allows layers to have their colour changed |
| OpChangeLayerColourParam | Param used to change the colour of a layer |
| OpChangeLineAttribOpDesc | Abstract base-class OpDescriptor to allow the user to change a line-attribute of all selected objects, or to set the AttributeManager's current attribute if no objects are selected |
| OpChangeLineCapOpDesc | OpDescriptor to allow the user to change the join-type of all selected objects, or to set the AttributeManager's current join-type attribute if no objects are selected |
| OpChangeLineJoinOpDesc | OpDescriptor to allow the user to change the join-type of all selected objects, or to set the AttributeManager's current join-type attribute if no objects are selected |
| OpChangeLineWidthOpDesc | OpDescriptor to allow the user to change the line width of all selected objects, or to set the AttributeManager's Current line width attribute if no objects are selected |
| OpChangeSetProperty | |
| OpChangeTranspFillProfile | |
| OpClearCache | To allow comparitive timing of window redraws Notes: In the OIL |
| OpClipartImport | |
| OpClipboardExport | |
| OpClipboardImport | |
| OpClone | This class represents the Clone operation. When executed this operation makes a copy of all selected objects, leaving the new objects on top of the existing objects |
| OpCloseNodePaths | This operation is for closing all the open selected paths |
| OpClosePathWithPath | This op deals with a destination path being edited, and a source path which may be the result of a drag edit operation. The idea is that the op will take the components of the source path and add them in a deterministic way to the destination path, resulting in a closed destination path. The source path is assumed to have either 1 or 2 elements in it. The first element will be added to the end of the destination path and act as a closing piece. The second element of the source path will affect the first element in the destination path. If both elements match in type, ie are two curves, then the none end control handles of the source will be copied to the destination. This op as can be seen is rather specific, and is used by the pen tool to close an open path. Imagine clicking on the first control point of a path and draging out control handles. The handles will affect the previous and next elements of the path. The previous being a close element and the next being the first element of the path. Hence the need for this strange op |
| OpColEditCommand | A polymorphic Op which is used for all generic colour editor "commands" |
| OpColourChange | |
| OpCombineLayersToFrameLayer | |
| OpCombineShapes | Base class op that does all the shape combining ops, like add, subtract and intersect,etc |
| OpContourNodes | Copy of the blend nodes operation in blndtool.h |
| OpConvertFileFormats | The "Convert File Formats" debug command |
| OpConvertPathToShapes | This creates objects out of the paths of the selected objects |
| OpConvertToBitmap | Converts objects into a bitmap |
| OpCopy | This class represents the Copy operation. When executed this operation makes a copy of all selected objects and places them on the internal clipboard |
| OpCopyAndTransform | This operation creates a transformed copy of the selected objects |
| OpCopyFrame | |
| OpCopyMouldShape | An undoable operation to copy the mould shape to the clipboard |
| OpCreateContour | Creates contours on the selection |
| OpCreateFill | An operation to add a Linear Graduated Fill to the selected Object(s) |
| OpCreateFontThumbnails | |
| OpCreateNewFrame | |
| OpCreateNewMould | Creates a new mould object and all its various children to form a valid mould structure. The operation will execute only when there is one or more selected objects to work on. These selected objects will to all intense and purpose dissappear from the tree. They will move from their current positions and move inside the new mould node |
| OpCreateNodeBitmap | Creates a new Node Bitmap, at a specific position on the page |
| OpCreateTextObject | This operation is invoked to allow the user to insert a TextStory into the document. Currently the only way the user can create a TextStory is to click on a spread |
| OpCut | This class represents the Cut operation. When executed this operation hides all selected objects and places a copy of them on the Internal clipboard |
| OpDeactivateBrush | This operation takes a brush handle as a parameter, locates the appropriate brush definition and sets the flag indicating that it has been deactivated. Also removes the item from the line gallery and freehand combo |
| OpDelBar | Will cut down the size of a bar to the number of buttons requested by deleting the last buttons in the bar |
| OpDelete | This class represents the Delete operation. When executed this operation hides all selected objects |
| OpDeleteAllGuidelines | Allows guides to be Deleted |
| OpDeleteAllLiveEffect | Operation to delete all Bitmap Effects on the selection. See also: |
| OpDeleteBitmap | Removes all references to a bitmap, and deletes it from memory |
| OpDeleteFrame | |
| OpDeleteGuideline | Allows guides to be Deleted |
| OpDeleteLiveEffect | Operation to apply Bitmap Effect to the selection. See also: |
| OpDeleteNamesFromAll | |
| OpDeletePageBackground | |
| OpDeletePoints | This class will delete any selected points from selected paths |
| OpDeleteTextStory | This operation should be used to hide a particular TextStory |
| OpDescControlCreateMsg | This message is sent to an OpDescriptor after its controls have been created. It gives you a chance to perform control initialisation. eg. Set scrollbar ranges, fill listboxes .. |
| OpDescControlDestroyMsg | This message is sent to an OpDescriptor after its controls have been destroyed, It gives the OpDescriptor a chance to cleanup |
| OpDescControlMsg | This message is the OpDescriptor equivelant of a DialogMsg. It is sent when an OpDescriptor's control sends a message |
| OpDescMsg | Base class for all OpDescriptor messages |
| OpDescriptor | |
| OpDeSelectAllPathPoints | This operation is used to deselect all endpoints in a path |
| OpDetachBlendPath | Detached the blend path from each of the selected blends |
| OpDetachMould | An operation to attach and detach a mould manifold from its object This allows the manifold to be edited on its own without the moulded objects following. Handy for quick edits |
| OpDisplayBitmapGallery | Displays the bitmap gallery. This op can be attached to a menu, button or keypress |
| OpDisplayColourGallery | |
| OpDisplayFontsGallery | Displays the fonts gallery. This op can be attached to a menu, button or keypress |
| OpDisplayFrameGallery | Displays the frame gallery. This op can be attached to a menu, button or keypress |
| OpDisplayLayerGallery | Displays the layers gallery. This op can be attached to a menu, button or keypress |
| OpDisplayLibClipartGallery | |
| OpDisplayLibFillsGallery | |
| OpDisplayLineGallery | |
| OpDisplayNameGallery | |
| OpDisplayTEMPLATEGallery | |
| OpDragBox | This is a base class for operations that use a drag box to select an area within a view, such as the selector and the zoom tools. This class looks after the chore of correctly drawing and updating the xored drag box |
| OpDragOrigin | Defines an operation for dragging perspective mould vanishing points around |
| OpDragRegularShape | This operation is started by a NodeRegularShape when someone drags on one of its control points. As the control point is dragged about the new version of the shape, corosponding to the new blob positions, will be EOR rendered to the window |
| OpDragRotateCentre | Allows you to drag the selector tool's centre of rotattion around |
| OpDragStoryIndent | This is the operation that is used to drag the indent position along the path the text story is on |
| OpDragStoryNonPathIndent | Base class for dragging indents for stories not on a path |
| OpDragStoryNonPathLeftIndent | This is the operation that is used to drag the left hand path indent |
| OpDragStoryNonPathRightIndent | This is the operation that is used to drag the right hand path indent |
| OpDragStoryPathIndent | Base class for dragging indents for stories on a path |
| OpDragStoryPathLeftIndent | This is the operation that is used to drag the left hand path indent |
| OpDragStoryPathRightIndent | This is the operation that is used to drag the right hand path indent |
| OpDrawBrush | Draws a freehand stroke, smooths it and applies a nice brush effect |
| OpDroppedFile | |
| OpDuplicate | |
| OpDuplicateBar | Make a complete copy of the bar. Only the buttons names are made unique and there is a new bar name. It is positioned next to the original bar |
| OpEditBlendEndObject | The operation to edit the position of the end objects of a blend on a path |
| OpEditFill | This operation edits an AttrLinearFill already in the tree. It is normally started when the Tool detects a drag on one of its selected blobs |
| OpEditLegacyEffect | Hold all class for passing on requests to "edit" a legacy effect See also: |
| OpEditLiveEffect | Operation to apply Bitmap Effect to the selection. See also: |
| OpEditRectangle | This operation edits a NodeRect already in the tree. It is normally started when the Rect detects a drag on one of its selected blobs |
| OpEditRegularShape | This operation can be used to change the internal data members of NodeRegularShapes in an undoable way. It either changes one particular shape or all selected shapes. The data members are changed to those supplied by the parameter object |
| OpEffectLock | Operation to change effect locked state. See also: |
| OpEffectLockAll | Operation to change effect locked state. See also: |
| OpEffectRes | Operation to change effect resolution. See also: |
| OpenFileDialog | Brings up an Open file dialog that goes to the correct directory etc |
| OPENFILENAMEEX | |
| Operation | This abstract class represents an operation which is a single job initiated by the user. You should derive all non undoable operations directly from this base class |
| OperationHistory | This class represents the operation history for a camelot document. It is a repository for all undoable operations performed in Camelot. It stores operations in chronological order and provides methods to undo and redo them |
| OpException | |
| OpExit | This class represents the Exit Application operation |
| OpExportSets | |
| OpExportSets::ExportHighlightedIter | Iterates over highlighted set items, re-exporting any that are export targets |
| OpFeatherEffectParam | Contain all the info transferred from the UI to the OpApplyLiveEffect operation |
| OpFillNudge | The underlying nudge op that does a nudge on the selected points in a path |
| OpFitTextToCurve | This class is the operation used to fit a line of text to a path |
| OpFlgs | |
| OpFlgsStr | |
| OpFlipTrans | This operation allows you to flip the selection either vertically or horizontally. It only has an immediate version and no interactive version |
| OpFrameProperties | |
| OpFreeHand | This is the FreeHand Operation that builds a smoothed curve |
| OpGalleryCommand | A polymorphic Op which is used for all generic gallery "commands" |
| OpGBrush | Operation to toggle GBrush setting Notes: Will be on a dialog somewhere eventually |
| OpGDraw | Operation to toggle gdraw setting Notes: Will be on a dialog somewhere eventually |
| OpGenericDownload | |
| OpGrabAllFrames | Performs an operation to grab all of the frame layers and preview them |
| OpGrabFrame | Performs an operation to grab the selected frame layer and preview it |
| OpGrid | Base class all grid operations are derived from |
| OpGridChange | |
| OpGridCopy | This class represents the grid Copy operation. Currently, it just greys out the menu/button/keypress associated with the op |
| OpGridCut | This class represents the grid Cut operation. Currently, it just greys out the menu/button/keypress associated with the op |
| OpGridDelete | This class represents the grid Delete operation |
| OpGridDuplicate | This class represents the grid Duplicate operation. Currently, it just greys out the menu/button/keypress associated with the op |
| OpGridNewResize | |
| OpGridPaste | This class represents the grid Paste operation. Currently, it just greys out the menu/button/keypress associated with the op |
| OpGridResize | |
| OpGridSelection | |
| OpGroup | This class represents the Group operation |
| OpGuideline | Allows guidelines to be dragged around |
| OpGuidelineParam | Param passed to OpGuideline::DoWithParams() |
| OpHelpTuple | |
| OpHideColours | |
| OpInsertFloater | This is the operation that the line tool uses to insert the floating endpoint in an undoable kind of way |
| OpIntersectShapes | Op that invokes the Add Shapes operation performed by OpCombineShapes |
| OpJoinShapes | This class takes two or more selected paths and combines them into one path |
| OpLayerChange | This class represents the LayerChange operation which is created by the LayerManager to make changes to the layers of the current spread |
| OpLayerGalChange | |
| OpLayerGalParam | |
| OpLibGalClipTheme | |
| OpListItem | The reason we need to store OpDescriptors in OpListItems is that OpDescriptors are MessageHandler objects and so are already potentially stored on a list |
| OpLiveEffect | Base class for all LiveEffect ops See also: |
| OpLiveEffectParam | Contain all the info transferred from the UI to the OpApplyLiveEffect operation |
| OpMakeColourLocalToFrame | Operation to create copy of a colour (and its descendants) for the current frame |
| OpMakeNodesShapes | This undoable operation converts a given list of nodes to editable shapes (paths), each new node retaining the selection status of the original |
| OpMakeSegmentsCurves | This class will change all the selected segments in all selected paths from lines into curves (ignoring segments that are already curves!) |
| OpMakeSegmentsLines | This class will change all the selected segments in all selected paths from curves into lines (ignoring segments that are already lines!) |
| OpMakeShapes | This class represents the MakeShapes operation |
| OpMakeStroke | This class represents the MakeStroke operation |
| OpMenuExport | |
| OpMenuImport | |
| OpMenuLoad | Imports the specified file as NativeEPS |
| OpMenuParam | Contain all the info transferred from the menu UI to Ops |
| OpMenuSave | Saves the document to the file specified in the params to the disk using the NativeEPS format |
| OpMenuSelectPathPoints | This operation is the base of select/deselect all endpoints in a path |
| OpMouldLib | Provides a library of undoable functions for moulding objects |
| OpMouldLibSel | Provides a library of undoable functions for moulding objects |
| OpMoveBackwards | This class represents the MoveBackwards operation |
| OpMoveForwards | This class represents the OpMoveForwards operation |
| OpMovePathPoint | This operation allows the exact positioning of elements in a path |
| OpMoveToLayer | An op to move the selection from where-ever it is to the active layer |
| OpMoveToLyrBehind | This class represents the move to layer behind operation |
| OpMoveToLyrInFront | This class represents the move to layer in front operation |
| OpMsg | This message is sent whenever something happens to an operation |
| OpNameGalleryPropIndexDesc | |
| OpNewGuideline | Op to create a new guideline immendiately |
| OpNewPath | This operation will create a new path of a single line or curve and put it in the tree |
| OpNewRegShape | Provides an operation for the regular shape tool to use to create and insert a new shape into the document tree (with undo etc...) |
| OpNodePathAddEndpoint | This operation is started by the bezier editing tool when it wants to add a point to the start or end of a particular path. It uses the normal dragging of the base operation, but the action when the operation finishes is different. This class is derived from OpNodePathEditBlob which drags the normal selected points around |
| OpNodePathEditBlob | This operation is started by the NodePath when it receives a drag message from one of the tools. It uses it to drag one (or many) of the paths control points around the screen to edit the path. As the control points are dragged about the new version of the path, corosponding to the new blob positions, will be EOR rendered to the window |
| OpNodePathEditControlBlob | This operation is started by the NodePath when it receives a drag message from one of the tools. It uses it to drag one of the paths Bezier control points around the screen to edit the path. As the control points are dragged about the new version of the path, corosponding to the new blob positions, will be EOR rendered to the window. This class is derived from OpNodePathEditBlob which drags the normal selected points around. This drags the Bezier control points around of one of the selected points on the curve. Most of the functions are not needed as it uses the base class versions |
| OpNudge | The underlying nudge op that does a nudge on the selection. Note: Mark initially implemented the twelve different types of nudge as twelve seperate ops. Simon changed this (07/11/94) so that it now uses only one operation, but has 12 OpDescriptors all of which map to the same operation. We determine the type of nudge we are after from the runtime class of the OpDescriptor in the Do function |
| OpOverprintFill | An Op for toggling the AttrOverprintFill attribute |
| OpOverprintLine | An Op for toggling the AttrOverprintLine attribute |
| OpPageResize | |
| OpPalettePopupCommand | |
| OpParam | Operation parameter structure. The meaning of the structure's fields are defined by each operation. Note that sensible Operations will derive a special OpParam for their own specific needs, so you should use the derived class where it is available |
| OpParamBarCreation | |
| OpParamBarCreationDlg | |
| OpParamBarDuplication | |
| OpParamBarRedefineStateDlg | |
| OpParamBarStatesDlg | |
| OpParamDelBar | |
| OpParamExtendSetsDlg | A parameter class for creating the ExtendSetsDlg with. See also: ExtendSetsDlg |
| OpParamMakeNodesShapes | OpParam structure required to use the OpMakeNodesShapes undoable operation. See also: OpMakeNodesShapes |
| OpParamPasteAtPosition | Holds information allowing the paste op to paste objects at a specific position |
| OpParamShortenBar | |
| OpPaste | This class represents the Paste operation. When executed this takes a copy of all objects on the internal clipboard and adds them to the visible spread |
| OpPasteAttributes | This class represents the PasteAttributes operation. The operation applies all attributes common to the objects on the clipboard. This operation is not in itself undoable. It invokes another UndoableOperation to actually apply the attributes |
| OpPasteEnvelope | An undoable operation to paste the contents of the clipboard as a mould shape |
| OpPasteMouldShape | An undoable operation to paste the contents of the clipboard as a mould shape |
| OpPastePerspective | An undoable operation to paste the contents of the clipboard as a mould shape |
| OpPathNudge | The underlying nudge op that does a nudge on the selected points in a path |
| OpPenAddElement | Given a path in the tree with a selected end point, this operation will control the creation of a new element (through clicks and drags), at the end of the path. It is derived from OpPenEditPath which controls all the eoring of path elements such as blobs and lines |
| OpPenClosePath | This op controls the closing of an open path. It performs the eoring of path elements a blobs during a click or drag action. It is primarily used by the pen tool an is brought into being when a click occurs over the startpoint of a path, having a selected endpoint |
| OpPenCreateInternal | This operation is started by the pen tool when it receives a click on the document with no previous internal or external state set. ie the pen tool is not holding a moveto element inside iteslf from a previous click and there are no selected endpoints to add to |
| OpPenCreatePath | This op is concerned with creating a new path in the tree. It is derived from OpPenEditPath, which handles all the dragging and redraw of a new path element. This op will use |
| OpPenDragBlobs | This op class is defined as a base class only. It provides common dragging functionality which is inherited by create and edit pen classes |
| OpPenEditInternal | This operation is started by the pen tool when it receives a click over its internal moveto point. The point will be converted into a dragto if a drag occurs |
| OpPenEditPath | This operation is started by the pen tool when it receives a click on a document and needs to create a new path. The idea is, it will drag edit a path until such time as the user lets go of the mouse. and then add the path to the tree. The operation handles the internals of rendering the eor path |
| OpPenHandles | This operation simply provides functions for other operations to use. It is not intended to be used as an operation in its own right. Most useful pen classes are derived from this |
| OpPreviewPopupCommand | The context menu handling for the bitmap preview dialog |
| OpPrint | This class represents all the Printing operations |
| OpPrintOnAllPlates | An Op for toggling the AttrPrintOnAllPlates attribute |
| OpPullOntoGrid | Translate the selection so that one of it's corners lies on the grid |
| OpPush | This is the Push operation that slides the document about |
| OpPutToBack | This class represents the PutToBack operation |
| OpQuality | Operation to set quality level on a DocView Notes: Will be on a dialog somewhere eventually |
| OpRectangularEnvelope | Simple operations to handle the creation of default envelope and perspective shapes |
| OpRectangularPerspective | Simple operations to handle the creation of default envelope and perspective shapes |
| OpRedefineNamesAsSel | |
| OpRedo | This class represents the Redo operation |
| OpRedrawColours | |
| OpRedrawColoursInfo | This non-undoable operation is used by the colour manager to redraw all nodes of the document which have been affected by changes to a colour or colours |
| OpReformShapeEdge | This operation is started by a NodeRegularShape when someone drags on one of its edges. It is used to interactively reform the path used to form the edge of the shape |
| OpRegister | Manage registration of CD |
| OpRemoveAttributeFromSelection | Delete a Node from the tree |
| OpRemoveBlend | This removes the selected blend objects, leaving the original objects in the tree |
| OpRemoveClipView | Operation to take apart the selected ClipView object |
| OpRemoveContour | Removes contours on the selection |
| OpRemoveFloater | This is the operation that the line tool uses to remove the floating endpoint in an undoable kind of way |
| OpRemoveMould | An undoable operation to remove the mould shape from a mould object |
| OpRemoveNamesFromSel | |
| OpRenameAll | |
| OpRepeatApplyAttribToSelected | This class represents the OpApplyAttribToSelected operation. It applies the specified attribute to all selected objects |
| OpReplaceAttributes | This class represents the OpReplaceAttributes operation. It replaces specific attributes with a new one |
| OpResetSpreadOrigin | Op to reset the spread (user and grid) origin |
| OpReshapeOrAddPoint | This operation serves two purposes - while dragging, it will reshape a bezier segment, changing the path on ending the drag. However, if the drag is released immediately after it is initiated, a point is added to the bezier curve (or line) at the click point |
| OpRetroFit | This operation handles the updating of a freehand path after it has been retro fitted |
| OpRetroSmooth | |
| OpReversePath | |
| OpReverseStoryPath | This operation should be used to hide a particular TextStory |
| OpRotateMould | An operation to rotate a set of objects within a mould manifold. The op simply changes the start point of a mould path object by rotating it around one logical element. The result is simply to spin the orientation of the moulded objects within the mould shape |
| OpRotateTrans | The operation that performs the interactive EORed dragging during a rotation |
| OpSaveAnimatedGIF | Pops up a common dialog to allow the user to export an animated GIF from Camelot. This is for the special frame related export so we have all the options set up |
| OpSaveAsNativeV1 | Saves the document to the file specified in the params to the disk using the Version 1 Native format i.e. Native EPS |
| OpSaveAsNativeV2 | Saves the document to the file specified in the params to the disk using the Version 2 Native format |
| OpSaveAsWeb | Saves the document to the file specified in the params to the disk using the Web format |
| OpScaleTrans | This is the interactive and immediate scale operation |
| OpSelectAllPathPoints | This operation is used to select all endpoints in a path |
| OpSelectBrush | This operation can take place only in the Freehand tool. If there is a single selected brush then it makes that brush selected in the combo so that the user can draw with it straight away rather than having to select it in the combo themselves. Note that it is not undoable because a) it makes no change to anything in the document and b) it can only be called whilst in the Freehand tool (and what would happen if it were undone outside of the Freehand tool is rather hard to define) |
| OpSelectEndFrame | |
| OpSelectIntersectSets | |
| OpSelectNextFrame | |
| OpSelectorDragBox | This operation is started when the user does a drag over the document, that started in empty space. A drag box will be drawn out over the document as the user moves the mouse about and when the drag ends, all the objects wholly inside the box will be selected |
| OpSelectPathPoints | This is the operation that marquee selects points in paths |
| OpSelectPrevFrame | |
| OpSelectSet | |
| OpSelectStartFrame | |
| OpSelectUnionSets | |
| OpShapeMakeRegular | This is an operation that makes one QuickShape regular |
| OpShapeToggleBase | This is a base class for operations that toggle certain states of a QuickShape |
| OpShapeToggleCurvature | This class is an operation that toggles the curvature state of all selected QuickShapes |
| OpShapeToggleElipPoly | This class is an operation that toggles the ellipse/polygon state of all selected QuickShapes |
| OpShapeToggleSetNumSides | This class is an operation that sets the number of sides of all selected QuickShapes |
| OpShapeToggleSetNumSides10 | This class is an operation that sets the number of sides of all selected QuickShapes |
| OpShapeToggleSetNumSides3 | This class is an operation that sets the number of sides of all selected QuickShapes |
| OpShapeToggleSetNumSides4 | This class is an operation that sets the number of sides of all selected QuickShapes |
| OpShapeToggleSetNumSides5 | This class is an operation that sets the number of sides of all selected QuickShapes |
| OpShapeToggleSetNumSides6 | This class is an operation that sets the number of sides of all selected QuickShapes |
| OpShapeToggleSetNumSides7 | This class is an operation that sets the number of sides of all selected QuickShapes |
| OpShapeToggleSetNumSides8 | This class is an operation that sets the number of sides of all selected QuickShapes |
| OpShapeToggleSetNumSides9 | This class is an operation that sets the number of sides of all selected QuickShapes |
| OpShapeToggleStellation | This class is an operation that toggles the stellation state of all selected QuickShapes |
| OpShearTrans | The operation that performs the interactive EORed dragging during a shear |
| OpShortenBar | Will cut down the size of a bar to the number of buttons requested by deleting the last buttons in the bar |
| OpShowGrid | Allows the user to toggle the visible state of all grids. Notes: - |
| OpShowGuides | Allows the user to toggle the visible state of all guides. Notes: - |
| OpShowPrintBorders | Allows the user to toggle the visible state of the print borders Notes: - |
| OpShowPrinterColours | An Op for toggling composite print preview on and off |
| OpShowState | Will cut down the size of a bar to the number of buttons requested by deleting the last buttons in the bar |
| OpSlice | The "Image Slice" menu item |
| OpSliceDragBox | Drag box class for the SliceTool. Allows the user to select a number of named sets, by dragging a box around some objects on the document. All objects sharing the same names as those inside the box will then be selected |
| OpSliceShapes | Op that invokes the Add Shapes operation performed by OpCombineShapes |
| OpSliceTranslate | This is the Slice tool's Translate operation, which is similar in behaviour to OpTranslateTrans, except that we inform the user during the drag if the current selection's bounds overlap those of an unselected named set (button). When doing an immediate transform the params to DoWithParams() are :- Param1 - All the standard transform data Param2 - A pointer to a DocCoord that holds to offset translate by |
| OpSmoothSelection | This class will smooth paths between selected control point regions. It processes all selected objects within the current document |
| OpSnapToGrid | Allows the user to toggle snap-to-grid on and off. Notes: - |
| OpSnapToGuides | Allows the user to toggle snap-to-guides on and off. Notes: - |
| OpSnapToObjects | Allows the user to toggle snap-to-objects on and off. Notes: - |
| OpSpreadOrigin | Allows you to drag the origin to another place |
| OpSquashTrans | The operation that performs the interactive EORed dragging during a Squash |
| OpState | |
| OpSubtractShapes | Op that invokes the Add Shapes operation performed by OpCombineShapes |
| OpTextAutoKern | This Operation applies autokern to the FocusStory |
| OpTextCaret | OpTextCaret groups together all caret moving ops |
| OpTextFormat | This class implements many of the 'operations' which will cause the TextStory to be reformated |
| OpTextKern | This Operation applies a kern to the FocusStory |
| OpTextPaste | An undoable operation to paste the contents of the clipboard into a text story |
| OpTextSelection | This is the operation that positions the caret after a click, and then does a drag to select characters. It also provides other functions for selecting groups of characters |
| OpTextUndoable | All undoable text operations are derived from this base class. It provides useful functions required by all Undoable Text Operations |
| OpThrottleCache | To allow comparitive timing of window redraws Notes: In the OIL |
| OpThumbDownload | Thumbnail download operation |
| OptimalBitmapRenderCallback | |
| OptimalPrintRenderCallback | |
| OpTimeDraw | To allow easier timing of window redraws Notes: In the OIL |
| OptionsChangingMsg | This message is sent when a user has changed the options on a document or a global application based option. At present the messages include:- |
| OptionsTabs | These encompass all the tabs available for the options dialog box to use |
| OpToggleCompositePreview | An Op for toggling composite print preview on and off |
| OpToggleContourInsetPath | Toggles the inset path states of all selected contours |
| OpToggleCyanPreview | An Op for toggling cyan plate print preview on and off |
| OpToggleDoubleBuffer | This class represents the OpToggleDoubleBuffer operation. Creating an instance of this class and calling its "Do" function will toggle the state of the flag controlling whether double buffering is used for rendering on GTK |
| OpToggleFore | This class represents the ToggleFore operation. Creating an instance of this class and calling its "Do" function will toggle the state of the flag controlling whether any RenderRegions created by the current DocView will be submitted to the background rendering system or not |
| OpToggleKeyPreview | An Op for toggling Key plate print preview on and off |
| OpToggleMagentaPreview | An Op for toggling Magenta plate print preview on and off |
| OpToggleMonoPlatePreview | An Op for toggling mono plate print preview on and off |
| OpToggleMouldGrid | An operation to turn a particular moulds grid on and off |
| OpTogglePressure | |
| OpTogglePrintTextAsShapes | This operation toggles the state of the "print text as shapes flag" in selected TextStories |
| OpToggleScroll | This class represents the ToggleScroll operation. Creating an instance of this class and calling its "Do" function will change the state of the BOOL which determines whether standard Window scroll bars or RISCOS-like proportional scroll bars are used |
| OpToggleSmooth | When a path point is double-clicked on, this operation is invoked to toggle the smoothness of the point. This works much like the equivalent feature in ArtWorks except that making a smooth point into a cusp will change the position of the control points |
| OpToggleSolidDrag | This class represents the OpToggleSolidDrag operation. Creating an instance of this class and calling its "Do" function will toggle the state of the flag controlling whether double buffering is used for rendering on GTK |
| OpToggleSpotPreview | An Op for toggling Spot plate print preview on and off |
| OpToggleYellowPreview | An Op for toggling Yellow plate print preview on and off |
| OpToolSelect | This class is used for Tool Selection |
| OpTranslateTrans | This is the interactive and immediate Translate operation. When doing an immediate transform the params to DoWithParams() are as follows :- Param1 - All the standard transform data Param2 - A pointer to a DocCoord that holds to offset translate by |
| OpUndo | This class represents the Undo operation |
| OpUngroup | This class represents the UnGroup operation |
| OpUngroupSpecial | This class represents the UnGroup Special operation |
| OpUpdate | This class represents the Update operation |
| OpURLImport | |
| OpWhatsThis | This class represents the global "What's This?" operation |
| OpZoom | This operation can perform zooms in and out of the current DocView, either by an immediate call to the ZoomIn/ZoomOut/ZoomInOnRect/ZoomAtPoint functions, or by a call to the DoDrag function, which starts a mouse drag to define a zoom box |
| OpZoomComboDescriptor | OpDescriptor for the zoom tool's combo-box containing scale factors |
| OpZoomDescriptor | Base class to the two zoom tool OpDescriptors, OpZoomComboDescriptor and OpZoomButtonDescriptor. Simplifies the parameters required by a constructor call, and provides default GetState and message handlers |
| OpZoomFitDrawingDescriptor | OpDescriptor for the zoom tool's "Fit to drawing" button |
| OpZoomFitRectDescriptor | OpDescriptor used to zoom to a specific rectangle |
| OpZoomFitSelectedDescriptor | OpDescriptor for the zoom tool's "Fit to selected" button |
| OpZoomFitSpreadDescriptor | OpDescriptor for the zoom tool's "Fit to spread" button |
| OpZoomIn | This op has been written so that we can use the NumPad Plus key to fire off a zoom in operation. We can`t use the zoom op directly as the hotkey code calls the Do() function instead of the DoWithParam(). What this class does is basically call the ZoomOps DoWithParam() from it`s Do() function |
| OpZoomOut | This op has been written so that we can use the NumPad Minus key to fire off a zoom out operation. We can`t use the zoom op directly as the hotkey code calls the Do() function instead of the DoWithParam(). What this class does is basically call the ZoomOps DoWithParam() from it`s Do() function |
| OpZoomPrevZoomDescriptor | OpDescriptor for the zoom tool's "Previous Zoom" button |
| OpZoomTo100 | This op has been written so that we can use the NumPad Plus key to fire off a zoom in operation. We can`t use the zoom op directly as the hotkey code calls the Do() function instead of the DoWithParam(). What this class does is basically call the ZoomOps DoWithParam() from it`s Do() function |
| OpZoomTo200 | This op has been written so that we can use the NumPad Plus key to fire off a zoom in operation. We can`t use the zoom op directly as the hotkey code calls the Do() function instead of the DoWithParam(). What this class does is basically call the ZoomOps DoWithParam() from it`s Do() function |
| OpZoomTo300 | This op has been written so that we can use the NumPad Plus key to fire off a zoom in operation. We can`t use the zoom op directly as the hotkey code calls the Do() function instead of the DoWithParam(). What this class does is basically call the ZoomOps DoWithParam() from it`s Do() function |
| OpZoomTo400 | This op has been written so that we can use the NumPad Plus key to fire off a zoom in operation. We can`t use the zoom op directly as the hotkey code calls the Do() function instead of the DoWithParam(). What this class does is basically call the ZoomOps DoWithParam() from it`s Do() function |
| OriginalBitmapRef | A reference to the original bitmap, before it was decompressed |
| OriginContextMenu | Implements the Ruler context sensitive menu |
| OriginGadget | This is the class for the "set origin" gadget, |
| OSRenderBitmap | Special version of a RenderRegion that can render into a bitmap. For now it is monochrome only. It can also be asked if it is 'blank' - this can be used for proper click detection. If USE_GDRAW_BITMAP is defined then this class is much reduced, its functionality being subsumed by GRenderClick |
| OSRenderRegion | Encapsulates rendering using the OS. (GDI, RiscOS, etc). This object is created when something needs rendering using the OS calls instead of Gavins routines. This will be ALL THE TIME for the moment. See RenderRegion notes for more general details of this class |
| OSRRFontInfo | |
| OutlineDecompositionState | |
| OUTLINETEXTMETRIC | |
| OutputDIB | Contains functions to write a DIB to a Windows BMP in segments, optionally with compression, optionally converting from one depth to another. To use: Open a CCFile for write. Call StartFile to write out the header. Call WriteBlock to write out each block of the bitmap, starting from low memory. When you're done, call TidyUp |
| OutputGIF | Contains functions to write a DIB to a GIF in segments, optionally with compression, optionally converting from one depth to another. To use: Open a CCLexFile for write. Call StartFile to write out the header. Call WriteBlock to write out each block of the bitmap, starting from low memory. When you're done, call TidyUp. Similar to OutputDIB but strangely enough writes the data as a GIF instead of a BMP or via the AccusoftFilters |
| OutputPNG | Contains functions to write a DIB to a PNG in segments, optionally with compression, optionally converting from one depth to another. To use: Open a CCFile for write. Call StartFile to write out the header. Call WriteBlock to write out each block of the bitmap, starting from low memory. When you're done, call TidyUp. Similar to OutputDIB and OutputGIF but strangely enough writes the data as a PNG instead of a BMP or via the AccusoftFilters |
| OverprintFillAttrValue | Attribute value indicating if overprint-Fill is enabled or disabled |
| OverprintLineAttrValue | Attribute value indicating if overprint-line is enabled or disabled |
| OverrideList | An override list contains items that can override each other |
| OverrideListItem | An item in an OverrideList. See class OverrideList for an explanation |
| p | |
| Page | Represents the actual bits of paper on which the document will be printed |
| PageDropInfo | Gives info about where an drag has, or is going to be, dropped on a page |
| PageMarkRegion | Holds the position and orientation of a page mark region. ie the region a page mark will be formatted in. There are current 16 regions around a typical page each having a vertical or horizontal orientation |
| PageMarkRegions | A simple structure holding the positions of all 16 page mark regions around a typical page. The constructor of this class creates the regions given the bounding rect of a page |
| PageRect | Stores a rectangle and thats it. When printing, the print manager adds rectangles to this list |
| PageRectList | Keeps a list of page rectanges in order to service the crop mark renderer |
| PageResizeInfo | |
| PageSize | Encapsulates all the page size information and functionality in one class. The class knows what size an A4 page is and what its textual name is |
| PageSizesList | Encapsulates all the page size information and functionality in one class. The class knows what size an A4 page is and what its textual name is |
| PageTab | Allows the user to set any options which are normally associated with the document's page. This includes such things as:- The size of the page as either a predefined page size or A custom page with explicit width/height control. Choice of Portrait or Landscape. Bleed size. Show page shadow switch |
| PageTabAppPrefsDlg | To open up the application preference's dialog box with the page tab selected. This is used by the pop up menu when on the page |
| PaintShopProPaletteFilter | Microsoft Windows palette filter |
| PAINTSTRUCT | |
| Palette | Something that should have been done long ago.. |
| PaletteContextMenu | |
| PALETTEENTRY | |
| PaletteFilter | Base class for all palette filters |
| PaletteFilterFamily | A filter for all palette files |
| PaletteIterator | Something that should have been done long ago.. |
| PaletteManager | |
| PaletteOptimiser | |
| PaletteOptimiser::Box | |
| PaletteOptimiser::Clr | |
| PaletteOptimiser::PalEntry | |
| PaletteOptimiser::Stats | |
| PANOSE | Kernel Panose related class and functions |
| PaperRenderRegion | Provide a fast way of rendering paper. One of these regions is used to render paper on screen, to avoid any lag we might get from using a bitmap type render region (e.g. GRenderRegion) |
| PaperSizesType | |
| ParamOpDescriptor | New ParamOpDescriptor class whose purpose in life is to allow an OpDescriptor to be created which instead of using a resource id to get the menu item/operation item text, uses a string resource. This then means we can use the name from the plug-in instead of having to resource all names! |
| Parser | This parser is in fact a lexical analyzer for ScaleUnit's It matches Numbers (IsNumeric) & Qualifiers (IsCharUnitType). Anything else is considered Unknown. This is just a fill in while I consider how to provide something more generic. The code is blardy awful, partly because of lack of support in the StringBase class. To use it (not that you would), do something like: MonoOn: Parser myParser(stringToParse); if (PrepareForParse() == FALSE) ... if (GetToken() == Parser::TK_QUALIFIER)... myQualifier = GetSemanticValue(); MonoOff: Repeated calls to GetToken() will move along the stringToParse until the end of the string is reached when TK_EOS is returned |
| PassThruBuffer | A simple structure for passing data to PostScript devices under Windows. It holds the number of bytes in the buffer followed by the data. (See SDK/MFC docs for Escape() function) |
| PasteSpecialDlg | Allows the user to choose the clipbaord format to be pasted |
| Path | Creation, manipulation and use of Paths. A path is an arbitary collection of MoveTo, LineTo and CurveTo segments Public Member variables :- BOOL IsFilled - TRUE if this path if filled, FALSE otherwise |
| PathBecomeA | Converts nodes to paths |
| PathEditedMsg | This message is sent whenever a single control point or an endpoint on a path is edited. A client of this message is the Line tool, which uses the data in this message to update the edit fields in its infobar |
| PathExtraInfo | Creation, manipulation and use of extra information on paths, eg. Pressure. A path will have a pointer to an instance of this class if it has some extra information associated with it. The extra info is stored as a number of channels, each of which is an array of 'PathExtraElements' (currently UINTs). These channels can then be mapped to one of the known 'provider data' types, eg, Line Width, Colour etc |
| PathFlags | |
| PathFlagsRecordHandler | Handles the reading of the path flag record in the v2 file format |
| PathName | Represents a simple path and filename |
| PathNameEx | Extended pathname class, having some extra features we needed in Webster:
- allows access to the drivename
- it can create a directory path on the storage medium if not present
|
| PathNameListItem | |
| PathProcessor | This is the abstract base class for all PathProcessors |
| PathProcessorBrush | This path processor renders the new brush objects in place of the paths that are passed to it. It contains many variant members which can affect the placing, scaling and other aspects of the objects that are rendered. The ink objects that are actually rendered come from a BrushDefinition object. The path processor maintains a pointer to an AttrBrushType which is the attribute node that 'owns' the processor |
| PathProcessorStroke | This is the abstract base class for all PathProcessors |
| PathProcessorStrokeAirbrush | A path processor which renders paths as airbrushed strokes |
| PathProcessorStrokeVector | A path processor which "moulds" vector clipart along a path |
| PathRecordHandler | Handles the reading of all fill attribute records in the v2 file format |
| PathStroker | Abstract Base class Converts a Trapezoid (See ProcessPathToTrapezoids, pathtrap.h) stroke definition into an output path |
| PathStrokerVector | Path stroker Converts a Trapezoid (See ProcessPathToTrapezoids, pathtrap.h) stroke definition into an output path |
| PathUtil | Base class for path utility static functions. These functions operate on sections of paths, ie lists of doc coords, but do not process complete paths and hence cannot be included as member functions of the paths class. The class contains no member variables, just static member functions which would otherwise be global if not for the fabby idea of encompasing them together under a class structure |
| PBMFilter | Encapsulates a Unix PBM import filter |
| PBMOILFilter | Provide the OIL parts of the PBM filter which loads in the file as a BMP |
| PColourCIET | |
| PColourCMYK | |
| PColourGeneric | |
| PColourGreyT | |
| PColourHSVT | |
| PColourIndexed | |
| PColourRGBT | |
| PCXOILFilter | Provide the OIL parts of the PCX filter which loads in the file as a BMP |
| PendingRedraws | Encapsulates a set of regions in a DocView, which must be accumulated in order for them to be redrawn at some point, possibly all in one go. This class chooses the most efficient invalidation method, according to the number and nature of regions added |
| PenTool | This class handles the Pen Tool that is used to draw lines and curves via clicking and draging on the workarea |
| PenToolInfoBarOp | Class for handling the pen tool's information bar |
| PenToolInfoBarOpCreate | Class for creating PenToolInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| PerspectiveShapes | The default perspective shapes class. This class provides a bunch of static functions to create some default shapes. All shapes are defined on a (0,0),(72000,72000) coordinate system |
| PGMFilter | Encapsulates a Unix PGM import filter |
| PGMOILFilter | Provide the OIL parts of the PGM filter which loads in the file as a BMP |
| PhotoCDDlg | |
| PhotoCDDlgParam | Allows data to be passed into the photocd options dialog box and then returned to the caller |
| PhotoCDOILFilter | Provide the OIL parts of the PHOTOCD filter which loads in the file as a BMP |
| PhotoShopEPSFilter | A filter that imports EPS files in Adobe Photoshop EPS format. Well, actually it doesn't as it's just a stub to stop Photoshop files from being loaded in (as they stuff up) |
| PhotoShopEPSOILFilter | Provide the OIL parts of the PhotoShop EPS filter |
| PhotoShopOILFilter | Provide the OIL parts of the PhotoShop filter which loads in the file as a BMP |
| PICTOILFilter | Provide the OIL parts of the PICT filter which loads in the file as a BMP |
| Pixel32bpp | This structure defines the layout of a 32bpp RGB pixel value, in a nice kernel compatible way. They should be used for kernel access to bitmaps so that pixels are treated in a platform independent manner |
| PlasmaFractalFill | A fractal fill class. Static fns only |
| PluginFilterProcess | |
| PlugInHandler | Provides specific characteristics of a type of plug-in. This includes the type of file which the plug-in in usually stored in. This provides the basis of which a handler is derived from |
| PlugInItem | Provides the minimum requirement to store details on a plug-in |
| PlugInManager | Provide general handling facilities for plug-ins in Camelot |
| PluginNativeFilter | This is the plugin import/export filter that passes Xar format data to an external object for further processing |
| PluginOILFilter | This class is used to encapsulate the platform specific features of a filter. Every Filter object has a pointer to an OILFilter object. For example, under Windows, it holds the file extensions that this file understands |
| PlugInOp | |
| PlugInOpDescriptor | New PlugInOpDescriptor class whose purpose in life is to allow an OpDescriptor to be created which instead of using a resource id to get the menu item/operation item text, uses a string resource. This then means we can use the name from the plug-in instead of having to resource all names! |
| PlugInPath | Represents a pathname object that the user has requested that all plug-ins be loaded in from |
| PlugInPathList | Holds a list of Pathnames that the PlugInManager will use to search for plug-ins. The list is set up by the user in the plug-ins options tab |
| PlugInsContextMenu | Implements the plug-ins context sensitive menus |
| PlugInsTab | Allows the user to define options assocaited with plug-ins. At present this covers:-
- setting up the pathnames to use
- a switch to say whether to parse the plug-ins at start up or not
|
| PlugInUndoOp | Undoable Operation so that a plug-ins can be invoked and used |
| PlugsTabAppPrefsDlg | To open up the document preference's dialog box with the plug-ins tab selected. This is used by the plug-ins menu item (under 'Bitmap Effects & Plug-Ins') |
| PNGExportOptions | Base class for storing information about the bitmap we're exporting |
| PNGFilter | Encapsulates a PNG export filter. Derives off the masked filter which provides funcitonality for doing masked bitmap export and import |
| PNGOILFilter | The PNG File format Oil Filter (Extension etc) |
| PNGProgressBar | Controls the status bar while loading / saving png files |
| PNGUtil | Contains functions to read in a PNG file as a DIB |
| POINT | |
| Point2 | |
| PointersTab | Allows the user to set any options which are normally associated with Pointers. This includes such things as:- Magnetic snap radii Actions for the different mouse buttons |
| PolygonRecordHandler | Handles rectangle type records from the new file formatRecord handler for polygons, used when importing polygons from the new file format. Derived from the regular shape record handler, so we use all the functions in that class to complete the regular shape |
| POLYPOLYGON_INFO16 | |
| PositionCaretAction | This action is used to position a caret within a TextStory. Its execute function inserts another PositionCaretAction into the undo record to return the caret to its current position and then moves it to the stored position |
| PPMFilter | Encapsulates a Unix PPM import filter |
| PPMOILFilter | Provide the OIL parts of the PPM filter which loads in the file as a BMP |
| PPStackLevel | |
| PreDelFactorOutInfoItem | PreDelFactorOutInfoItems are used by the GetPreDelFactorOutInfo and DoFactorOutAfterDeletion functions. See these for a description of its purpose |
| PrefData | |
| PreferenceChunk | Objects of this class hold a chunk of preferences for a particular section of the preferences. There may be more than one chunk for a given section, depending on how accurate the initial declaration of the section's size was |
| PreferenceEntry | Instances of this class hold information about a single preference. This is a very simple public class with no member functions |
| Preferences | Maintains a list of PreferenceSection objects, and allows clients to declare new sections, and add new preferences to the sections |
| PreferenceSection | Holds all the preferences for a particular section of the preference file. These preferences are stored in one or more instances of the PreferenceChunk class. These instances are linked together as a List by this class |
| PrefixQualifier | A prefix qualifier is one of the form <QualifierToken><...>, e.g. 5.00 |
| PrePostTextAction | This action will be generated at the start and end of an OpTextUndoable operation. It will perform the following tasks |
| PressureItem | To store information about brush objects, including pressure |
| PressureSmoother | Given a bunch of pressure samples (from a graphics tablet, or simulated from mouse movements) this class provides methods to produce a ValueFunction object representing the variable-pressure information. The pressure information is smoothed to reduce the amount of data that needs to be saved, and to improve the quality of the pressure information (e.g. to get smooth pressure-pen strokes) |
| PreviewContextMenu | The context menu for the bitmap preview dialog |
| PreviewDialog | |
| PreviewDialog::PreviewTimer | |
| PreviewFilter | The filter's sole purpose is to hold the PreviewBitmapSize static. It can not import, export or appear on a menu. Notes: 20/01/97 This class used to be derived from AccusoftFilters (but prob never should have been). All other preview filters were derived from this, but are now derived from their respectively similar file filter i.e. PreviewFilterBMP is derived from BMPFilter. This causes a problem with FILTERIDs cos FILTERID_PREVIEW_TIFF is defined to be the same as FILTERID_PREVIEW obviously this won't work now that the filters are not all derived from PreviewFilter |
| PreviewFilterBMP | The filter will save out the BMP Preview Bitmap. Overrides GetExportOptions so dialogs are not put up but returns preview export options |
| PreviewFilterGIF | The filter will save out the GIF Preview Bitmap. Overrides GetExportOptions so dialogs are not put up but returns preview export options |
| PreviewFilterJPEG | The filter will save out the JPEG Preview Bitmap. Overrides GetExportOptions so dialogs are not put up but returns preview export options. Note: 22/01/97 Preview filters can generally import as well now (if their base class can) but obviously this one can't - use JPEGImportFilter instead |
| PreviewFilterPNG | The filter will save out the PNG Preview Bitmap. Overrides GetExportOptions so dialogs are not put up but returns preview export options |
| PreviewInBrowserTab | Allows the user to set various Animation Colours |
| PrintBaseTab | Allows the user to set any options which are associated with general document printing |
| PrintComponent | Provide a component that contains a ptr to the document's PrintControl object |
| PrintComponentClass | Provide a class that will add print components to new documents |
| PrintControl | This class encapsulates all the print settings for a document, and controls how the document pages are printed on the paper |
| PrintGeneralTab | Allows the user to set any options which are associated with general document printing |
| PrintImagesetterTab | Allows the user to set various imagesetting options |
| PrintingMaskedRenderRegion | This is a simplified version of the MaskedRenderRegion. It does not have to cope with a mix of complex and simple shapes to be rendered, but knows that there will be a run of complex shapes and then all the rest will be simple |
| PrintingRecordHandler | Handles importing of the print options records: TAG_PRINTERSETTINGS TAG_IMAGESETTING TAG_COLOURPLATE |
| PrintLayoutTab | Allows the user to set any options which are associated with general document printing |
| PrintMark | This class contains all the information pertaining to a mark. ie the type of mark it is, its menu text, icon id and a list of all the regions and formatting rules it uses |
| PrintMarkComponentClass | The class that gets a print mark doc component going on start up We need to register our class as a document component and this is where we do it all |
| PrintMarkItem | The PrintMarkItem contains details about this print mark. It holds the mark type, formatting information and a pointer to a subtree of objects which represent the mark. It also contains various bits of information used by Camelots UI to present the mark to the user |
| PrintMarksCache | The print marks cache. This class contains a list of cached printmarks kept by the print marks manager. It is split into its own class here to avoid complications will the mark managers handling of cache marks and document component marks |
| PrintMarksComponent | An actual print mark document component. This component contains a list of handles which refer to print marks cached by the print marks manager. On saving, the mark handles will be resolved into physical marks which will be exported and subsequently imported and registered |
| PrintMarksMan | The 'Print Marks Manager'. This manager handles the installation, formatting and rendering of printer marks. It liaises with the print box to provide a UI to enable and disable print marks |
| PrintMonitor | Monitors print jobs to ensure that we don't try to start more than one simulataneously, and to ensure that print jobs are released when we suffer a serious error (CPU exception). Also repository for printing preferences |
| PrintMsg | This is sent when something to do with the printer has happend |
| PrintOnAllPlatesAttrValue | Attribute value indicating if "print on all plates" is enabled or disabled |
| PrintPatchInfo | This class encapsulates all the info required to print the next patch on the current piece of paper |
| PrintPrefsDlg | |
| PrintProgressDlg | Maintains the print progress dialog which shows the user how the print is going and also allows them to cancel the print at any time |
| PrintPSRenderRegion | Provide a render region for rendering to PostScript devices (usually via a PostScript printer driver) |
| PrintRenderCallback | Handling callbacks from RenderTree Notes: RenderTree function calls the main function in this class when it's about to render any Node |
| PrintSepsTab | Allows the user to set options which are associated with printing colour separations |
| PrintTabPrintPrefsDlg | To open up the print preference's dialog box with the print tab selected. This is used by the units button on the tool bars |
| PrintView | |
| ProcessBitmapState | Holds the state of a bitmap during processing and implements functions to push the bitmap through the processing pipeline |
| ProcessDistance | If a platonic piece of string whose length l and endpoints (p0,p1) is laid along a path [e0,e1,e2,....en], this class calculates the index of the element ei, which contains p1 and the parameter mu (0<=mu<1) which can be used to calculate the actual coordinate value of p1 |
| ProcessFlags | |
| ProcessFlatten | Flattens a path to the user specified output buffer using a given flatness |
| ProcessGrid | An abstract class used for processing a grid |
| ProcessGridForceRedraw | Forces a redraw on the given grid |
| ProcessGridUnitMsg | Something has happened to the units system |
| ProcessLength | Calculates the length of a path |
| ProcessPath | |
| ProcessPathDistance | Process path to find Coord and Tangent at specified distance along path |
| ProcessPathToTrapezoids | Process a path to produce a trapezoid list suitable for variable- width or vector-brushed stroke generation |
| Progress | |
| ProgressDisplay | Encapsulates various bits of information required to provide a progress display while printing/exporting via View::RenderSimpleView() |
| PropertyTabs | These encompass some useful functionality which is required to get a property dialog tab up and running. This is the baseclass and should always be derived off from. Tabs currently available are:-
- layer properties dialog box
|
| PropMapEntry | |
| PSDCFontInfo | |
| PSPPaletteOILFilter | Provide the OIL parts of the paint shop pro palette file filter |
| PSPrintDC | Provide a device context for printing to a PostScript printer |
| PtCoefs | |
| PushModule | |
| PushTool | This class handles the Push Tool that is used to slide the document about in a more convienient way than using the scroll bars. Most of the hard work is done in the OpPush (The push operation) |
| Qualifier | A ScaleUnit is defined by: A range for which the scaled value is between 0 & 1 A scaler which converts any value in its range to between 0 & 1 A qualifier which may be prefixed or suffixed onto the value NB: There are no base units as such |
| Quality | Encapsulates the 'quality' of rendering, which in ArtWorks-speak was the WYSIWYG value. It is really a numeric value, but this fact should be hidden from everyone who should ask specific things of it, not use its value |
| QualityAttribute | Attribute for quality of display/rendering |
| QualitySliderDescriptor | |
| QuantisationCell | |
| QuickRenderer | |
| QuickShapeBase | The base class for the Quick shape tool family. Not actually a tool itself but the QuickShape, Ellipse and Rectangle tool are derived from it |
| QuickShapeBaseInfoBarOp | Class for handling the Regular Shape tool's information bar |
| QuickShapeBaseInfoBarOpCreate | Class for creating RegShapeInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| QuickShapeTool | The QuickShape tool |
| RadialFillAttribute | Specifies a radial fill attribute for an object, including the two vectors that define the ellipse |
| RadialTranspFillAttribute | Specifies a radial fill attribute for an object, including the two vectors that define the ellipse |
| RadioGroup | Allows user interface gadgets (GadgetID) to be associated with objects (CCObject), which can then respond to messages sent to the gadgets |
| RalphDocument | The RalphDocument COM object |
| RampItem | Defines whats common to all ramp items, i.e. their position and selection state |
| RandomSelection | |
| Range | |
| RangeControl | |
| RangeEnumerator | Iterates through a series of NodeRenderable nodes |
| RangeList | Holds a list of ranges. This is used to keep track when importing a file and preserving the layer information, and the import was initiated via drag and drop. When the import has finished, the bounding box of all the nodes on all the ranges is found, and then the all the nodes in all the ranges are centred on the drop point |
| RangeListItem | Hold a range that |
| RangeSource | Concretisation of NodeScan::Source for all NodeRenderableInks in a Range (generally), or in the Application's SelRange object (specifically) |
| RealLogPalette | |
| RecalcBoundsAction | An action which records the bounding box of a node, and replaces it on Undo, invalidating that area. This action should be added to the action list before modifying the object's bounding box. Please note that for undo and redo to work correctly, after you have modified the bounding box, you should create a RecordBoundsAction object and append that to the action list. This action is the opposite action to Recalc, and the two should always be used in tandem |
| RecordBoundsAction | An action which simply marks the fact that, when undone, it has to create a RecalcBoundsAction, and invalidate the existing bounds. It is the opposite action to RecalcBounds and should be used after creating a Recalc object and modifying the bounding box. Even when executed, all the action does is invalidate the screen and create a Recalc action |
| RecordChangeCodesAction | This class records undo/redo information for the Perspective shape object |
| RecordEnvelopeAction | This class records undo/redo information for the Envelope shape object |
| RecordGeometryAction | This action records the current mould geometry being used by a particular mould node. Once recorded this allows the geometry to be changed. During undo the old geometry will be replaced but not initialised |
| RecordPerspectiveAction | This class records undo/redo information for the Perspective shape object |
| RecordReferenceItem | When importing & exporting we want to hang on to references of the records we've written or read and the objects they represent, so that referencing records can pick up the associated item. This abstract class provides just the record reference (XFileRef). Derived classes should provide the object |
| RecordReferencingExporter | |
| RECT | |
| Rect | This class is used to represent a rectangular region. It uses a union to enable the client to access the rectangle as two Coords (lo and hi) or as four INT32s (lox, loy, hix, hiy). An anonymous union is used, which is a defined C++ feature and so portable |
| RectangleRecordHandler | Handles rectangle type records from the new file format Record handler for rectangles, used when importing rectangles from the new file format. Derived from the regular shape record handler, so we use all the functions in that class to complete the regular shape |
| RectangleTool | The QuickShape Rectangle tool |
| RectListItem | |
| RedoAction2 | Dummy BlobbyOp REDO action. Does nothing when it executes |
| RedoAction3 | Dummy BlobbyOp REDO action. Does nothing when it executes |
| RedoColAction | Simple BlobbyOp action which restores the colour of a documents page to the colour it was prior to the operation being undone |
| RedrawBoundsAction | An action to record the bounds of the mould. This op differs from RecordBoundsAction in that it does not use GetUnionBlobBounds() which is really bad for perspectives as this includes the vanishing points which results in a vast area of the document being redrawn. So we have to do everything separately |
| ReDrawInfoType | |
| RefItem | Item class for the Reference sorting system |
| RegenerateContourAction | Forces a regeneration of the bevel in all nodes in the list Used by NodeBevelcontroller::OnChildChange to force redraws in undos/redos |
| RegenerateFeatherContourAction | |
| REGION | |
| Region | The class defines an area of the screen. At the moment it is a DocRect, but eventually it will be decribed by a path or something |
| Registry | |
| RegistryEntry | Represents an entry in the registry consisting of a key, subkeys, and some values |
| RegularShapeRecordHandler | Base class record handler for regular shapesBase record handler for regular shapes, used when importing regular shapes from the new file format |
| ReleaseInfo | |
| RemapBlendAction | An action which undoes the remapping of a blend |
| RemoveAttributeParam | Parameter for OpRemoveAttributeFromSelection, giving the ClassID of the attributes to remove from the selection |
| RemoveFloaterAction | An action to provide the Line tool with an undoable way of removing the floating endpoint. This isn't stored in the document, which makes life tricky |
| RemovePathElementAction | An action which undoes the insertion of an element into path data (hence removing that element from the path) |
| RemovePressurePointsAction | An action which removes points from the pressure data list of a BrushAttValue |
| RemoveTimeStampPointsAction | An action which removes points from the timestamping list of a BrushAttValue |
| RenameObjectsDlg | |
| RenderableNodeEnumerator | Iterates through a series of NodeRenderable nodes |
| RenderCallback | Provide a base class for handling callbacks from RenderTree Notes: RenderTree function calls the BeforeNode function in this class when it's about to render any Node. Derive from this class and implement Callback to provide specialised processing of nodes during rendering Derived versions of Callback can: Prevent the node being rendered Set attributes Set subrender contexts Accumulate their own info about the render sequence |
| RenderControl | A RenderControl object is created to control the interruption of rendering. It provides a Stop function which can be called by a rendering routine to determine whether or not it should stop |
| RenderDemoDlg | A Sample dialog that renders stuff into itself using render regions |
| RenderDialogOp | Acts as a base class for all Dialogs that want to render using render regions in them |
| RenderRegion | THIS IS AN ABSTRACT CLASS. Don't try to create a RenderRegion itself, but rather create one of it's derived classes. A RenderRegion object is created when an area of the screen/printer (or any destination) has become invalid and needs to be redrawn. It 'lives' for as long as that region is still invalid. It is also used for e.g. exporting files or in smart click detection. Background rendering and region merging is achieved by using a List of Render Region objects. When a new region becomes invalid, a RenderRegion is created and added to that list. If the rendering is interrupted before it is complete, then it will continue again when the OnIdle routine scans through the list of RenderRegions. RenderRegions can also be created at other times for Immediate rendering. To use a RenderRegion, create an OSRenderRegion or a GRenderRegion depending on the method of rendering required, then Attach a DC and CWnd to the region to specify the Render destination. Next call InitRender which will return the RenderRegions previous render state if it had been interrupted or Null if it has just been created. You can then set attributes, Save/Restore them, and Render objects. When rendering is complete, call ExitRender passing the current render state |
| RenderRegion::_FillFlags | |
| RenderRegion::_StrokeFlags | |
| RenderRegion::_TextFlags | |
| RenderRegion::FlagBlock | |
| RenderRegionList | Holds a list of RenderRegion objects for the application to process. It should be used to add or remove render regions, or to initiate background rendering on idle events |
| RenderStack | To provide a stack on which to save attribute values while rendering the Camelot tree. The stack is optimised to minimise the amount of pushing and popping actually done |
| ReplaceAttributesParam | The parameter for the OpReplaceAttributes operation |
| RequiredAttributeItem | This ListItem holds an attribute's runtime class, plus a flag indicating if we have found the attribute. It is used by NodeRenderable::MakeAttributeComplete |
| ResourceIDWithFlagsEqual | |
| ResourceIDWithFlagsHash | |
| RestoreFillRampAction | An action which undoes the modification of Grad Fill data. This action can be used for undoing changing control points. This operation Changes the Colour of a Fill already in the tree. This operation Changes the Colour of a Fill already in the tree. An action which undoes the modification of Grad Fill data. This action can be used for undoing changing colours. Action for restoring fill ramps after changes have been made |
| RestoreSelectionsAction | When executed this action will restore the selection state of the document. It will also spawn another identical RestoreSelectionsAction adding and add it to the opposite action list |
| RetroSmooth | A new class to control retro smoothing of path regions |
| ReversePathAction | This action is used to reverse (change direction of) the path inside a TextStory |
| RGBQUAD | |
| RGBT | |
| RGBTRIPLE | |
| RGNDATA | |
| RIFFck | |
| RIFFFile | Nice class for reading RIFF files, takes a CCFile in the Init() routine to get it's data from. This doesn't view a RIFF file quite how they're actually stored on the disc. It's viewed as a series of Objects. These objects can be Chunks Start of lists End of lists End of file An object inside a list has a higher level than the list and chunks just before the list. You ask for the next object with NextObject(). This reads in the details about the next object in the file, which you can then read with the Get functions. You can get at the data with GetChunkData - this will error if the last object is not a chunk. This function reads the data into a block you give it. Alternatively, use AquireChunkData which will read it into a block maintained by this class. Data is not read unless it has to be. RepeatCurrent() will repeat the current object, giving one level of rewind. Useful for reading files with naff structures. SkipToListEnd() will skip to the end of the list of the level given |
| RIFFFile_Header | |
| RIFFFile_List | |
| RIFFFileLevel | |
| RolloverState | |
| RotateTool | Implementation of the Rotate Tool |
| RRCaps | This class has been designed to hold all the different things that a render region may or may not be able to render. eg. Some render regions can render transparency, while others can not. This class is used to record what your render region can do. It does this by having a flag for all the area of rendering that some regions can do and other can not. By default this class assumes that you can do nothing, so it is up to you to set the flags for the things you can do to TRUE. TRUE means you can render that type of thing, FALSE means that you can not. The flags to date are :- |
| RulerBase | Common base class for a ruler (X and Y derived) |
| RulerContextMenu | Implements the Ruler context sensitive menu |
| RulerPair | Encapsulates a horizontal and vertical ruler pair |
| RulerRedrawData | Structure containing semi-permenent redraw data |
| SafeRenderPointer | A object to handle the current 'safe' rendering pointer within the document. This is used for 'Progressive Rendering' (see kernel.h/cpp), during the loading of a document |
| SaveDetachAction | This action saves and restores the detach flags inside a mould object |
| SaveFileDialog | This is the Save Dialog that is brought up in responce to the saveas option. It will select the last used directory etc and is generally very fabby |
| SavePathArraysAction | Given a path, save the paths array data, ie all its verbs, coords and flags on the undo. Use DoRecord(Operation*, ActionList*,Path*) to save the path |
| SaveRegistryEntries | This class can be used for saving a list of items into the registry |
| SaveTemplateDialog | The Save Template dialog. It saves templates, basically |
| ScaleTab | Allows the user to set any options which are normally associated with a documents scaling |
| ScaleTabAppPrefsDlg | To open up the application preference's dialog box with the scale tab selected. This is used by the scale button on the tool bars |
| ScaleUnit | A ScaleUnit is defined by: A range for which the scaled value is between 0 & 1 A scaler which converts any value in its range to between 0 & 1 A qualifier which may be prefixed or suffixed onto the value NB: There are no base units as such |
| ScaleUnitReference | |
| ScannerRenderCallback | Handling callbacks from RenderTree Notes: RenderTree function calls the main function in this class when it's about to render any Node |
| ScanningRenderRegion | The Scanning Render Region is a special sort of render region that simply scans the document and works out where abouts there are complex shapes that can not be rendered by a normal OSRenderRegion. Complex shapes are shapes that are transparant or any other attribute that we are unable to render to normally. The Scanning Render Region is used to help with things like printing, Renderable EPS export etc where transparancy is not available |
| ScopedFlagSetter | For counting "rendered" objects without actually rendering them |
| ScreenCamView | A subclass of CCamView which is the class actually used for screen display |
| ScreenCamView::ScreenCamCanvas | |
| ScreenChangeMsg | A message to be broadcast whenever what is on the screen changes. This can be a dialog closing, or scrollbar moving or object being moved. It is vital to the brush that it be informed whenever something like this happens |
| ScreenView | A subclass of CCamView which is the class actually used for screen display |
| ScreenView::ScreenCanvas | |
| ScrollPageInc | ScrollPageInc records the number of units a scroll bars thumb should move for a page up or down scrollbar action. A ScrollPageInc is created and added to the DialogManager's ScrollPageIncList whenever the DialogManager::SetGadgetRange is called for a scrollbar or trackbar control |
| SelChangingMsg | This message is sent at the end of all operations which have changed the selection |
| SelectAllOp | The Select All operation |
| SelectDeselectAction | When executed this action will render node's selection blobs (which could remove them) and set it's selection state. If the node is currently selected then the node is deselected. If the node is currently deselected it is selected. It creates a second SelectDeselectAction for the node and adds it to the opposite action list |
| SelectDocSource | |
| SelectedAttrs |
|
| SelectIntersectScan | Selects objects which are in all of the highlighted set items |
| SelectionState | Used to record and restore all selections in the Camelot tree |
| SelectNoneOp | The Clear Selection operation |
| SelectObjSource | |
| SelectorInfoBarOp | Class for handling the Selector tool's information bar |
| SelectorInfoBarOpCreate | Class for creating SelectorInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| SelectorTool | The Selector tool is used to change the selection, edit objects and transform them. The Selector tool now derives from the DragTool, so that TransOperation may refer to a general DragTool when an object drag is in progress. At a later date, drag functionality may be pulled up into DragTool, to allow future tools to implement dragging of objects more easily |
| SelectorTool::IterateFlags | |
| SelectScan | Selects objects which are in the set item whose selection toggle has been clicked |
| SelectUnionScan | Selects objects which are in any of the highlighted set items |
| SelectUnionScan::Test | |
| SelEditRecord | |
| SelMediaDlg | |
| SelMediaDlgParam | |
| SelNdRng | SelNdRng objects are stored in an array within SelectionState objects, they record a range of upto 255 contiguous nodes as being selected |
| SelObjPathList | This class encapsulates all the data needed for each selected object |
| SelObjPathListItem | This class encapsulates all the data needed for each path generated by the objects that are being combined. A list of all the paths that each of the selected object generates is made, and each path generated creates an instance of this class |
| SelOperation | A SelOperation |
| SelRange | This class represents a range of selected nodes directly under the Selection Surface. The Selection Surface is the highest surface in the tree at which the user can select nodes. It is usually the child list of Layers but the user can push the Selection Surface lower, into groups, using Select Inside |
| SelRangeMessageHandler | Intercepts messages for the SelRange. (Basically sits there and flushes the Selection's information cache whenever it thinks the selection cache has become invalid) |
| SentryOperation | A SentryOperation is a non-undoable operation which hangs around on the live operations list (receiving message broadcasts) for the lifetime of the system |
| SepsDlg | |
| SepsDlgParam | |
| Set | |
| SetSentinelSource | |
| SetTimeStampUpdateTypeAction | The purpose of this action is to set a flag that determines what happens when the brushed nodepath calls its timestamping brush attribute to update itself. Setting this flag to TRUE indicates that our path has changed so that our timestamping list coordinates are no longer on the line. Therefore we will reposition these points on the new line. Setting it to FALSE indicates that we have added or removed points from the timestamping list and should sort and reorder it to make sure it is ok |
| SGalleryLinePropertiesDlg | |
| SGalleryOptionsDlg | |
| SGallerySearchDlg | |
| SGallerySortDlg | |
| SGATMItem | A DisplayTree node for ATM fonts in the Fonts SuperGallery |
| SGBitmapDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag |
| SGClaimPointInfo | |
| SGClipartDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag |
| SGClipartItem | A clipart gallery item |
| SGColourDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag |
| SGDisplayColour | This DisplayTree node is used by the Colour SuperGallery It is responsible for providing the ability to handle/redraw one IndexedColour displayed in said gallery |
| SGDisplayColourGroup | A derived SGDisplayColourGroup class for the Colour gallery groups |
| SGDisplayDATATYPE | This DisplayTree node is used by the TEMPLATE SuperGallery It is responsible for providing the ability to handle/redraw one DATATYPE displayed in said gallery |
| SGDisplayFlags | |
| SGDisplayFrame | This DisplayTree node is used by the Layer SuperGallery It is responsible for providing the ability to handle/redraw one Layer displayed in said gallery |
| SGDisplayGroup | This DisplayTree node type is used by the SuperGallery The top level(s) of the DisplayTree are made up of a number of SGDisplayGroup nodes, which divide the tree up into categories (and, potentially hierarchical groups within categories) |
| SGDisplayItem | This DisplayTree node is used by the SuperGallery It is responsible for providing the ability to redraw one item displayed in the gallery, and remembering information on that item (such as its selection state, etc) |
| SGDisplayKernelBitmap | This DisplayTree node is used by the Bitmap SuperGallery It is responsible for providing the ability to handle/redraw one KernelBitmap displayed in said gallery |
| SGDisplayLayer | This DisplayTree node is used by the Layer SuperGallery It is responsible for providing the ability to handle/redraw one Layer displayed in said gallery |
| SGDisplayLibColGroup | A derived SGDisplayLibColGroup class for Colour gallery libraries |
| SGDisplayLibColour | |
| SGDisplayNode | This DisplayTree node type is used by the SuperGallery This is a virtual class from which all nodes in the DisplayTree are derived |
| SGDisplayPreviewFonts | This is the base-class for the installed font items in the fonts gallery. An instance of this class should never be created, instead SGTTFItem and SGATMItem's should be used |
| SGDisplayRoot | This DisplayTree node type is used by the SuperGallery The top (root) level of the DisplayTree is made up of a single SGDisplayRoot node. This node is used as a single entry-point for all tree-wide actions which the SuperGallery applies to it (redraw, reformatting, etc) |
| SGDisplayRootScroll | This DisplayTree node type is used by the SuperGallery |
| SGFieldCache | |
| SGFillsDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag |
| SGFillsItem | A fills gallery item |
| SGFontsDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag |
| SGFontsGroup | This is a display tree group specifically for the fonts gallery - it disables various documenty things, and provides overrides for the group text |
| SGFormatInfo | |
| SGFrameGroup | This is a display tree group specifically for the layer gallery - it disables group things like folding, and provides column headings for the layers display |
| SGInit | Provides static functions for initialisation/deinitialisation of the SuperGallery system, plus useful internal SuperGallery work functions |
| SGLayerGroup | This is a display tree group specifically for the layer gallery - it disables group things like folding, and provides column headings for the layers display |
| SGLibDisplayItem | |
| SGLibFontItem | A library font gallery item |
| SGLibGroup | This is a display tree group specifically for library galleries The main reason for implementing it was to receive library group messages |
| SGLibOil | Initially, general OILy utilities for the library, but then the Add Library dialog code was added in.. |
| SGLineDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag |
| SGListDragInfo | Describes a generic supergallery item drag |
| SGListDragTarget | |
| SGMiscInfo | |
| SGMouseInfo | |
| SGNameDrag | A Wix ObjectName attribute drag, which was started from the Name gallery |
| SGNameDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag. This particular target is used for handling drags of NameGalllery items within their displayed list. It automatically handles drags with draginfo derived from BitmapDragInformation. Notes: Drag targets are destroyed automatically when a drag finishes by the drag manager with which they were registered. To remove a drag target at any time, destroy it - it automatically deregisters and cleans up |
| SGNameGroup | A SuperGallery group of SGNameItems. Records whether this group's display needs to be updated on the next idle event because of a change to its Document's named objects |
| SGNameItem | Represents an item in the Name gallery's display |
| SGNameProp | Abstract base class for the various kinds of properties associated with SGNameItems |
| SGOilClipartDragTarget | Drag Target for the mainframe, so dragging clipart into a null document situation (behind all the docs) will load a new document |
| SGOptsSortInfo | |
| SGRedrawInfo | |
| SGScrollDragInfo | Describes a supergallery scroll drag |
| SGScrollDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag |
| SGSortKey | |
| SGTTFItem | A DisplayTree node for TrueType fonts in the Fonts SuperGallery |
| SGUsedBitmaps | |
| SGUsedColourItem | |
| SGUsedColours | |
| SGUsedFonts | |
| SGUsedNames | NameGallery groups and items to manage the various types of attribute sets |
| ShadowRecordHandler | Handles the reading of all shadow records in the v2 file format |
| ShapeEditedMsg | This message is sent whenever a shape is edited |
| ShowNodeAction | When executed this action will show a node. It will also generate a HideNodeAction action adding it to the opposite Action list |
| SimpleBarControl | Contains all info about the control, plus a ptr to a message handler to pump all the messages to |
| SimpleBecomeA | A simple becomeA object that retrieves paths from nodes and makes them available to you, the user without messing around with MakeNodePathFromAttributes or any of that rubbish |
| SimpleBitmapRenderCallback | |
| SimpleCCObject | Override new and delete, so that new returns NULL when no more memory is available, rather than throwing an exception |
| SimplePrintRenderCallback | |
| SingleBitmapSelection | |
| SingleNodeSource | Concretisation of NodeScan::Source for a "scan" over a single node (generally), and over the 'selected' document's NodeSetSentinel sentinel (specifically) |
| SingletonAppliedAttribute | Represents an applied attribute of which there is only one for the objects given by the iterator |
| SliceHelper | |
| SliceInfoBarOp | |
| SliceInfoBarOpCreate | Class for creating SliceInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| SliceSaveFileDlg | |
| SliceTool | SliceTool is actually a misnomer. This tool is used for creating rollover buttons and bars for web pages |
| SnapShotItem | Defines what is saved during a current attribute snap shot |
| SnapShotList | Defines what is saved during a current attribute snap shot |
| SpanListItem | |
| SpecialEntry | |
| Spread | |
| SpreadMsg | This is sent when a spread event is happening that may be of interest to all you message handlers out there |
| SpreadRedraws | Encapsulates a set of regions on a spread, which must be accumulated in order for them to be redrawn at some point, possibly all in one go. This class chooses the most efficient invalidation method, according to the number and nature of regions added |
| SpreadSelection | |
| SpriteOILFilter | Provide the OIL parts of the Acorn Sprite filter which loads in the file as a BMP |
| SquareFillAttribute | Specifies a Square graduated fill for an object, including the start and end points |
| SquareTranspFillAttribute | Specifies a Square graduated fill for an object, including the start and end points |
| Stack | A general purpose stack for storing ListItems |
| StackT< Object > | Generic StackT |
| StandardBar | A class implementing "fixed content" bars Notes: In the OIL See Also: |
| StandardBarMsg | A tiny message local to the standard bar class |
| StandardDefaultRecordHandler | |
| StandardUnit | A class utility defining standard units for use as you please, although corrupting them may cause some annoyance. Notes: Contains only static members. See Also: class UnitGroup, class ScaleUnit |
| StartArrowAttribute | Attribute for start arrow type of paths |
| StartCapAttribute | Attribute for start cap style of paths |
| StartDocument | |
| StartRebuildMouldAction | When executed this action will get the mould to rebuild itself |
| static_tree_desc_s | |
| StaticTextControl | Represents a Static Text Control (Label) in a DialogOp |
| STATISTICS | |
| StatusBarPaneData | |
| StatusLine | Encapsulate the status line |
| StatusLine::StatusTimer | |
| StoreCharCodeAction | This action is used to restore a character's UniCode value on undo. Using this an op can chage the character code of a TextChar without having to hide the old char and create a new one |
| StoreKernCodeAction | This action is used to restore a kern value on undo. Using this an op can change the kern value without having to hide the old KernCode and create a new one |
| StorePathIndentAction | This action is used to store a text stories path indent value |
| String_128 | Extends its String base class to become fixed-length and atomically allocatable, ie. a failed constructor call for this class will never leave the object in an illegal state |
| String_16 | Extends its String base class to become fixed-length and atomically allocatable, ie. a failed constructor call for this class will never leave the object in an illegal state |
| String_256 | Extends its String base class to become fixed-length and atomically allocatable, ie. a failed constructor call for this class will never leave the object in an illegal state |
| String_32 | Extends its String base class to become fixed-length and atomically allocatable, ie. a failed constructor call for this class will never leave the object in an illegal state |
| String_64 | Extends its String base class to become fixed-length and atomically allocatable, ie. a failed constructor call for this class will never leave the object in an illegal state |
| String_8 | Extends its String base class to become fixed-length and atomically allocatable, ie. a failed constructor call for this class will never leave the object in an illegal state |
| StringBase | |
| StringListItem | A String_256 in a list item |
| StringToBitmap | Generation of anti-aliased font-string bitmaps for the font installer / de-installer |
| StringVar | Extends its String base class to become self-sizing. This means that we need to override only functions in StringBase that try to create or extend the text allocation |
| Strip | |
| StripSubTreeRecordHandler | This is the class is used to strip a subtree of records from the file |
| StrokeAttrRecordHandler | |
| StrokeColourAttribute | Represent a colour for a stroke, as opposed to a fill. Implementation is very similar (identical!) to the FillColourAttribute class |
| StrokeComponent | A document component for handling Stroke definitions |
| StrokeComponentClass | The class that gets a Stroke doc component going on start up We need to register our class as a document component and this is where we do it all |
| StrokeDefinition | Stores a vector stroke definition A static list of these items is held in the StrokeComponent |
| StrokeMsg | A message broadcast by a Stroke when it becomes selected as the default Stroke |
| StrokeTranspAttribute | Represent the transparency of a stroke, as opposed to a fill. Implementation is very similar (identical!) to the FillTranspAttribute class |
| StrokeTypeAttrValue | StrokeType attribute value StrokeType attributes describe the stroking characteristics for a path |
| StrokeTypeItem | Represents a stroke type user-interface item within the line gallery |
| Style | |
| StyleContainer | Provides a container for a load of Style's |
| StyleContainerItem | Provides an item for the container of a load of Style's |
| StyleIterator | Returns entries in a visible list |
| StyleRecordReference | Represents an association twixt Style and Record reference |
| StyleReferenceAttribute | This represents a TemplateOp/Argument/user-changable from the template file attribute. It will probably be superceded, but for now it's derived from AttrUser with a value of the form <InternalName>[/][;<Question>] Bring on the plug-in attributes I say |
| Styles | This DocComponent is an abstract class for styles. I put it in 'cos someone's bound to come along and want the functionality of the derived class WizOpStyleComponent |
| StylesExporter | |
| StylesMessage | Informs us that a Styles component has changed |
| SubRenderContext | Provide a base class for pointing to when storing sub-rendering contexts. These are needed when a node takes a long time to render, such as a NodeBlender object which interrupts itself before all the blended objects have finished rendering. This class is essentially empty - derive your own specific context class from it |
| SubTreeRenderContext | Represents the rendering state where tree rendering has been suspended but the current node is the root of a subtree that has ALREADY BEEN RENDERED |
| SuffixQualifier | A suffix qualifier is one of the form <...><QualifierToken>, e.g. 5.00% |
| SumAllPathsElem | Element for the list in SumAllPathsPathProcessor |
| SumAllPathsPathProcessor | All paths are placed in the linked list, with their associated attribute maps |
| SUNOILFilter | Provide the OIL parts of the SUN filter which loads in the file as a BMP |
| SuperGallery | |
| SystemBarOp | |
| TabStopDragOp | Operation to handle tab stop dragging |
| TabStopDragOpParam | Parameters for TabStopDragOp operation class |
| tagAssociations | A structure for use by the RadioGroup class Scope: public |
| tagCaptureFlags | |
| tagCaptureInfo | |
| TagDescriptionList | Keeps a list of all the tag descriptions present in the imported file |
| TagDescriptionListItem | An item that appears in the TagDescriptionList |
| tagDOWNLOADINFO | |
| tagGIFAPPLICATIONBLOCK | |
| tagGIFCOMMENTBLOCK | |
| tagGIFIMAGEBLOCK | |
| tagGIFINFOHEADER | |
| tagGIFRGBTRIPLE | |
| tagGIFTRANSBLOCK | |
| TARGAOILFilter | Provide the OIL parts of the TARGA filter which loads in the file as a BMP |
| TemplateAttribute | This represents a TemplateOp/Argument/user-changable from the template file attribute. It will probably be superceded, but for now it's derived from AttrUser with a value of the form <InternalName>[/][;<Question>] Bring on the plug-in attributes I say |
| TemplateAttrRecordHandler | Handles the reading of WizOp records in the v2 file format |
| TemplateDialog | Allows intelligent users to make attributes changeable via templates |
| TEMPLATESGallery | The TEMPLATE SuperGallery class |
| TempToolItem | Item that represent a temp tool selection |
| TestBitmapEffect | Test class |
| TextAttrRecordHandler | Record handler for text attribute records |
| TextChar | Simplest type of TextStory character. The only data stored is a Unicode value |
| TextControl | Represents an Edit Box in a DialogOp |
| TextInfoBarData | To encapsulate all the data required to interface with the text infobar |
| TextInfoBarEnumFont | Class for creating TextInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| TextInfoBarOp | A class used for caching Font data.Class for handling the tool's information bar |
| TextInfoBarOpCreate | Class for creating TextInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| TextLine | A TextLine gathers together all characters on a single line in a text story. The TextLine object is responsible for rendering all its character node children. It needs to do this because TextChars have no associated bounds and so they can only render themselves relative to other chars |
| TextLineInfo | Passing line level info to/from functions |
| TextManager | You name it and its assocaited with text then this probably isn't it |
| TextObjRecordHandler | Record handler for text objects See also: class TextAttrRecordHandler |
| TextRulerBarData | Keep the current ruler bar display state |
| TextStory | The root of the TextObject hierarchy |
| TextStoryInfo | Hold story level information |
| TextTool | A template tool class |
| TextToolBlobPosItem | The class of objects stored in the TextToolBlobPosList. These items store the blobs position and associated story |
| TextToolBlobPosList | A list the positions of blobs that the text tool is rendering as tool blobs. This class is just a wrapper arouind the list class, providing common handling functions |
| TGMItem | Associate the TransparencyGeometry enum with the resource id of the text that gets displayed on the menu |
| ThreeColFillAttribute | Specifies a Square graduated fill for an object, including the start and end points |
| ThreeColTranspFillAttribute | Specifies a Three colour graduated transparency for an object including the start and end points |
| ThumbDownloadParam | |
| ThumbMessage | This message is sent to inform the system of important global thumbnail events. Currently the only such event is CACHESIZECHANGED, sent whenever the thumbnail cache wants its size changing |
| ThumbnailFilterPNG | The filter will save out the PNG Thumbnail Bitmap. Overrides DoExport so dialogs are not put up but returns preview export options |
| TI_GIFFilter | Encapsulates a Windows GIF export and import filter. Derives off the masked filter which provides funcitonality for doing masked bitmap export and import |
| TIFFOILFilter | Provide the OIL parts of the TIFF filter which loads in the file as a BMP |
| TimerMsg | This message is sent whenever something happens with a timer |
| TimeSpan | |
| TimeStampBrushPoint | To store information about brush objects generated by the timestamping method |
| TipsDlg | Provides a Tip of the Day dialog showing useful and inspirational tips for users young and old |
| ToggleAutoKerningAction | Toggle a story's auto kerning value |
| ToggleInsetPathAction | Toggles the inset path flag on the given node |
| Tool | The Tool type reflects the latest Tool specification. Do NOT subclass from Tool, but use the latest Tool revision (e.g. Tool_v42). The Tool type should only be used by the Kernel and OIL layers, never by tools themselves |
| Tool_v1 | Specifies the interface between tools and the Kernel/OIL |
| ToolbarDlg | |
| ToolInfo | Provide information on a tool. The fields are as follows: MonoOn InfoVersion Indicates how much of this stucture is understood by the tool. InterfaceVersion The version of the kernel<->tool interface understood by the tool. Version The tool's own version number. ID The unique ID of this tool (allocated by Computer Concepts Ltd). ParentModuleID The unique ID of the module that provides this tool (allocated by Computer Concepts Ltd). Family A string describing the tool family this tool belongs to - e.g. "Path tools". Name A string describing the tool - e.g. "Rectangle tool". Purpose A string decribing what the tool is used for, e.g. "For drawing rectangles". Author A string naming the author(s) of the tool, e.g. "Computer Concepts Ltd". InfoBarDialog Resource ID of the dialog used in the infobar for this tool. MonoOff |
| ToolInfo_v1 | Provide information on a tool |
| ToolList | Used by the kernel to hold information on all the tools it currently knows about. It has an overloaded Add function which will only add tools if their ID has not already been used by another tool |
| ToolListItem | Used by the kernel to hold information on a particular tool. Contains a link to the OilTool object associated with the Tool |
| ToolnameDlg | |
| ToolOpDescriptor | Describes a Tool Selection operation. It contains pointers to the literal token describing the operation (used by the macro language, among other things) and pointers to some static member functions of the operation which allow dynamic creation of the operation |
| ToolsCurrentAttrGroupChangedMsg | This message is broadcast by the Tools whenever the Current Attribute Group associated with a tool changes. This presently means that we have switched to or from the Text Tool |
| ToolSwitch | Holds a key press that will temporarily switch to another tool |
| TraceBoundaryPoint | Implements the TraceRegion class |
| TraceControl | Dialog for tracer |
| TraceDlg | Dialog for tracer |
| TraceMsg | This is a foolish message to bring up a tracer dialog |
| TraceOp | Handles insertion of bitmap effect nodes into the tree |
| TraceOpParam | |
| TraceRegion | |
| Trans2DMatrix | This transformation will perform any 2D matrix transformations such as :- Translate, Rotate, Scale and Shear |
| TransformBase | The Transformation Base Class. This is an abstract class - you can only create instances of its derived classes. The Transformation classes are used to give a transparent interface to arbitary transformations on objects. Nodes do not need to be aware of what type of transformation is being applied or how is should be undone. This class contains two virtual function :- MonoOn virtual void Transform(DocCoord* Coords, INT32 NumCoords) MonoOff MonoOn virtual BOOL IsInvertable() MonoOff It also contains the following public member vars MonoOn BOOL TransLines; // TRUE if Line Widths are to be transformed MonoOff MonoOn BOOL TransFills; // TRUE if Fills are to be transformed MonoOff |
| TransformBoundingData | This structure holds information about the position of the selection as well as the current scale and angles MonoOn Position and size INT32 x; INT32 y; INT32 Width; INT32 Height; |
| TransformData | Holds the flags and additional data for the transform operations that are started by the Selector Tool. MonoOn DocCoord CentreOfTrans; // The centre of the transform INT32 StartBlob; // The blob that the transform was started from BOOL LockAspect; // Should the aspect ratio be locked BOOL LeaveCopy; // Should we leave a copy of the selection BOOL ScaleLines; // Should line widths be scaled as well BOOL TransFills; // Should fills be transformed as well Range* pRange; // range to transform; if NULL, use the selection MonoOff |
| TransformNodeAction | When executed this action will transform a range of NodeRenderableInk nodes. It also creates another TransformNodeAction to 'undo' the transformation just performed. It adds this action to the opposite action list |
| TransInvertable | One of the transformation base classes. All Transformations derived from this class can be inverted directly. ie Transforms that make use of a matrix can be inverted by inverting the matrix. This class adds the following virtual functions :- MonoOn virtual void Invert() MonoOff |
| TransNonInvertable | One of the Transformation base classes. All the transformations derived from this class can not be inverted. Transforms of this kind are considered to be one way mappings from the original coords. There is no way of getting the original coords back after they have been transformed by a class derived from this one. Examples include the Envelope transformation |
| TransOperation | The base class for all the Transform Operations. This class should provide most of the functionality for all the transform operations such as handling the eored drag events etc. At the end of the day it will transform the selection is some way (depending on the derived class) |
| TransparencyRamp | This class holds a list of transparency records, each of which describe a specific entry in the transparency ramp |
| TransparentGradTable | |
| TranspFillAttribute | The base class for a fill geometry attribute, such as flat, linear, radial, conical, etc. This provides the basic interface for fill rendering |
| TranspFillMappingAttribute | Specifies how a fill graduation behaves, e.g. linear, sinusoidal and so on |
| TranspFillMappingLinearAttribute | Specifies a linear fill mapping for a filled object. This is used for normal graduated fills |
| TranspFillMappingSinAttribute | Specifies a sinusoidal fill mapping for a filled object. i.e. the graduation sort of wibbles from one colour to another in a sort of whirly sinusoidal fashion |
| TranspFillProfileOpParam | Serves as our param passing stuff for undo/redo of transp fill profile changing |
| TranspGradTable | A kernel representation of a transparent graduation table |
| TranspInfoBarOp | Class for handling the gradfill tool's information bar |
| TranspInfoBarOpCreate | Class for creating TranspInfoBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| TranspModeMsg | A "transparency mode-change" message class |
| TranspRampItem | Defines a single entry in a transparency ramp. An entry is simply made up of a single long definition |
| TranspTool | The transparency tool |
| TrapEdge | Structure defining a trapezoid edge definition. A TrapEdge records the following information: |
| TrapEdgeList | Simple class to store a list of trapezoid edges (TrapEdge structures) Each source sub-path will be converted to a separate TrapEdgeList |
| TrapsList | Simple class containing a list of TrapEdgeLists representing a complex path Each TrapEdgeList represents a sub-path of the overall source path |
| tree_desc_s | |
| TriggerSet | Class to manage the UI and execution of stretch/extend properties |
| TTFont | A class description of a true type font |
| TTFontMan | A static class to allow acces to TrueType fonts |
| TunedMemory | This is a shell around the CCMalloc and CCFree memory allocator. If you use this class to get the memory, the total alloc'ed memory will not exceed the amount set in this class. This is used to allow the user to say how much memory they are prepared to commit to the off-screen bitmap used in rendering. If there is not enough, GRenderRegions will band thier output to use up less ram |
| TuneTab | Allows the user to set various tuning parameters, such as:-
- Gdraw memory for rendering
- Undo buffer size for the current document
|
| TxtAspectRatioAttribute | This text attribute specifies the aspect ratio of characters |
| TxtBaseClassAttribute | The base class from which all text attributes are derived |
| TxtBaseLineAttribute | This text attribute specifies the aspect ratio of characters |
| TxtBoldAttribute | This text attribute specifies the BOLD state (on/off) |
| TxtFirstIndentAttribute | This text attribute specifies the first line indent |
| TxtFontSizeAttribute | Specifies the size of a font |
| TxtFontTypefaceAttribute | Specifies a FontTypeface. Note that only a handle to the Typeface is stored in the attribute, not the full string description |
| TxtItalicAttribute | This text attribute specifies the ITALIC state (on/off) |
| TxtJustificationAttribute | This text attribute specifies the current text justification |
| TxtLeftMarginAttribute | This text attribute specifies the left margin |
| TxtLineSpaceAttribute | This text attribute specifies the aspect ratio of characters |
| TxtRightMarginAttribute | This text attribute specifies the right margin |
| TxtRulerAttribute | This text attribute specifies the ruler (i.e., tab stops) Conceptually, a ruler is just a pointer to a sorted list of tab stops |
| TxtScriptAttribute | This text attribute specifies the superscript/subscript value of a char |
| TxtTabStop | This type represents a tab stop (part of a ruler attribute) |
| TxtTrackingAttribute | This text attribute specifies a spacing between characters, it can be positive or negative |
| TxtUnderlineAttribute | This text attribute specifies if text is underlined or not |
| TypesetInfo | A class to encapsulate all the bits of typesetting we provide. The main entry in the class is a list of colour plate objects. When printing separations, the list is used to (a) determin which separations require printing and (b) to set each printable colour plate in the active print view. The main print loop will use the access functions in this class to cycle through each printable plate. This will result in a set of separated representations of a page being produced. Other information held in this class pertain to Postscript functionality. The class contains the prefered screening values for the entire document |
| UnApplyAction | When executed this action will hide a node. It will also generate a ShowNodeAction action adding it to the opposite Action list |
| UndoableNodeScan | Base class for NodeScans which are used by UndoableOperations |
| UndoableOpDescriptor | All undoable operations should be registered using an UndoableOpDescriptor. The only difference between an UndoableOpDescriptor and an OpDescriptor is that the Operation Flags are set to different default values |
| UndoableOperation | All Undoable operations should be derived from this class |
| UndoAction2 | Dummy BlobbyOp UNDO action. Does nothing when it executes |
| UndoAction3 | Dummy BlobbyOp UNDO action. Does nothing when it executes |
| UndoColAction | Simple BlobbyOp action which restores the colour of a documents page to the colour it was prior to the operation being performed |
| UndoTab | Allows the user to set any options which are normally associated with a documents undo. This includes such things as:- Unlimited undo setting OR maximum memory to be allocated to the undo system |
| UnicodeManager | Class for containing all Unicode related methods |
| Unit | Encapsulates units within Camelot. All units (i.e. default and user-defined ones) are an instance of this class. Each document has its own list of units controlled by an instance of DocUnitList within the Document class. Therefore you should get hold of the DocUnitList within the current doc when you want to add/delete/edit/find a unit |
| UnitFlagsType | |
| UnitGroup | A UnitGroup is a set of ScaleUnits that are interconvertible Notes: It is possible to violate the integrity of the UnitGroup by changing ScaleUnits included in the group. Kindly use the UpdateUnit method provided |
| UnitListComponent | Provide a component that allows us to save out the units for this document using the serialisation facilities of the DocComponent base class |
| UnitListComponentClass | Provide a class that will add Unit List components to new documents |
| UnitMsg | This message is sent whenever something happens to a unit |
| UnitPropertiesDlg | |
| UnitsRecordHandler | Provide a units record handler for the new native and web file formats. This asks the units document component to import the unit definitions for us |
| UnitsTab | Allows the user to define the default units that are used for displaying size information, font size information and general display information. Also, alllows them to define their own units and edit the scaling factor applied to the spread, layer, or whatever. Based on the old UnitsDlg code |
| UnitsTabAppPrefsDlg | To open up the document preference's dialog box with the units tab selected. This is used by the units button on the tool bars |
| UpdateBrushAction | An action which signals to a brush attribute that its ink node hsa changed. It is appropriate to call this action when serious adjustments have been made to the timestamping points list of the attrbrushtype, for instance adding or removing subsets of the list. It is not appropriate to call it when the coordinates of the path have changed but you do not wish to add or remove any points from the list |
| UpdateCachedKeyholePathAction | Cause a NodeClipViewController node to update it cached keyhole path when an operation is undone or redone. Notes: Invoking this action via its Init() method has no _direct_ effect, save to set the action to trigger on undo/redo |
| URLImportDlg | |
| UsedPropertiesList | Provides a visible list of user attributes |
| UserAttribute | Represent a line width of a path. This may be a simple stroking operator such as a constant line width, or a complex one such as variable line widths or an airbrush stroke operator. (I'd say it stores a "key" string and an associated "value" string for implementation of URLs and other such stuff, but if you say it stores a line width, who am I to argue? ;-) |
| UserAttributeAgglomerator | An AttributeAgglomerator finds the Common Attributes among the nodes provided by an RenderableNodeEnumerator. This allows us to derive classes to retrieve more specialized attributes, namely AttrUser's |
| UserCoord | Encapsulate coord system relative to a user specified origin on a spread by spread basis |
| UserInterface | Allows a user to edit a list of items |
| UserRect | This class is used to represent a rectangular region. It uses a union to enable the client to access the rectangle as two UserCoords (lo and hi) or as four INT32s (lox, loy, hix, hiy). An anonymous union is used, which is a defined C++ feature and so portable |
| ValueFunction | Abstract Base class Provides an interface by which the caller can obtain the value of a given function at a given "position" |
| ValueFunctionBevelEnds | |
| ValueFunctionBlip | Provides an interface by which the caller can obtain the value of a given function at a given "position" |
| ValueFunctionConstant | Provides an interface by which the caller can obtain the value of a given function at a given "position" |
| ValueFunctionDecay | |
| ValueFunctionDoubleRampS | |
| ValueFunctionEllipse | Provides an interface by which the caller can obtain the value of a given function at a given "position" |
| ValueFunctionIntestine | |
| ValueFunctionPressure | |
| ValueFunctionPressureS | |
| ValueFunctionPropeller | |
| ValueFunctionRamp | Provides an interface by which the caller can obtain the value of a given function at a given "position" |
| ValueFunctionRampL | |
| ValueFunctionRampL2 | |
| ValueFunctionRampLinear | |
| ValueFunctionRampS | |
| ValueFunctionRampS2 | |
| ValueFunctionRandom | |
| ValueFunctionSawTooth | |
| ValueFunctionSmoothStroke | Provides an interface by which the caller can obtain the value of a given function at a given "position" |
| ValueFunctionSS_Barb | |
| ValueFunctionSS_Cigar | |
| ValueFunctionSS_Cigar2 | |
| ValueFunctionSS_Cigar3 | |
| ValueFunctionSS_Comet | |
| ValueFunctionSS_Concave | |
| ValueFunctionSS_Convex | |
| ValueFunctionSS_Fallout | |
| ValueFunctionSS_Goldfish | |
| ValueFunctionSS_Iron | |
| ValueFunctionSS_Meteor | |
| ValueFunctionSS_Missile | |
| ValueFunctionSS_OceanLiner | |
| ValueFunctionSS_Petal | |
| ValueFunctionSS_Reed | |
| ValueFunctionSS_SlimBlip | |
| ValueFunctionSS_Torpedo | |
| ValueFunctionSS_Yacht | |
| ValueFunctionTeardrop | Provides an interface by which the caller can obtain the value of a given function at a given "position" |
| ValueFunctionTeardropCurvedEnd | Provides an interface by which the caller can obtain the value of a given function at a given "position" |
| ValueFunctionThumbtack | Provides an interface by which the caller can obtain the value of a given function at a given "position" |
| VariableWidthAttrValue | VariableWidth attribute value VariableWidth attributes describe the width characteristics for a path |
| VarWidthItem | Represents a stroke type user-interface item within the line gallery |
| Vector3< T > | Provides a 3D templated vector class Presently used as support for Path::IsIsometric() |
| stl::Vector3< T > | Provides a 3D templated vector class Presently used as support for Path::IsIsometric() |
| Vector3D | Define all 3 vector operations we need |
| VectorFileRenderRegion | Encapsulates the functions shared by the CMX, EPS, and Flash render regions. This class is never itself instantiated |
| VectorFilter | Allows filter families to contain all vector formats. All filters that load vector-based files (EPS, metafiles, and so on), should be derived from this class. Vector files often contain bitmaps - if in doubt, derive from the VectorFilter |
| VectorFilterFamily | A filter for all vector file types. e.g. EPS, WMF, Draw, etc |
| VectorStrokeSubRenderContext | Used during rendering to store the render context of a repeating vector stroke if it has taken too long to render so far |
| VersionIndependentProgID | Represents the VersionIndependentProgID key in a registry. Saves us some typing really |
| VerticalInsetStore | |
| VerticalRuler | Encapsulates vertical ruler |
| VFPressureRecord | Stores Pressure-sensitive pen values (as used for variable-width strokes) and allows the caller to retrieve values from such recorded information |
| View | The basic kernel view item. This class contains minimal functionality to maintain the 'current' view, and the connection from a kernel view object to an OIL view object. DocView and PrintView are derived from this class |
| ViewComponent | Provide a component that handles the saving of view information to the v2 file format |
| ViewComponentClass | Provide a class that will add view components to new documents |
| ViewContextMenu | Implements the DocView context sensitive menu |
| ViewDragTarget | An instantiation of this class is created by each entity which wishes to provide a 'destination' to which the mouse can go to complete a drag. WinoilDragTargets are used as a base class from which to derive drag targets for WINOIL entities (an optional HWND) |
| ViewItem | When optimising redraw for a particular View, we try to join all the render regions of a View into one if they cover more than 70% of the resulting union. This class is used to remember which DocViews we have already tried to optimise as we step through the render region list |
| ViewList | When optimising redraw for a particular View, we try to join all the render regions of a DocView into one if they cover more than 70% of the resulting union. This class is used to remember which Views we have already tried to optimise as we step through the render region list |
| ViewModule | |
| ViewOps | This class is used for all the View operations found on the View Menu |
| ViewRecordHandler | Handles the reading of all view records in the v2 file format |
| ViewState | |
| ViewTab | Allows the user to set any options which are normally associated with the applications View. This includes such things as:- Colour bar display mode Showing percentage hourglasses and/or progress bars |
| VisibleAttribute | Provides a user editable attribute (of sorts) |
| VisibleLabel | Allows a user to edit a list of items |
| VisibleLabel::Observer | |
| VisibleList | Allows a user to edit a list of items |
| VisibleListItem | Allows a user to edit a list of items |
| VisibleListItemPtr | Provides a container element for a visible list |
| VisibleListIterator | Returns entries in a visible list |
| VisibleListWithEditableEntries | This rendition of a VisibleList has VisibleListItems that are editable The functionality should be in the base class but that TemplateDialog parameter ruins things a bit |
| VisibleStyleReference | Provides a user editable style reference |
| VisibleTemplateAttribute | Provides a user editable template attribute |
| VisibleTemplateHandler | Provides the user with something tangible in the way of WizOp's. They can appear in a list control via this class |
| VisibleTextNode | The VisibleTextNode is an abstract base class. All visible objects which appear on text lines such as characters, kerns, carets, etc. will be instances of derived classes of VisibleTextNode |
| VisibleUserAttribute | Provides a user editable user attribute |
| VisibleWizOpStyle | Provides the user with a style to play with. They can appear in a list control via this class |
| WebAddress | Represents a URL |
| WebAddressAttribute | The new Web Address attribute. It's distinct from the old Web Address attribute, which was a type of UserAttribute |
| WebAddressDlg | The new Web Address dialog |
| WebCorrectFlags | A set of flags that define how a URL should be corrected |
| WebFontInstallParam | |
| WebOILFilter | The Web File format Oil Filter (Extension etc) |
| WebPrefsDlg | |
| WebPrefsDlgParam | Allows data to be passed into the export web preference dialog box and then returned to the caller |
| WinCoord | Structure holding a 16-bit/32-bit (Win16/Win32) cartesian coordinate. Its main use is to hold the coordinates supplied to and from the operating system. The origin for this coordinate system is the top-left of the screen or window |
| WindingRuleAttribute | Attribute for the winding rule of a path |
| WindowOps | This class is used for all the Window operations found on the Window Menu |
| WinRect | A Windows rectangle |
| WinTabPressurePen | Overrides the base pressure-sensitive pen class to provide support for WinTab pressure-sensitive tablet devices. When such a device is unavailable, this class returns control to the base-class to allow joysticks and mice to be used to simulate pens based on speed and/or direction of travel rather than real applied pressure |
| WizOp | The Camelot Text file format supports templating. Each argument to a template is processed by a WizOp. The WizOp's extracted from the registry, which this class represents, are then Available Properties in the Wizard Properties dialog |
| WizOpProbe | Searches through the (local) registry returning entries in the WizOp category |
| WizOpRegistryEntry | When the WizOpProbe returns a ClassRegistryEntry it returns one of these which can then be used to extract WizOp specific bits from the registry |
| WizOps | This collection of WizOps is used by the Wizard Properties dialog |
| WizOpStyle | A WizOpStyle is a style solely for the purpose of naming WizOps |
| WizOpStyleComponentClass | Provide a class that will add document information components to new documents |
| WizOpStyleRecordHandler | Allows WizOpStyleComponent's to be read from the .xar/.web file formats |
| WizOpStyleRefRecordHandler | Handles the reading of WizOpStyleRef records in the v2 file format |
| WizOpStyles | Provide a component that allows us to save out the information for this document using the serialisation facilities of the DocComponent base class |
| WobbleFlags | Used to determin what to wobble when recalculating curve control points during a drag. The flags affect which handles around a curve endpoint are repositioned |
| WorkCoord | |
| WorkRect | This class is used to represent a rectangular region. It uses a union to enable the client to access the rectangle as two WorkCoords (lo and hi) or as four XLONGs (lox, loy, hix, hiy). An anonymous union is used, which is a defined C++ feature and so portable |
| WPGOILFilter | Provide the OIL parts of the WPG filter which loads in the file as a BMP |
| wxAdvSplashScreen | |
| wxAdvSplashScreenWindow | |
| wxAuiDefaultDockArt | |
| wxAuiDockArt | |
| wxAuiDockInfo | |
| wxAuiDockUIPart | |
| wxAuiFloatingFrame | |
| wxAuiManager | |
| wxAuiManagerEvent | |
| wxAuiPaneButton | |
| wxAuiPaneInfo | |
| wxCamArtControl | A base class for controls using the CamArtProvider to paint themselves Notes: In the OIL See Also: |
| wxCamArtControlEvent | A derived event to allow for postprocessing of autorepeat on buttons Notes: In the OIL See Also: |
| wxCamArtControlXmlHandler | A resource handler to enable wxCamArtControl items to be loaded from XML Notes: In the OIL See Also: |
| wxCamArtProviderEvent | A derived event to allow for postprocessing of dialog events Notes: In the OIL See Also: |
| wxCamBitmapDropdownPopup | |
| wxCamDialogEvent | A derived event to allow for postprocessing of dialog events Notes: In the OIL See Also: |
| wxCamDrawControl | A base class for controls using the CamDrawProvider to paint themselves Notes: In the OIL See Also: |
| wxCamDrawControlEvent | A derived event to allow for postprocessing of autorepeat on buttons Notes: In the OIL See Also: |
| wxCamDrawControlXmlHandler | A resource handler to enable wxCamDrawControl items to be loaded from XML Notes: In the OIL See Also: |
| wxCamGridPopup | |
| wxCamMenuBar | |
| wxCamTreeCtrl | |
| wxCamVListBoxComboPopup | |
| wxComboBoxExtraInputHandler | |
| wxComboCtrl | |
| wxComboCtrlBase | |
| wxComboCtrlFeatures | |
| wxComboPopup | |
| wxComboPopupExtraEventHandler | |
| wxComboPopupWindow | |
| wxDynamicPropertySheetDialog | The create method creates a Dialog box and positions it |
| wxGenericComboControl | |
| wxGridCombo | |
| wxGridComboPopup | |
| wxGridComboXmlHandler | |
| wxKeyMap | Maps the string representation of a wx key (i.e. "WXK_F1"), into it's enum value |
| wxOwnerDrawnComboBox | |
| wxOwnerDrawnComboBoxXmlHandler | |
| wxPlatformDependent | |
| wxPseudoTransparentFrame | |
| wxSliderCombo | |
| wxSliderComboPopup | |
| wxSliderComboXmlHandler | |
| wxTextValidatorFixed | |
| wxTreebook | |
| wxTreebookEvent | |
| wxTreebookXmlHandler | |
| wxVListBoxComboPopup | |
| wxWindowDeletionWatcher | |
| xlong | |
| XMatrix | |
| XOROutlineInfoStr | Contains information used by the XOR Outline rendering functions in the Range. THis includes a pointer to the "Prime Object" (which is the object that the user clicked on to start their drag), a rectangle which is used when comparing object sizes to determine how significant they are in the current drag (more significant objects are drawn first) and a couple of flags indicating if the significance region is based on the entire screen size or not, and whether the information is currently cached correctly |
| XPFCapability | This is the baseclass for the various nodes in the capability tree |
| XPFCBevel | This is the class for Bevel capabilities |
| XPFCBitmap | This is the class for Bitmap capabilities |
| XPFCBitmapEffect | This is the class for BitmapEffect capabilities |
| XPFCBlend | This is the class for Blend capabilities |
| XPFCClipView | This is the class for ClipView capabilities |
| XPFCColour | This is the class for Colour capabilities |
| XPFCComplexClass | This is a general class that just uses the runtime class of the node It can be used directly to handle those complex objects that just support a simple on/off style of conversion or it can be used as the baseclass for more complex classes |
| XPFCContour | This is the class for Contour capabilities |
| XPFCEllipse | This is the class for Ellipse capabilities |
| XPFCFeather | This is the class for Feather capabilities |
| XPFCFill | This is the class for Fill capabilities |
| XPFCFillTrans | This is the class for FillTrans capabilities |
| XPFCLayer | This is the class for layer capabilities |
| XPFCLine | This is the class for Line capabilities |
| XPFCLineTrans | This is the class for LineTrans capabilities |
| XPFCMould | This is the class for Mould capabilities |
| XPFCPolygon | This is the class for Polygon capabilities |
| XPFCRectangle | This is the class for Rectangle capabilities |
| XPFCShadow | This is the class for Shadow capabilities |
| XPFCText | This is the class for Text capabilities |
| XPFRenderCallback | This is the custom render callback class for the capabilities conversion |
| XPFRenderRegion | This is the custom render region for the capabilities conversion |
| XPFSpanRenderCallback | |
| XPFView | Simple view class for use when converting for plugin filters |
| XSEPSExportOptions | This gets options relevant to the export of XS EPS |
| XWindowsOILFilter | Provide the OIL parts of the XWindows filter which loads in the file as a BMP |
| z_stream | A file stream compressor and decompressor. Allows the CCDiskFile to offer compression of files. At present just used to compress the native file format |
| z_stream_s | |
| ZipDeflate | The deflater for the file compressor and decompressor. Allows the CCDiskFile to offer compression of files. At present just used to compress the native file format |
| ZipInflate | The inflater for the file compressor and decompressor. Allows the CCDiskFile to offer compression of files. At present just used to compress the native file format |
| ZoomInfoBarOp | Handles creation/destruction and message handling for the zoom tool info-bar |
| ZoomInfoBarOpCreate | Class for creating (dummy) InformationBarOps. Derived classes of BarCreate are used by DialogBarOp::ReadBarsFromFile() |
| ZoomTool | This class is to allow the user to Zoom in and out of the document at will. It provides an interface to the tool system for the zoom mouse-drag Operation |
