| VCF::ABGRPixel< BitSizeType, FloatingPoint, PixTraitsType, PixAllocaterType > | Defines a channel layout order of a,b,g,r with BitSizeType bits per channel |
| VCF::ABGRPixel< float, true > | |
| VCF::AbstractApplication | An AbstractApplication is a base class for deriving new application types Currently there are two main types, standard Application classes, which represent the current process the application is associated with and of which there should only be one, and LibraryApplication classes which are tied to shared librarys or DLL's |
| VCF::AbstractClassInfo< CLASS_TYPE > | The AbstractClassInfo is used to simplify registering classes with the FoundationKit's runtime ClassRegistry |
| VCF::AbstractCommand | A partial implementation of the Command interface |
| VCF::AbstractComponentEditor | Basic implementation of the ComponentEditor interface |
| VCF::AbstractContainer | AbstractContainer implements the basics of a container with the exception of actual layout rules, therefore resizeChildren is not implemented |
| VCF::AbstractControlEditor | Class AbstractComponentEditor documentation |
| VCF::AbstractDelegateProperty | |
| VCF::AbstractImage | AbstractImage represents a base implementation of the Image interface |
| VCF::AbstractPropertyEditor | |
| VCF::AbstractScrollable | Class AbstractScrollable documentation |
| VCF::AbstractScrollable::ControlResizeHandler | |
| VCF::AbstractView | Basic implementation of a view |
| VCF::AbstractWin32Component | This is the core Win32 control class peer, does most of the handling of WM_XXX messages |
| VCF::AbstractX11Control | This class serves as a common implementation for various methods of the ControlPeer interface |
| VCF::AcceleratorKey | An AcceleratorKey represents a link between a specific keyboard keystroke combination and an event handler to be invoked when the combination takes place |
| VCF::AcceleratorKey::Value | This class is used to hold the values of both the keyboard modifier(s), such as Ctrl, Shift, or Alt, and the virtual key value, such as vkLetterV |
| VCF::Action | The Action class is used to represent an "action" that gets performed because of some event from the UI, such as clicking a menu item or button |
| VCF::ActionEvent | The ActionEvent is used to store and read the state about a particular action |
| VCF::ActiveXControlHost | This is a control that can host other ActiveX controls |
| VCF::Application | Represents the main process for a application |
| VCF::ApplicationException | Application level exceptions |
| ApplicationKit | |
| VCF::ApplicationKit | |
| VCF::ApplicationPeer | System neutral interface describing an application |
| VCF::ApplicationResourceBundle | |
| VCF::ARGBPixel< BitSizeType, FloatingPoint, PixTraitsType, PixAllocaterType > | Defines a channel layout order of a,r,g,b with BitSizeType bits per channel |
| VCF::ARGBPixel< float, true > | |
| VCF::Array< ItemType > | A simple wrapper for using a vector collection |
| VCF::Regex::Ascii | Regex engine for Ascii text |
| VCF::AssociativeEnumerator< KeyType, ValueType, CollectionType > | The AssociativeEnumerator is a utility class that makes it easy to use a specific stl collection class (like a map) and have support for the Enumerator interface |
| VCF::AsyncResult | This class is used to manage invoking a delegate's callbacks asynchronously |
| VCF::AsyncResult::AsyncTask | |
| VCF::AsyncResult::Task | |
| VCF::AsyncReturns | Interface class used for async delegate execution |
| VCF::AsyncURL | |
| VCF::AtomicCount | |
| VCF::Attachable< Type, Impl > | |
| VCF::BackgroundState | |
| VCF::BadComponentStateException | This exception should be thrown when a component is used in an incorrect way |
| VCF::BadDateFormat | This exception is thrown when a bad date format is used |
| VCF::BadImageBitsException | This exception should be thrown when pointer access to the image's pixels has become corrupt |
| VCF::BadModelStateException | Throw when a model state has changed and it is determined that the change makes the model corrupt or invalid |
| VCF::BadTimeFormat | This exception is thrown when a bad time format is used |
| VCF::Base64Codec | |
| VCF::Basic3DBorder | Draws a basic 3D border around a component |
| VCF::BasicException | The base exception class in the Framework |
| VCF::BasicFileError | |
| VCF::BasicFill | This class is a basic implementation of the Fill interface |
| VCF::BasicInputStream | |
| VCF::BasicOutputStream | |
| VCF::BasicRectangle | |
| VCF::BasicStroke | |
| VCF::BasicTableItemEditor | BasicTableItemEditor represents a simple implementation of the TableItemEditor interface |
| VCF::BezierCurve | The BezierCurve is a basic implementation of the Path interface and provides methods to create lines, rectangles, polylines, and curves |
| VCF::BGRAPixel< BitSizeType, FloatingPoint, PixTraitsType, PixAllocaterType > | Defines a channel layout order of b,g,r,a with BitSizeType bits per channel |
| VCF::BGRAPixel< float, true > | |
| VCF::BinaryPersistable | |
| VCF::BMPLoader | |
| VCF::BoolPropertyEditor | |
| VCF::Border | A Border component is responsible for drawing the border of a control |
| VCF::Button | The Button interface represents a standard set of behaviours for any control that wishes to act like a button |
| VCF::ButtonEvent | A ButtonEvent is fired whenever a button is pressed or clicked |
| VCF::ButtonPeer | |
| VCF::ButtonState | |
| VCF::ByDay | |
| VCF::ByHour | |
| VCF::ByMillisecond | |
| VCF::ByMinute | |
| VCF::ByMonth | |
| VCF::BySecond | |
| VCF::ByYear | |
| VCF::CallBack | Base class for a function callback |
| VCF::CantCreateObjectException | |
| VCF::CellID | |
| VCF::CellRange | |
| VCF::CFRefObject< CFObjType > | |
| VCF::CFTextString | This is a utility class for wrapping CFStringRef and allowing for easy assignment to/from a VCF::String class |
| VCF::Channel< PixelType, ColorChannelVal > | |
| VCF::ChannelIterator< PixelType, ColorChannelVal > | |
| VCF::ChannelIterator< ColorPixels::Type, ccAlpha > | Alpha color channel iterator specilization |
| VCF::ChannelIterator< ColorPixels::Type, ccBlue > | Blue color channel iterator specilization |
| VCF::ChannelIterator< ColorPixels::Type, ccGreen > | Green color channel iterator specilization |
| VCF::ChannelIterator< ColorPixels::Type, ccRed > | Red color channel iterator specilization |
| VCF::CharMemStream< allocationSize > | |
| VCF::CheckBoxControl | A CheckBoxControl is a control that displays its state with a check mark indicating an on/off or true/false state |
| VCF::Circle | |
| VCF::Class | Class is the base class for all RTTI in the Framework |
| VCF::ClassFunction< ReturnType, ClassType > | |
| VCF::ClassFunction1< ReturnType, P1, ClassType > | |
| VCF::ClassFunction2< ReturnType, P1, P2, ClassType > | |
| VCF::ClassFunction3< ReturnType, P1, P2, P3, ClassType > | |
| VCF::ClassFunction4< ReturnType, P1, P2, P3, P4, ClassType > | |
| VCF::ClassFunction5< ReturnType, P1, P2, P3, P4, P5, ClassType > | |
| VCF::ClassFunction6< ReturnType, P1, P2, P3, P4, P5, P6, ClassType > | |
| VCF::ClassInfo< CLASS_TYPE > | ClassInfo is used to simplify registering classes with the FoundationKit's runtime ClassRegistry |
| VCF::ClassNotFound | Exception should be thrown when attempting to create a class or cast to class type that the run time system is unable to find |
| VCF::ClassProcedure< ClassType > | A class method that takes no arguments |
| VCF::ClassProcedure1< P1, ClassType > | A class member function |
| VCF::ClassProcedure2< P1, P2, ClassType > | |
| VCF::ClassProcedure3< P1, P2, P3, ClassType > | |
| VCF::ClassProcedure4< P1, P2, P3, P4, ClassType > | |
| VCF::ClassProcedure5< P1, P2, P3, P4, P5, ClassType > | |
| VCF::ClassProcedure6< P1, P2, P3, P4, P5, P6, ClassType > | |
| VCF::ClassProcedure7< P1, P2, P3, P4, P5, P6, P7, ClassType > | |
| VCF::ClassProcedure8< P1, P2, P3, P4, P5, P6, P7, P8, ClassType > | |
| VCF::ClassRegistry | ClassRegistry contains all Class's in the Framework Runtime |
| VCF::Clipboard | The Clipboard represents a common place to put shared data between objects and/or between applications |
| VCF::ClipboardEvent | A ClipboardEvent is fired during changes ot the system clipboard |
| VCF::ClipboardPeer | The ClipboardPeer is the interface for connecting to an OS specific clipboard |
| VCF::CLSIDPred | |
| VCF::CmdParam | |
| VCF::Color | The Color class is used to represent a given color with 4 values, with each value representing a separate red, green, blue, and alpha color component (RGBA) |
| color_sum_gray8 | |
| VCF::ColorEtchedBorder | |
| VCF::ColorNames | Struct with all color names not included by VCF: they are essentially grays we need to instantiate it somewhere: unfortunately non-integer constant have no external linkage otherwise ColorName would be replaced by a namespace with the same String constants and put in the VCF library |
| VCF::ColorPropertyEditor | |
| VCF::ColorSpace | A class for managing all the color transformations between different color spaces |
| VCF::ColorSpace::HSLrangetype | |
| VCF::ColorSpace::HSLtype | |
| VCF::ColorSpace::HSVtype | |
| VCF::ColorSpace::HWBtype | |
| VCF::ColorSpace::RGBrangetype | |
| VCF::ColorSpace::RGBtype | |
| VCF::ColumnController | |
| VCF::ColumnItem | A ColumnItem item is used to represent a single header column |
| VCF::ColumnItemEvent | Class ColumnItemEvent documentation |
| VCF::ColumnLayoutContainer | |
| VCF::ColumnModel | The ColumnModel is a model that represent's 0 or more ColumnItems |
| VCF::ComboBoxControl | A combo box control is a control that is used to display a selection from a list of choices in a single field |
| VCFCOM::COMDataObject | This class implements IDataObject directly but also uses a member variable taht can point to a reference to some already existing IDataObject instance |
| COMException | |
| VCF::Command | A Command represents an interface describing a single action, that is potentially undoable |
| VCF::CommandButton | The CommandButton is a native push button that fires an event when pressed, or "clicked" |
| VCF::CommandGroup | Class CommandGroup documentation |
| VCF::CommandLine | A utility for parsing command lines |
| VCF::CommonColorDialog | The CommonColorDialog is used to present a standard dialog for selcting a color |
| VCF::CommonColorDialogPeer | |
| VCF::CommonDialog | Base class for all the standard, or "common" dialog classes |
| VCF::CommonDialogPeer | |
| VCF::CommonFileBrowseDialog | This class displays a common dialog used to select a directory |
| VCF::CommonFileDialog | Base class for open and save common dialogs |
| VCF::CommonFileDialogPeer | |
| VCF::CommonFileOpenDialog | This class is used to display a common or standard file open dialog |
| VCF::CommonFileSaveDialog | This class is used to display a common or standard file save dialog |
| VCF::CommonFolderBrowseDialogPeer | |
| VCF::CommonFontDialog | This class is used to display a common font dialog |
| VCF::CommonFontDialogPeer | |
| VCF::CommonPrintDialog | A class for displaying a common print dialog |
| VCF::CommonPrintDialogPeer | |
| VCF::Component | The base class for all objects within the Visual Component Framework that wish to manipulated dynamically within the an IDE |
| VCF::ComponentEditor | A ComponentEditor is an interface used to edit an entire component at once, as opposed to a PropertyEditor which only edits a single property of a specific component or object |
| VCF::ComponentEditorManager | The ComponentEditorManager is used to regulate the different component editors that are available |
| VCF::ComponentEvent | ComponentEvent are events generated by changes made to the component |
| VCF::ComponentInfo | ComponentInfo represents special data regarding a component's class |
| VCF::ComponentSetting | A component setting is a special "value" that may be added to a component's settings to be stored when the program shuts down, and initialized with the program starts up |
| VCF::Composition | |
| VCFCOM::COMUtils | Linker requirements: rpcrt4.lib - for RPC and UUID stuff shell32.lib - for Shell functions |
| VCF::Condition | The Condition object is used as a synchronization primitive, like the Mutex, and Semaphore |
| VCF::ConditionPeer | Class ConditionPeer documentation |
| VCF::ConicGradientFill | |
| VCF::Container | A Container is a Component that is implemented when a Control wants to be able to contain other child controls within itself |
| VCF::ContextPeer | The ContextPeer serves as a platform neutral interface for a set of standard drawing methods that should provide the following functionality: |
| VCF::Control | The base class for all visual components in the Visual Component Framework |
| VCF::ControlContainer | A ControlContainer is a simple custom control that automatically creates a standard container as soon as it's created |
| VCF::ControlEditor | A ControlEditor is an additional interface used to edit an entire Control instance at once, as opposed to a PropertyEditor which only edits a single property of a specific component or object |
| VCF::ControlEvent | ControlEvent are events generated by changes made to the control |
| VCF::ControlGraphicsContext | Graphics Context associated to a control |
| VCF::ControlPeer | The base Peer interface |
| VCF::ControlPopupMenuMenuEvent | |
| VCF::Cursor | Class Cursor documentation |
| VCF::CursorManager | Class CursorManager documentation |
| VCF::CursorPeer | Class CursorPeer documentation |
| VCF::CursorPropertyEditor | |
| VCF::CustomControl | This is the base class for custom controls that are not based on existing native controls |
| VCF::DataObject | A DataObject represents a data object in the clipboard |
| VCF::DataObjectPeer | |
| VCFCOM::DataRendering | Base implementation of IDataObject |
| VCF::DataTypeNotSupportedException | |
| VCF::DateTime | This class is used to represent a point in time |
| VCF::DateTime::Iterator< DateLogic > | Templatized class for iterating a date, either forward or backard in time, where the template type DateLogic is a class with the following static methods: |
| VCF::DateTimeSpan | The DateTimeSpan represents an absolute delta value between two date time values |
| VCF::DefaultListModel | |
| VCF::DefaultListModelPropertyEditor | |
| VCF::DefaultMenuItem | |
| VCF::DefaultMenuItemPropertyEditor | |
| VCF::DefaultTableCellItem | |
| VCF::DefaultTableModel | |
| VCF::DefaultTabPage | |
| VCF::DefaultTextModel | |
| VCF::DefaultTreeModel | |
| VCF::DefaultTreeModel::TreeValRef | |
| VCF::Delegate | A delegate can be thought of as a function pointer on steroids |
| VCF::Delegate0 | A delegate that takes no arguments |
| VCF::Delegate1< P1 > | A delegate that takes one argument of type P1 |
| VCF::Delegate1R< ReturnType, P1 > | |
| VCF::Delegate2< P1, P2 > | |
| VCF::Delegate2R< ReturnType, P1, P2 > | |
| VCF::Delegate3< P1, P2, P3 > | |
| VCF::Delegate3R< ReturnType, P1, P2, P3 > | |
| VCF::Delegate4< P1, P2, P3, P4 > | |
| VCF::Delegate4R< ReturnType, P1, P2, P3, P4 > | |
| VCF::Delegate5< P1, P2, P3, P4, P5 > | |
| VCF::Delegate5R< ReturnType, P1, P2, P3, P4, P5 > | |
| VCF::Delegate6< P1, P2, P3, P4, P5, P6 > | |
| VCF::Delegate6R< ReturnType, P1, P2, P3, P4, P5, P6 > | |
| VCF::Delegate7< P1, P2, P3, P4, P5, P6, P7 > | |
| VCF::Delegate8< P1, P2, P3, P4, P5, P6, P7, P8 > | |
| VCF::DelegatedContainer< ContainerType > | This class is used to provide easy access to a containers methods so the developer doesn't have to get the container instance of the control |
| VCF::DelegateProperty | |
| VCF::DelegateR< ReturnType > | The base calss for delegates that return a value from a function |
| VCF::DesignTimeContainer | |
| VCF::Dialog | A Dialog is a popup frame that is generally used for user input |
| VCF::DialogEvent | |
| VCF::DialogPeer | |
| VCF::Dictionary | The Dictionary class is a utility class useful storing a collection of key-value pairs |
| VCF::DictionaryEnumerator | The DictionaryEnumerator simply iterates through all of the items in a Dictionary |
| VCF::Directory | A Directory represents a directory in a filesystem |
| VCF::Directory::Finder | A Finder object is used to iterate a set of files contained in a Directory object that represents the directory |
| VCF::DisclosureButtonState | |
| DocInterfacePolicy | |
| VCF::DockManager | DockManager class uses to manage ToolbarDock's and floating toolbars |
| VCF::DocManagerEvent | Class DocManagerEvent |
| VCF::Document | A document is a component that interacts with a valid model instance and has many extra features like saving, loading, cutting no implemented within the scope of a model |
| VCF::DocumentBasedApplication< DocInterfacePolicy > | |
| VCF::DocumentEvent | |
| VCF::DocumentInfo | Contains the string infos characterizing a document class or a kind of document |
| VCF::DocumentManager | The DocumentManager manages the interaction between the application (and any other UI classes) and a collection of one or more documents |
| VCF::DocumentManagerImpl< AppClass, DocInterfacePolicy > | Class DocumentManagerImpl implementation of the DocumentManager for which also the DocInterfacePolicy is specified |
| VCF::DoublePropertyEditor | |
| VCF::DragDropPeer | |
| VCF::DragScrollEvent | |
| VCF::DragSource | The drag source represents the source, or beginning of a drag drop operation |
| VCF::DragSourceEvent | |
| VCF::DrawStates | A set of values for different states |
| VCF::DrawUIState | The DrawUIState is a utility class to make it easy to indicate the user interface state of a GUI element, such as a button |
| VCF::DropDownControl | |
| VCF::DropDownPeer | |
| VCF::DropTarget | The DropTarget class represents a way to control and be notified when a something is "dropped" ( or just "dragged over" ) as a result of a drag-drop operation |
| VCF::DropTargetEvent | Drop event are fired when an object is dropped during a drag drop operation |
| VCF::DropTargetPeer | |
| VCF::Ellipse | |
| VCF::Enum | The Enum class is used to wrap C++ enum types, allowing the user to iterate forward and backward through the enum type |
| VCF::Enumerator< COLLECTION_TYPE > | This is a template class that provides an interface for iterating through a collection, and provides a standard set of methods |
| VCF::EnumeratorContainer< COLLECTION, COLLECTION_TYPE > | EnumeratorContainer is based on some COLLECTION class that represents a collection class of some sort, i.e |
| VCF::EnumeratorMapContainer< COLLECTION, COLLECTION_TYPE > | EnumeratorMapContainer is based on some COLLECTION class that represents an associative collection of some sort, i.e |
| VCFCOM::EnumFormatETC | |
| VCFCOM::EnumObject< T > | Template class to make it easy to create IEnumXXX objects |
| VCF::EnumPropertyEditor | |
| VCF::EnumSetPropertyEditor | |
| VCF::EnumValue | |
| VCF::ErrorLog | An ErrorLog represents a place to output status during the life of a running application |
| VCF::EtchedBorder | |
| VCF::Event | The Event class is root object for events in the Framework |
| VCF::Field | The Field class allows RTTI introspection to support member variables of a class |
| VCF::File | The File class represents a single file or directory |
| VCF::FileAssociationInfo | |
| VCF::FileInputStream | |
| VCF::FileIOError | This exception should be thrown for errors during reading or writing a file |
| VCF::FileNotFound | |
| VCF::FileOutputStream | |
| VCF::FilePath | A FilePath represents a path to a file in the filesystem |
| VCF::FilePeer | The FilePeer interface is used to describe basic file operations that are then implemented for the specific OS platform |
| VCF::FileSearchFilter | FileSearchFilter is an abstract class for any user defined Filter object working with the Directory::Finder |
| VCF::FileSearchFilterStandard | FileSearchFilterStandard is the predefined Filter object used for simple searches |
| VCF::FileStreamBase | Special file stream that uses native OS calls for file IO as opposed to the more generic C++ filestream class |
| VCF::FileStreamPeer | FileStreamPeer is a basic file stream interface to wrap native file IO OS calls |
| VCF::Fill | The Fill class is a high level class used to fill in a Path |
| VCF::Filter | |
| VCF::FilterCBData | |
| VCF::Finalization | |
| VCF::FixedPointNumber | |
| VCF::FocusEvent | Event class for events specific of any change of focus |
| VCF::Font | A Font wraps the windowing system's graphics font object |
| VCF::FontInfo | Use this class to retreive information about a loaded system font |
| VCF::FontPeer | Represents the native windowing system's representation of a Font |
| VCF::FontPropertyEditor | |
| VCF::Format | The Format class is used to format a string, similar to the sprintf/printf family of functions, only made typesafe for C++, and less likely to encounter buffer overflow errors that are so easy to do with sprintf and friends |
| VCF::FoundationKit | The FoundationKit class is used to initialize the Foundation Kit runtime |
| VCF::FoundationKit::Assertion | This is a special case exception used only for the triggering of an asertion, through the call to FoundationKit::assertCondition() |
| VCF::Frame | A frame is a component that houses other components, plus has special adornments used for interacting with it |
| VCF::Frame::State | |
| VCF::FrameEvent | |
| VCF::Function< ReturnType > | |
| VCF::Function1< ReturnType, P1 > | |
| VCF::Function2< ReturnType, P1, P2 > | |
| VCF::Function3< ReturnType, P1, P2, P3 > | |
| VCF::Function4< ReturnType, P1, P2, P3, P4 > | |
| VCF::Function5< ReturnType, P1, P2, P3, P4, P5 > | |
| VCF::Function6< ReturnType, P1, P2, P3, P4, P5, P6 > | |
| VCF::FunctionTypeInfo | Base class for storing function information for a delegate |
| VCF::GenericMemoryBuffer< DATA_TYPE, allocationSize > | GenericMemoryBuffer |
| VCF::GradientFill | This is the base class for gradient fills |
| VCF::GradientFill::ColorSorter | |
| VCF::GradientFill::GradientColor | |
| VCF::GraphicsContext | A GraphicsContext provides the lowest level graphics interface to the native systems 2D drawing operations |
| VCF::GraphicsContext::ImageOperation | |
| VCF::GraphicsContext::PointOperation | |
| VCF::GraphicsKit | |
| GraphicsKit | Initializes the graphics Kit runtime |
| VCF::GraphicsResourceBundle | A GraphicsResourceBundle is used to represent a collection of resources that happen to be images |
| VCF::GraphicsResourceBundlePeer | Class GraphicsResourceBundlePeer documentation |
| VCF::GraphicsToolkit | The GraphicsToolkit serves as a way to retreive basic system information and as a factory for creating various graphics peers, like the ContextPeer, FontPeer, and the system implementation the Image class |
| VCF::GrayScaleImage | |
| VCF::GrayscalePixel< BitSizeType, FloatingPoint, PixTraitsType, PixAllocaterType > | Defines a channel layout order of a,b,g,r with BitSizeType bits per channel |
| VCF::GrayscalePixel< float, true > | |
| HBitmap32Bit | Win32 utility class |
| HBitmapData | |
| HBitmapGrayScale | |
| VCF::HeaderControl | Class HeaderControl documentation |
| VCF::HeaderItemState | |
| VCF::HelpEvent | |
| VCF::HorizontalGradientFill | |
| VCF::HorizontalLayoutContainer | |
| VCF::Regex::Host | Base class for performing regex searches |
| VCF::hresult | |
| VCF::HTMLAuthenticationEvent | This is event is used when an authentication event is fired by the underlying browser peer |
| VCF::HTMLBrowserControl | The HTMLBrowserControl provides a wrapper around the native HTML rendering and UI presentation for the platform |
| VCF::HTMLBrowserPeer | HTMLBrowserPeer describes a generic interface for a browser control |
| VCF::HTMLDocument | |
| VCF::HTMLDocumentPeer | |
| VCF::HTMLElement | This represents an individual node |
| VCF::HTMLElementCollection | This is a collection of 0 or more HTMLElement nodes |
| VCF::HTMLElementCollectionPeer | |
| VCF::HTMLElementEvent | An event thats used for HTMLElement events |
| HTMLElementEventHandlerBase | |
| HTMLElementEventHandlerMethods< ClassType > | |
| VCF::HTMLElementPeer | |
| VCF::HTMLEvent | Generic HTML event sent for all other events generated by the HTML Browser |
| VCF::HTMLEventHandler | |
| VCF::HTMLInputElement | |
| VCF::HTMLInputElementPeer | |
| VCF::HTMLKit | The HTMLKit is used to provide support for rendering HTML in a control (as well as connecting to the HTML resource if it's not on the local machine), and for enumerating the various HTML DOM elements |
| VCF::HTMLNewWindowEvent | |
| VCF::HTMLToolkit | |
| IAuthenticateImpl | |
| IDispatchImpl | |
| IDocHostUIHandlerImpl | |
| VCF::Image | The Image class is an abstract class that defines how you can work with and manipulate an image |
| VCF::ImageComponent | |
| VCF::ImageContext | This is a simple class that is intended to be used when you need access to an image's GraphicsContext |
| VCF::ImageControl | Class ImageControl documentation |
| VCF::ImageDataObject | |
| VCF::ImageEvent | |
| VCF::ImageFilenamePropertyEditor | |
| VCF::ImageList | An image list is a collection of images |
| VCF::ImageListEvent | |
| VCF::ImageLoader | The ImageLoader interface provides a means to load up images into a generic Bitmap |
| VCF::ImageLoaderException | |
| VCF::ImagePropertyEditor | |
| VCF::ImageTile | |
| VCF::ImplementedInterfaceClass | ImplementedInterfaceClass documentation |
| VCF::Initialization | |
| VCF::InputStream | InputStream, basic interface describing the requirements to support streaming data into a stream |
| VCF::IntegerPropertyEditor | |
| VCF::Interface | Base class for interfaces |
| VCF::InterfaceClass | The InterfaceClass does much the same for interface classes that the VCF::Class does for classes |
| VCF::InterfaceInfo< INTERFACE_TYPE > | The InterfaceInfo class serves bascially the same purpose as the ClassInfo class |
| VCF::InternetKit | The InternetKit is a singleton class that initializes the rest of the InternetKit and the InternetToolkit class |
| VCF::InternetToolkit | The InternetToolkit is used to get data from the URL |
| VCF::InvalidImage | |
| VCF::InvalidImplementer | |
| VCF::InvalidMessageDialogException | |
| VCF::InvalidPeer | |
| VCF::InvalidPointerException | |
| VCF::InvalidStateException | |
| IOleClientSiteImpl | |
| IOleInPlaceFrameImpl | |
| IOleInPlaceSiteImpl | |
| VCF::IPAddress | |
| VCF::IPAddressPeer | |
| VCF::IPEndPoint | |
| IServiceProviderImpl | |
| VCF::Item | The Item class can be used represent a single element in a model |
| VCF::ItemEditorEvent | |
| VCF::ItemEvent | |
| VCF::ItemSort | |
| VCF::Regex::Iterator | A bi-directional iterator to simplify the regex interface |
| VCF::JavaScriptEngine | |
| VCF::JavaScriptEngine::ClassEntry | |
| VCF::JavaScriptEngine::ObjectInstanceEntry | |
| VCF::JavaScriptEvent | |
| VCF::JavaScriptKit | |
| VCF::JPEGLoader | A class for built in support for reading and writing JPEG images |
| VCF::Kernel | |
| VCFWin32::KeyboardData | |
| VCF::KeyboardEvent | |
| VCF::Label | |
| VCF::Layer | |
| VCF::Library | A Library represents a DLL (Dynamic Linked Library) or SO (Shared Object) |
| VCF::LibraryApplication | Class LibraryApplication documentation |
| VCF::LibraryPeer | The LibraryPeer represents a generic wrapper around using DLL/SOs on systems |
| VCF::Light3DBorder | Class Light3DBorder documentation |
| VCF::LightweightComponent | |
| VCF::LinuxFilePeer | |
| VCF::LinuxFileStream | This is going to based on the C runtime's fopen/fread/fwrite stream API for now |
| VCF::LinuxLibraryPeer | |
| VCF::LinuxLocalePeer | |
| VCF::LinuxProcessIORedirector | Win32 (NT or better) implementation of ProcessIORedirectionPeer original code swiped from: (c) 2002 Andreas Saurwein - saurwein@uniwares.com Any mistakes are mine due to the "port" over into the VCF |
| VCF::LinuxProcessPeer | |
| VCF::LinuxRegistry | |
| VCF::LinuxResourceBundle | |
| VCF::LinuxRunLoopPeer | |
| VCF::LinuxRunLoopSourcePeer | |
| VCF::LinuxRunLoopTimerPeer | |
| VCF::LinuxSemaphorePeer | Class LinuxSemaphorePeer |
| VCF::LinuxSystemPeer | |
| VCF::LinuxSystemToolkit | |
| VCFLinux::LinuxUtils | General purpose utility class |
| VCF::List< ItemType > | |
| VCF::ListBoxControl | |
| VCF::ListControl | A base class that provides a consistent interface and implementation for any control class that deals with a list of data held in a ListModel and a collection of ListItems |
| VCF::ListController | |
| VCF::ListItem | |
| VCF::ListItemState | |
| VCF::ListModel | The List is a simple model that stores a list of data |
| VCF::ListModelEvent | |
| VCF::ListPeer | |
| VCF::ListSubItem | |
| VCF::ListViewControl | |
| VCF::ListviewPeer | |
| VCF::Locale | A locale instance represents the cultural data used to convert data to string in manner appropriate to the language and country |
| VCF::LocalePeer | |
| VCF::Lock | The Lock class represents a way to automatically lock or unlock a syncronizeable primitive, like a thread, mutex, or semaphore, by having the lifetime of the Lock stack based |
| VCF::Map< KeyType, ValueType > | |
| VCF::Regex::Match | Contains details of matches found during regex searches, namely the regex object that performed the search, the position in which the match was made and the exact text that triggered the match |
| VCF::Math | |
| VCF::Matrix2D | The Matrix2D is used for transforming 2D shapes or images |
| VCF::MDIPolicy | Class MDIPolicy policy class for a Multiple Document Interface (MDI) |
| VCF::Menu | |
| VCF::MenuBar | A menu bar is used to control a menu associated with either the application or a Frame |
| VCF::MenuBarPeer | |
| VCF::MenuItem | |
| VCF::MenuItemEvent | |
| VCF::MenuItemPeer | |
| VCF::MenuManager | The MenuManager class is used by the internals of the framework to make sure that menu are handled in a platform neutral way |
| VCF::MenuManagerPeer | |
| VCF::MenuState | |
| VCF::MessageDialog | MessageDialog class let the user to create at run time a dialog with many options for customization |
| VCF::MessageLoader | |
| VCF::Method | Base class for dynamic method invocation Methods are dynamically invokable and can support querying for argument types querying is done throught the getArgumentType() method and will only work if the argTypes_ string has bee set appropriately |
| VCF::MIMEType | Specification for this MIME Types may be found at RFC 2045 http://www.faqs.org/rfcs/rfc2045.html |
| VCF::Model | A model is the base class for storing data that can then be presented to the user by controls and/or views |
| VCF::ModelEvent | |
| VCF::MouseEvent | |
| VCF::MultilineTextControl | Class MultilineTextControl documentation |
| VCF::Mutex | Class Mutex documentation |
| VCF::MutexPeer | Class MutexPeer documentation |
| VCF::NetworkException | Base class for all exceptions in the NetworkKit |
| VCF::NetworkKit | The NetworkKit class is used to initialize the NetworkKit runtime |
| VCF::NetworkToolkit | |
| VCF::NoFreeMemException | |
| VCF::NoGraphicsToolkitFoundException | |
| NoImplementerFoundException | |
| VCF::NoPeerFoundException | |
| VCF::NoSuchElementException | |
| VCF::NotImplementedException | |
| NoToolKitFoundException | |
| VCF::NullClassType0 | |
| VCF::NullClassType1< ParamType1 > | |
| VCF::NullClassType2< ParamType1, ParamType2 > | |
| VCF::NullClassType3< ParamType1, ParamType2, ParamType3 > | |
| VCF::NullClassType4< ParamType1, ParamType2, ParamType3, ParamType4 > | |
| VCF::NullClassType5< ParamType1, ParamType2, ParamType3, ParamType4, ParamType5 > | |
| VCF::NullClassType6< ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ParamType6 > | |
| VCF::NullClassType7< ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ParamType6, ParamType7 > | |
| VCF::NullClassType8< ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ParamType6, ParamType7, ParamType8 > | |
| VCF::NullReturnClassType0< ReturnType > | |
| VCF::NullReturnClassType1< ReturnType, ParamType1 > | |
| VCF::NullReturnClassType2< ReturnType, ParamType1, ParamType2 > | |
| VCF::NullReturnClassType3< ReturnType, ParamType1, ParamType2, ParamType3 > | |
| VCF::NullReturnClassType4< ReturnType, ParamType1, ParamType2, ParamType3, ParamType4 > | |
| VCF::NullReturnClassType5< ReturnType, ParamType1, ParamType2, ParamType3, ParamType4, ParamType5 > | |
| VCF::NullReturnClassType6< ReturnType, ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ParamType6 > | |
| VCF::Object | Base class for the entire Visual Component Framework |
| VCF::ObjectWithCallbacks | ObjectWithCallbacks is an object that may have 0 or more CallBacks associated with it, and will automatically clean up these CallBacks when it is destroyed |
| VCF::OpenGLContext | |
| VCF::OpenGLControl | |
| VCF::OpenGLKit | |
| VCF::OpenGLPeer | |
| VCF::OpenGLToolkit | The OpenGLToolkit is a singleton class that creates instances of a OpenGLPeer specific to the windowing system the toolkit is running on |
| VCF::OrderedEnumerator< ItemType, CollectionType > | The OrderedEnumerator is a utility class that makes it easy to use a specific stl collection class (like a vector) and have support for the Enumerator interface |
| VCF::OSHandlePeer | This is used to as a generic wrapper around native OS objects or "handles" |
| VCF::OSXApplicationPeer | |
| VCF::OSXAppResourceBundle | |
| VCF::OSXButton | |
| VCF::OSXClipboard | Class OSXClipboard documentation |
| VCF::OSXColorDialog | |
| VCF::OSXConditionPeer | Class OSXConditionPeer documentation Part/most of the implementation for this class comes from William E |
| VCF::OSXContext | |
| VCF::OSXControl | |
| VCF::OSXControlContextPeer | |
| VCF::OSXCursorPeer | |
| VCF::OSXDesktopPeer | |
| VCF::OSXDialog | |
| VCF::OSXDragDropPeer | |
| VCF::OSXDropTargetPeer | |
| VCF::OSXEventMsg | This class is used as a wrapper around an XEvent |
| VCF::OSXFileOpenDialog | |
| VCF::OSXFilePeer | |
| VCF::OSXFilePeer::FileSearchData | |
| VCF::OSXFileSaveDialog | |
| VCF::OSXFileStream | This is going to based on the C runtime's fopen/fread/fwrite stream API for now |
| VCF::OSXFolderBrowseDialog | |
| VCF::OSXFont | |
| VCF::OSXGCRef | |
| VCF::OSXGraphicsResourceBundle | |
| VCF::OSXGraphicsToolkit | Class OSXGraphicsToolkit documentation |
| VCF::OSXImage | |
| VCF::OSXLibraryPeer | |
| VCF::OSXLightweightControl | |
| VCF::OSXListview | |
| VCF::OSXLocalePeer | |
| VCF::OSXMenuBar | |
| VCF::OSXMenuItem | |
| VCF::OSXMenuManagerPeer | |
| VCF::OSXMutex | Class ConditionalPeer documentation |
| VCF::OSXPopupMenu | |
| VCF::OSXProcessHandle | This is the handle class that OSXProcessPeer::getHandleID() returns |
| VCF::OSXProcessPeer | |
| VCF::OSXRect | Utility class to faciltate the transfer from a VCF::Rect instance or HIRect instance to OSX's Rect struct |
| VCF::OSXRegistry | |
| VCF::OSXResourceBundle | |
| VCF::OSXRunLoopPeer | |
| VCF::OSXRunLoopSourcePeer | |
| VCF::OSXRunLoopTimerPeer | |
| VCF::OSXScrollPeer | Class OSXScrollPeer documentation |
| VCF::OSXSemaphore | Class MutexPeer documentation |
| VCF::OSXStringUtils | |
| VCF::OSXSystemPeer | |
| VCF::OSXSystemToolkit | |
| VCF::OSXTextEditPeer | |
| VCF::OSXTextPeer | |
| VCF::OSXThread | |
| VCF::OSXThreadManagerPeer | |
| VCF::OSXToolbar | |
| VCF::OSXTree | |
| VCF::OSXUIShellPeer | |
| VCF::OSXUIToolkit | |
| OSXUIUtils | |
| VCF::OSXWindow | |
| VCF::OutOfBoundsException | |
| VCF::OutputReadyEvent | |
| VCF::OutputStream | OutputStream, basic interface describing the requirements to support streaming data into a stream |
| VCF::PackageInfo | This class provides extra information specifically for shared or static libraries |
| VCF::PackageManager | |
| VCF::Panel | |
| VCF::ParsePosition | |
| VCF::Path | A Path is an abstract class that represents a series of points used to draw one or more shapes |
| VCF::PathPoint | Utility to make working with path points easier |
| VCF::Persistable | Persistable is a simple interface used to indicate that an object can read or write itself to an input or output stream |
| VCF::PixelAllocater< PixTraits > | |
| VCF::PixelException | |
| VCF::Pixels< PixelType > | |
| VCF::PixelTraits< SizeType, FloatingPoint, GrayScale > | |
| VCF::PNGLoader | A class for built in support for reading and writing PNG images |
| VCF::Point | 2 dimensional coordinate (x and y) and stores the data as doubles, for maximum precision |
| VCF::PoolThread | This is the specific thread class that the thread pool uses to create the threads for itself |
| VCF::PopupMenu | This class is for creating popup menus, sometimes referred to as a context, or contextual menu |
| VCF::PopupMenuPeer | |
| VCF::PopupWindow | |
| VCF::PopupWindowPeer | |
| VCF::PosixCondition | Class PosixCondition documentation |
| VCF::PosixMutex | Class ConditionalPeer documentation |
| VCF::PosixThread | |
| VCF::PosixThreadManagerPeer | |
| VCF::Printable | |
| VCF::PrintContext | |
| PrintContext | This represents the printing context, used for drawing when printing is being invoked |
| VCF::PrintEvent | A PrintEvent is fired by the PrintSession during certain operations |
| VCF::PrintSession | The PrintSession is the core printing class |
| VCF::PrintSessionPeer | |
| VCF::Procedure | A callback that takes no arguments |
| VCF::Procedure1< P1 > | Represents a callback for a static function with one function argument of type P1 and no return type |
| VCF::Procedure2< P1, P2 > | |
| VCF::Procedure3< P1, P2, P3 > | |
| VCF::Procedure4< P1, P2, P3, P4 > | |
| VCF::Procedure5< P1, P2, P3, P4, P5 > | |
| VCF::Procedure6< P1, P2, P3, P4, P5, P6 > | |
| VCF::Procedure7< P1, P2, P3, P4, P5, P6, P7 > | |
| VCF::Procedure8< P1, P2, P3, P4, P5, P6, P7, P8 > | |
| VCF::Process | |
| VCF::ProcessException | |
| VCF::ProcessIORedirectionPeer | This defines the interface for a redirecting process input/ouput |
| VCF::ProcessPeer | Peer class that wraps working with processes on OS's |
| VCF::ProcessWithRedirectedIO | This class represents a process that has it's IO redirected so that when there is new data available an event is fired to any registered event handlers |
| VCF::ProgramInfo | This class provides a platform neutral way to access additional information about a program |
| VCF::ProgressControl | The ProgressControl is a class that displays a vertical or horizontal progress bar showing the position of within a given range of a task |
| VCF::ProgressState | |
| VCF::Property | The Property class represents a member attribute of a class |
| VCF::PropertyChangeEvent | Property change event's are used whenever a propertys value changes |
| VCF::PropertyChangeException | |
| VCF::PropertyEditor | This is the common base class for any editor that is specific of any property |
| VCF::PropertyEditorManager | This is the class for managing the current list of property editors available for use in editing a property |
| VCF::PropertyListing | A PropertyListing is just a Dictionary with some extra functions that make it easy to deal with sub dictionaries and arrays |
| VCF::ProtocolHandler | |
| VCF::PushButton | Class PushButton documentation |
| VCF::RadialGradientFill | |
| VCF::RadioButtonControl | Class RadioButtonControl documentation |
| VCF::Rect | |
| RefCount | |
| VCF::RegExKit | |
| VCF::Registry | The registry represents an external data source that applications may store application data in |
| VCF::RegistryException | |
| VCF::RegistryPeer | |
| VCF::RegistryValueInfo | Class that wraps up a specific registry value that may be a string, integer, bool, or stream of binary data |
| VCF::Resource | |
| VCF::ResourceBundle | A ResourceBundle is used to represent a collection of resources |
| VCF::ResourceBundlePeer | Class ResourceBundlePeer documentation |
| VCF::ResourceException | |
| VCF::ResultsCache< ReturnType > | A class that is uses to cache the results of callbacks that return values |
| VCF::RGBAPixel< BitSizeType, FloatingPoint, PixTraitsType, PixAllocaterType > | Defines a channel layout order of r,g,b,a with BitSizeType bits per channel |
| VCF::RGBAPixel< float, true > | |
| VCF::RunLoop | The RunLoop class is used to create an instance of an OS event queue |
| VCF::RunLoopPeer | |
| VCF::RunLoopSource | |
| VCF::RunLoopSourcePeer | |
| VCF::RunLoopTimer | |
| VCF::RunLoopTimerPeer | |
| VCF::Runnable | A class that represents a single executable task |
| VCF::RuntimeException | |
| VCF::SchemaValidationException | |
| VCF::Scrollable | This class is used to add scrolling support to a control |
| VCF::ScrollbarManager | The ScrollbarManager represents a component used for managing scrolbars for a target control |
| VCF::ScrollbarPeer | |
| VCF::ScrollBarState | |
| VCF::ScrollEvent | |
| VCF::ScrollPeer | Class ScrollPeer documentation |
| VCF::SDIPolicy | Class SDIPolicy policy class for Single Document Interface This is the implementation of the regular SDI architecture, with all the tipical operations on a document that we can find in an application having a single document |
| VCF::Semaphore | Class Semaphore |
| VCF::SemaphorePeer | Class MutexPeer documentation |
| VCF::SeparatorMenuItem | Class to help creating a separator menu item |
| VCF::ShadowFill | |
| VCF::SimpleListModel | |
| VCF::Size | |
| VCF::SliderControl | The SliderControl, sometimes referred to as a "trackbar" provides a UI that consists of a thumb button that slides, vertically or horizontally, along a "track" |
| VCF::SliderState | |
| VCF::SmartPtr< T > | |
| VCF::Socket | |
| VCF::SocketEvent | |
| VCF::SocketException | |
| VCF::SocketPeer | An abstract class that represents a platform socket implementation |
| VCF::SocketReadException | |
| VCF::SocketWriteException | |
| VCF::Splitter | Class Splitter documentation |
| VCF::StandardContainer | Basic implementation of a container handles basic alignment,layout of child components |
| VCF::StatusBar | |
| VCF::StatusBar::Container | Te container internally used by this control |
| VCF::Stream | Stream interface defines a core set of funcationality for streams in the Visual Component Framework derived Streams should support "stream chaining", the ability of the stream constructor to support an incoming stream from someother stream object |
| VCF::StringPropertyEditor | |
| VCF::StringsMessageLoader | |
| VCF::StringsMessageLoader::Exception | |
| VCF::StringTokenizer | Class for breaking a string into a series of one or more tokens |
| VCF::StringUtils | The StringUtils class is a collection of static utility methods for operating on strings |
| VCF::Stroke | |
| VCF::SynchObject | Class SynchObject documentation Defines an abstract base class for synchronisation classes like mutexes and semaphores, to be used with the lock class |
| VCF::System | The System object represents basic lower level OS functions |
| VCF::SystemPeer | Defines the SystemPeer interface |
| VCF::SystemToolkit | The SystemToolkit is and abstract class used to create or get access to basic system peer instances, like threads, processes, etc |
| VCF::SystemTray | The SystemTray component provides a simple wrapper around system tray functionality |
| VCF::SystemTrayPeer | |
| VCF::TabbedPages | |
| VCF::TabbedPages::ScrollButton | |
| VCF::TableCellEvent | |
| VCF::TableCellItem | |
| VCF::TableControl | This class if for presenting data in a tabular format |
| VCF::TableItemEditor | The TableItemEditor class is used to provide editing capabilities for individual cell items in a TableControl |
| VCF::TableItemState | |
| VCF::TableModel | |
| VCF::TableModelEvent | |
| VCF::TabModel | The Tab model is a interface for describing what a model that implements a series of tabs should do |
| VCF::TabModelEvent | Event class for events specific of tabbed pages It containes the pointer to the specific tab page associated to this event |
| VCF::TabPage | |
| VCF::TabSheet | |
| VCF::TabState | |
| VCF::TCPSocket | A socket class that represents a TCP socket |
| VCF::TCPSocketInputStream | An input stream class used for reading data from a TCP socket |
| VCF::TCPSocketOutputStream | An output stream class used for writing data to a TCP socket |
| VCF::TextCodec | The TextCode class represents a way of transforming an ansi or unicode string into another form of unicode |
| VCF::TextControl | The base class for presenting text to the user |
| VCF::TextDataObject | |
| VCF::TextEditPeer | A interface for supporting text controls This results in a native text control widget being created, with all painting responsibilities being controlled by the native widget |
| VCF::TextEvent | |
| VCF::TextInputStream | TextInputStream is used for interpreting data from another stream as text |
| VCF::TextModel | The TextModel is a model interface for working with text data |
| VCF::TextOutputStream | The TextOutputStream is used for writing data from another stream as text |
| VCF::TextPeer | This is the basic text peer interface for storing and displaying text on the screen |
| VCF::TextState | |
| VCF::ThemeBorder | Draws a native theme compliant border around a component |
| VCF::Thread | The Thread class represents a thread of execution in a process |
| VCF::ThreadedFunction< ReturnType, ClassType > | |
| VCF::ThreadedFunction1< ReturnType, ParamType1, ClassType > | |
| VCF::ThreadedFunction2< ReturnType, ParamType1, ParamType2, ClassType > | |
| VCF::ThreadedFunction3< ReturnType, ParamType1, ParamType2, ParamType3, ClassType > | |
| VCF::ThreadedFunction4< ReturnType, ParamType1, ParamType2, ParamType3, ParamType4, ClassType > | |
| VCF::ThreadedFunction5< ReturnType, ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ClassType > | |
| VCF::ThreadedFunction6< ReturnType, ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ParamType6, ClassType > | |
| VCF::ThreadedProcedure< ClassType > | |
| VCF::ThreadedProcedure1< ParamType1, ClassType > | |
| VCF::ThreadedProcedure2< ParamType1, ParamType2, ClassType > | |
| VCF::ThreadedProcedure3< ParamType1, ParamType2, ParamType3, ClassType > | |
| VCF::ThreadedProcedure4< ParamType1, ParamType2, ParamType3, ParamType4, ClassType > | |
| VCF::ThreadedProcedure5< ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ClassType > | |
| VCF::ThreadedProcedure6< ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ParamType6, ClassType > | |
| VCF::ThreadedProcedure7< ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ParamType6, ParamType7, ClassType > | |
| VCF::ThreadedProcedure8< ParamType1, ParamType2, ParamType3, ParamType4, ParamType5, ParamType6, ParamType7, ParamType8, ClassType > | |
| VCF::ThreadedProcedure< NullClassType0 > | |
| VCF::ThreadEvent | |
| VCF::ThreadException | |
| VCF::ThreadManager | |
| VCF::ThreadManagerPeer | |
| VCF::ThreadPeer | Basic Thread interface to wrap native thread OS calls |
| VCF::ThreadPool | A simple class for thread pooling |
| VCF::TileManager | |
| VCF::TimeOutHandler | |
| VCF::TimerComponent | The TimerComponent is used to fire timer events |
| VCF::TimerEvent | Class TimerEvent documentation |
| VCF::TimeZone | |
| VCF::TitledBorder | |
| VCF::ToggledButton | RadioButtonControl base class for toggled buttons |
| VCF::Toolbar | A class for adding toolbars to your window |
| VCF::Toolbar::FloatingToolbar | Inner class used by the Toolbar to create a Floating toolbar window when the Toolbar is dragged out of it's dock |
| VCF::ToolbarDock | A toolbar dock represents a rectangular child window that may hold o or more toolbars |
| VCF::ToolbarItem | |
| VCF::ToolbarModel | |
| VCF::ToolbarModelEvent | |
| VCF::ToolbarPeer | |
| VCF::ToolTipEvent | The tooltip event is fired when tooltip text is being requested and/or just before the tooltip is ready to be shown, allowing the handler to customize the tooltip's data or presentation |
| VCF::TransparentWindow | |
| VCF::TransparentWindowPeer | |
| VCF::TreeControl | |
| VCF::TreeController | |
| VCF::TreeItem | |
| VCF::TreeItemState | |
| VCF::TreeListControl | |
| VCF::TreeListModel | |
| VCF::TreeModel | |
| VCF::TreeModelEvent | |
| VCF::TreePeer | |
| VCF::TreeSubItem | |
| VCF::TypeCastException | |
| VCF::UDPSocket | |
| VCF::UDPSocketInputStream | An input stream class used for reading data from a UDP socket |
| VCF::UDPSocketOutputStream | |
| VCF::UIApplication | Class UIApplication documentation |
| VCF::UIComponent | |
| VCF::UIMetricsManager | A utility class to retrieve standard ui element metrics |
| VCF::UIPolicyManager | Helper class for any document interface policy it manages things like merging menus, etc |
| VCF::UIShell | The desktop represents the Windowing systems bottom most control or "window" and is usually the first window the User sees when the system starts up |
| VCF::UIShellPeer | Class UIShellPeer interface documentation |
| VCF::UIToolkit | The UIToolkit is used to create instances of various peer's needed by the VCF, as well as providing certain low level services, such as modal and non-modal event loops, and getting at UI metrics |
| VCF::UndoRedoEvent | Event for the UndoRedoStack operations |
| VCF::UndoRedoStack | Stack class managing any undo redo operation |
| VCF::UnicodeString | The UnicodeString class represents a thin wrapper around the std::basic_string class since std::basic_string cannot be derived from (it has no virtual destructor) |
| VCF::UnitTransformer | |
| VCF::URL | The URL class wraps a string that points to some resource, either on the local filesystem or over the internet |
| VCF::URLAuthenticationEvent | |
| VCF::URLAuthenticationException | |
| VCF::URLDataException | |
| VCF::URLEvent | |
| VCF::URLException | |
| VCF::Regex::UTF_16LE | Regex engine for UTF-16LE text |
| VCF::UVMap | |
| VCF::ValidationEvent | |
| VCF::ValidSchemaParseException | |
| VCF::VariantArray | |
| VCF::VariantData | VariantData represents an unknown type of variable - similiar to Visual Basic's Variant object |
| VCF::VariantDataInputStream | The VariantDataInputStream is used to read a VariantData object from an InputStream source |
| VCF::VariantDataOutputStream | The VariantDataOutputStream is used to write a VariantData object to an OutputStream source |
| VCF::VerticalGradientFill | |
| VCF::VFFInputStream | |
| VCF::VFFInputStream::DeferredDelegateSetter | |
| VCF::VFFInputStream::DeferredPropertySetter | |
| VCF::VFFOutputStream | The VFFOutputStream class is used to support writing a component ( and it's child components) to a stream |
| VCF::VFFParser | A class used for parsing VFF files, at this moment (8/25/2001) meant for internal use only |
| VCF::View | A view represents a visual display or rendering of part or all of the data in a model |
| ViewCreator< ViewType > | |
| VCF::Waitable | |
| WebBrowserCtrl | |
| VCF::WhatsThisHelpEvent | |
| VCF::Win32Application | |
| VCF::Win32AppResourceBundle | |
| VCF::Win32Button | |
| VCF::Win32Clipboard | Class Win32Clipboard documentation |
| VCF::Win32ColorDialog | |
| VCF::Win32Component | |
| VCF::Win32Condition | Class Win32Condition documentation Part/most of the implementation for this class comes from William E |
| VCF::Win32Context | A Context provides the lowest level graphics interface to the native systems 2D drawing operations |
| VCF::Win32ControlContext | Implementation of the peer for Win32 of the GraphicsContext |
| VCF::Win32CursorPeer | Class Win32CursorPeer documentation |
| VCF::Win32Dialog | |
| VCF::Win32DragDropPeer | |
| VCF::Win32DragDropPeer::COMDragSource | |
| VCF::Win32DropDownPeer | |
| VCF::Win32DropTargetPeer | |
| VCF::Win32DropTargetPeer::COMDropTarget | |
| VCF::Win32Edit | |
| VCF::Win32FileOpenDialog | |
| VCF::Win32FilePeer | |
| VCF::Win32FilePeer::Win32FindData | |
| VCF::Win32FilePeer::Win32FindDataA | |
| VCF::Win32FilePeer::Win32FindDataW | |
| VCF::Win32FileSaveDialog | |
| VCF::Win32FileStream | |
| VCF::Win32FolderBrowseDialog | |
| VCF::Win32Font | |
| VCF::Win32FontDialog | |
| VCF::Win32FontHandle | Used to hold a HFONT and a refcount |
| VCF::Win32FontManager | Uses to manage fonts for controls |
| VCF::Win32GraphicsResourceBundle | |
| VCF::Win32GraphicsToolkit | Class Win32GraphicsToolkit documentation |
| VCF::Win32GrayScaleImage | |
| VCF::Win32HTMLBrowser | Class Win32HTMLBrowser documentation |
| VCF::Win32HTMLToolkit | |
| VCF::Win32Image | |
| VCF::Win32InternetToolkit | |
| VCF::Win32IPAddressPeer | |
| VCF::Win32LibraryPeer | |
| VCF::Win32ListBox | |
| VCF::Win32Listview | |
| VCF::Win32LocalePeer | |
| VCF::Win32MenuBar | |
| VCF::Win32MenuItem | |
| VCF::Win32MenuManagerPeer | |
| VCF::Win32MSG | |
| VCF::Win32Mutex | Class Win32Mutex documentation |
| VCF::Win32NetworkToolkit | |
| VCF::Win32Object | |
| VCF::Win32OpenGLPeer | |
| VCF::Win32PopupMenu | |
| VCF::Win32PopupWindowPeer | |
| VCF::Win32PrintDialog | Class Win32PrintDialog documentation |
| VCF::Win32PrintInfo | |
| VCF::Win32PrintSession | |
| VCF::Win32ProcessIORedirector | Win32 (NT or better) implementation of ProcessIORedirectionPeer original code swiped from: (c) 2002 Andreas Saurwein - saurwein@uniwares.com Any mistakes are mine due to the "port" over into the VCF |
| VCF::Win32ProcessPeer | |
| VCF::Win32Registry | |
| VCF::Win32ResourceBundle | |
| VCF::Win32RunLoopPeer | |
| VCF::Win32RunLoopSourcePeer | |
| VCF::Win32RunLoopTimerPeer | |
| VCF::Win32ScrollPeer | Class Win32ScrollPeer documentation |
| VCF::Win32SemaphorePeer | Class Win32SemaphorePeer |
| VCF::Win32SocketPeer | |
| VCF::Win32SystemPeer | |
| VCF::Win32SystemToolkit | |
| VCF::Win32SystemTrayPeer | This is the Win32 implementation of the SystemTrayPeer class |
| VCF::Win32TextPeer | |
| VCF::Win32Thread | |
| VCF::Win32ThreadManagerPeer | |
| VCF::Win32Toolbar | |
| VCF::Win32ToolKit | |
| VCF::Win32ToolKit::TimerRec | |
| VCF::Win32TransparentWindowPeer | |
| VCF::Win32Tree | |
| VCF::Win32UDPSocketPeer | |
| VCF::Win32UIShell | Class Win32UIShell documentation |
| VCFWin32::Win32UIUtils | |
| VCFWin32::Win32Utils | What follows are a set of standard utility functions for Win32 |
| Win32VisualStylesWrapper | Based on the class CVisualStylesXP by David Yuheng Zhao |
| VCF::Win32Window | |
| VCF::Window | A frame with min |
| VCF::WindowEvent | |
| VCF::WindowPeer | |
| VCF::Wizard | A Wizard is used to disaplay a UI in a wizard dialog |
| VCF::XCBAbstractControl | |
| VCF::XCBApplicationPeer | |
| VCF::XCBApplicationResourceBundlePeer | |
| VCF::XCBButton | |
| VCF::XCBContextPeer | |
| VCF::XCBContextPeer::GlyphInfo | |
| VCF::XCBControlContextPeer | |
| VCF::XCBCursorPeer | |
| VCF::XCBDesktopPeer | |
| VCF::XCBEventMessage | |
| VCF::XCBFontPeer | |
| VCF::XCBGraphicsResourceBundlePeer | |
| VCF::XCBGraphicsToolkit | Class XCBGraphicsToolkit documentation |
| VCF::XCBGrayscaleImagePeer | |
| VCF::XCBImagePeer | |
| VCF::XCBMenuBarPeer | |
| VCF::XCBMenuManagerPeer | |
| VCF::XCBSurface | This represents the struct that we need to build a VCF graphics context peer |
| VCF::XCBUIMetricsManager | |
| VCF::XCBUIShellPeer | |
| VCF::XCBUIToolkit | |
| VCF::XCBUIToolkit::XCBCookieInfo | |
| VCF::XCBWindowPeer | |
| VCF::XMLAttr | Class XMLAttr documentation |
| VCF::XMLDictInputStream | |
| VCF::XMLDictOutputStream | |
| VCF::XmlDocument | |
| VCF::XMLError | |
| VCF::XmlException | |
| VCF::XMLKit | |
| VCF::XmlNamespace | |
| VCF::XMLNode | Class XMLNode represents a single node in a parsed XML document |
| VCF::XmlNode | |
| VCF::XMLParser | |
| VCF::XMLParserEvent | Class XMLParserEvent documentation |
| XMLParserHandler | Class XMLParserHandler documentation |
| VCF::XMLSaxParser | |
| VCF::XmlSchema | |
| VCF::XmlSchemaContext | |
| VCF::XMLTextReader | |
| VCF::XmlTextWriter | |
| VCF::XMLUtils | |
| VCF::XmlValidSchemaContext | |
| VCF::XPathExpression | |
| VCF::XPathIterator | |
| VCF::XPathNodeIterator | |
| VCF::XSLTStyleSheet | |
