| 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 |
| VCFRemote::AbstractDistributedApplication | Class AbstractDistributedApplication documentation |
| VCFRemote::AbstractDistributedApplication::DistributedAppListener | |
| VCF::AbstractEventProperty | |
| VCF::AbstractGTKControl | This class serves as a common implementation for various methods of the ControlPeer interface |
| VCF::AbstractGTKControl::Container | |
| VCF::AbstractGTKControl::ContainerChild | |
| VCF::AbstractGTKControl::ContainerClass | |
| VCF::AbstractImage | AbstractImage represents a base implementation of the Image interface |
| VCF::AbstractListModel | The AbstractListModel is basic implementation of ListModel |
| VCF::AbstractModel | The AbstractModel is a base class for creating your own custom model classes |
| VCF::AbstractPropertyEditor | |
| VCF::AbstractScrollable | Class AbstractScrollable documentation |
| VCF::AbstractScrollable::ControlResizeHandler | |
| VCF::AbstractTableModel | An AbstractTableModel repersents a basic implementation of a TableModel |
| VCF::AbstractTreeModel | AbstractTreeModel is a basic implementation of Treemodel |
| 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 |
| VCFRemote::AppInfo | A small object that can be passed around from app to app that includes information about the app |
| VCF::Application | Represents the main process for a application |
| VCF::ApplicationException | Application level exceptions |
| VCF::ApplicationKit | |
| 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::Regex::Ascii | Regex engine for Ascii text |
| 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::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::ButtonEventHandler< SOURCE_TYPE > | ButtonEventHandler handles the following: onButtonClicked |
| VCF::ButtonPeer | |
| VCF::ButtonState | |
| VCF::ByDay | |
| VCF::ByHour | |
| VCF::ByMillisecond | |
| VCF::ByMinute | |
| VCF::ByMonth | |
| VCF::BySecond | |
| VCF::ByYear | |
| 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 | |
| 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::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::ClassRegistry | ClassRegistry contains all Class's in the Framework Runtime |
| VCFRemote::ClassRegistryEntry | A Class Registry entry contains the neccessary information to create a class from a server, either locally (more often than not), or remotely, if the remote class has been cached for faster lookup |
| VCFRemote::ClassServerInstance | |
| 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::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::ColumnModelEvent | Class ColumnModelEvent documentation |
| VCF::ColumnModelEventHandler< SOURCE_TYPE > | |
| 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::ComponentEventHandler< SOURCE_TYPE > | |
| 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::ControlEventHandler< SOURCE_TYPE > | ControlEventHandler Handles the following: Sized Positioned ParentChanged |
| 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 |
| VCFNet::DatagramSocket | |
| VCFNet::DatagramSocketPeer | |
| 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::DefaultColumnItem | Class DefaultColumnItem documentation |
| VCF::DefaultColumnModel | Class DefaultColumnModel documentation |
| VCF::DefaultListItem | |
| VCF::DefaultListModel | |
| VCF::DefaultListModelPropertyEditor | |
| VCF::DefaultMenuItem | |
| VCF::DefaultMenuItemPropertyEditor | |
| VCF::DefaultTableCellItem | |
| VCF::DefaultTableModel | |
| VCF::DefaultTabModel | This class represents a default, basic implementation of the TabModel class |
| VCF::DefaultTabPage | |
| VCF::DefaultTextModel | |
| VCF::DefaultTreeItem | |
| VCF::DefaultTreeModel | |
| VCF::Delegate | The Delegate class is used to maintain a collection of event handlers and fire events to them |
| 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::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 | |
| VCFRemote::DistributedApplication | Interface for distributed applications also provides a statice method for the main entry point into a distributed app |
| VCFRemote::DistributedClassRegistry | Class DistributedClassRegistry documentation |
| VCFRemote::DistributedException | Class DistributedException documentation |
| DocInterfacePolicy | |
| VCF::DockManager | DockManager class uses to manage ToolbarDock's and floating toolbars |
| VCF::DocManagerEvent | Class DocManagerEvent |
| VCF::Document | A document is a model has many extra features like saving, loading, cutting and all that kind of stuff |
| VCF::DocumentBasedApplication< DocInterfacePolicy > | |
| 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::DragEventHandler< SOURCE_TYPE > | |
| 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::DropEventHandler< SOURCE_TYPE > | |
| 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::EventHandler | EventHandler's form the back bone of the event model in the VCF |
| VCF::EventHandlerInstance< SOURCE, EVENT > | The EventHandlerInstance class is used to provide a typesafe wrapper around a specific class's member function pointer |
| VCF::EventProperty | |
| exception | |
| fd_twoints | |
| 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::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::FixedPointNumber | |
| VCF::FocusEvent | Event class for events specific of any change of focus |
| VCF::FocusEventHandler< SOURCE_TYPE > | The handler class for a FocusEvent |
| 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::FrameEventHandler< SOURCE_TYPE > | |
| VCF::GenericEventHandler< SOURCE_TYPE > | The GenericEventHandler class is provided as a convenience class for use when dealing with a generic Event object |
| VCF::GenericMemoryBuffer< DATA_TYPE > | 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 | |
| GraphicsKit | Initializes the graphics Kit runtime |
| VCF::GraphicsKit | |
| 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 > | |
| VCF::GTKApplication | |
| VCF::GTKCommandButton | Class GTKCommandButton documentation |
| VCF::GTKContext | |
| VCF::GTKControl | |
| VCF::GTKControlContext | |
| VCF::GTKCursor | |
| VCF::GTKDesktop | |
| VCF::GTKDialog | Class GTKDialog documentation |
| VCF::GTKEventMsg | This class is used as a wrapper around an XEvent |
| VCF::GTKFileOpenDialog | Class GTKFileOpenDialog documentation |
| VCF::GTKFont | |
| VCF::GTKGraphicsResourceBundle | |
| VCF::GTKGraphicsToolkit | |
| VCF::GTKImage | |
| VCF::GTKMenuBar | |
| VCF::GTKMenuManagerPeer | |
| VCF::GTKPrintSession | |
| VCF::GTKTextControl | Class GTKTextControl documentation |
| VCF::GTKToolbar | |
| VCF::GTKUIToolkit | |
| VCF::GTKWindow | |
| HBitmap32Bit | Win32 utility class |
| HBitmapData | |
| HBitmapGrayScale | |
| VCF::HeaderControl | Class HeaderControl documentation |
| VCF::HelpEvent | |
| VCF::HelpEventHandler< SOURCE_TYPE > | Class HelpEventHandler documentation |
| 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::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::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::ImageListEventHandler< SOURCE_TYPE > | ImageListEventHandler This handles the following Image List events: ImageListSizeChanged ImageAdded ImageDeleted ImageListCreated ImageListDestroyed ImageListSizeChanged |
| VCF::ImageLoader | The ImageLoader interface provides a means to load up images into a generic Bitmap |
| VCF::ImageLoaderException | |
| VCF::ImagePropertyEditor | |
| VCF::ImageTile | |
| VCF::ImlibFontHdr | This is the imlib2 font header (I got this from the test example that comes with the code |
| VCF::ImplementedInterfaceClass | ImplementedInterfaceClass documentation |
| VCF::InputStream | InputStream, basic interface describing the requirements to support streaming data into a stream |
| VCFRemote::InstanceID | |
| 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 | |
| IServiceProviderImpl | |
| VCF::Item | The Item class can be used represent a single element in a model |
| VCF::ItemEditorEvent | |
| VCF::ItemEditorEventHandler< SOURCE_TYPE > | ItemEditorEventHandler handles: onChange onValidateChange |
| VCF::ItemEvent | |
| VCF::ItemEventHandler< SOURCE_TYPE > | |
| 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 |
| JSArena | |
| JSArenaPool | |
| JSAtom | |
| JSAtomList | |
| JSAtomListElement | |
| JSAtomMap | |
| JSAtomState | |
| JSClass | |
| JSCListStr | |
| JSCodeGenerator | |
| JSCodeSpec | |
| JSConstDoubleSpec | |
| JSContext | |
| JSContext::JSGSNCache | |
| JSDependentString | |
| JSDHashEntryHdr | |
| JSDHashEntryStub | |
| JSDHashTable | |
| JSDHashTableOps | |
| jsdpun | |
| JSErrorFormatString | |
| JSErrorReport | |
| JSExtendedClass | |
| JSFunction | |
| JSFunctionSpec | |
| JSGCArenaList | |
| JSGCThing | |
| JSHashAllocOps | |
| JSHashEntry | |
| JSHashTable | |
| JSIdArray | |
| JSInlineFrame | |
| JSInt64 | |
| JSJumpTarget | |
| JSLocaleCallbacks | |
| JSLocalRootChunk | |
| JSLocalRootStack | |
| JSObject | |
| JSObjectMap | |
| JSObjectOps | |
| JSParseNode | |
| JSPrincipals | |
| JSProperty | |
| JSPropertyCache | |
| JSPropertyCacheEntry | |
| JSPropertyDesc | |
| JSPropertyDescArray | |
| JSPropertySpec | |
| JSPropertyTreeEntry | |
| JSPtrTable | |
| JSRegExp | |
| JSRegExpStatics | |
| JSResolvingEntry | |
| JSResolvingKey | |
| JSRuntime | |
| JSScope | |
| JSScopeProperty | |
| JSScript | |
| JSSharpObjectMap | |
| JSSpanDep | |
| JSSrcNoteSpec | |
| JSStackFrame | |
| JSStackHeader | |
| JSStmtInfo | |
| JSString | |
| JSStringBuffer | |
| JSSubString | |
| JSTempValueRooter | |
| JSTempValueUnion | |
| JSToken | |
| JSTokenBuf | |
| JSTokenPos | |
| JSTokenPtr | |
| JSTokenStream | |
| JSTreeContext | |
| JSTryNote | |
| JSXDROps | |
| JSXDRState | |
| JSXML | |
| JSXMLArray | |
| JSXMLArrayCursor | |
| JSXMLNamespace | |
| JSXMLObjectOps | |
| JSXMLQName | |
| VCF::Kernel | |
| VCFWin32::KeyboardData | |
| VCF::KeyboardEvent | |
| VCF::KeyboardEventHandler< SOURCE_TYPE > | KeyboardEventHandler handles the following: onKeyPressed onKeyDown onKeyUp |
| 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::LinuxRunLoopPeer::PostedEvents | |
| VCF::LinuxRunLoopPeer::StopEvent | |
| VCF::LinuxRunLoopPeer::TimerInfo | |
| VCF::LinuxRunLoopPeer::TimerMap | |
| VCF::LinuxSemaphorePeer | Class LinuxSemaphorePeer |
| VCF::LinuxSystemPeer | |
| VCF::LinuxSystemToolkit | |
| VCFLinux::LinuxUtils | General purpose utility class |
| VCF::ListBoxControl | |
| VCF::ListItem | |
| VCF::ListItem::SubItem | |
| VCF::ListModel | The List model is a interface for describing what a model that implements a list of items should do |
| VCF::ListModelEvent | |
| VCF::ListModelEventHandler< SOURCE_TYPE > | ListModelEventHandler handles the following: onListModelContentsChanged onItemAdded onItemDeleted |
| 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::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::MemoryStream | A MemoryStream a stream for in memory data for both reading and writing |
| 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::MenuItemEventHandler< SOURCE_TYPE > | MenuItemEventHandler handles the following: onMenuItemClicked onMenuItemUpdate |
| 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 for a control or other visual elements |
| VCF::ModelEvent | |
| VCF::ModelEventHandler< SOURCE_TYPE > | ModelEventHandler handles the following: onModelEmptied |
| VCF::ModelValidationEventHandler< SOURCE_TYPE > | ModelValidationEventHandler handles the following: onModelValidate |
| VCF::MouseEvent | |
| VCF::MouseEventHandler< SOURCE_TYPE > | MouseEventHandler handles the following onMouseDoubleClicked onMouseClicked onMouseMove onMouseUp onMouseDown |
| VCF::MultilineTextControl | Class MultilineTextControl documentation |
| VCF::Mutex | Class Mutex documentation |
| VCF::MutexPeer | Class MutexPeer documentation |
| VCFNet::NetToolkit | |
| VCF::NoFreeMemException | |
| VCF::NoGraphicsToolkitFoundException | |
| NoImplementerFoundException | |
| VCF::NoPeerFoundException | |
| VCF::NoSuchElementException | |
| VCF::NotifyEvent | A generic event meant only to indicate some sort of "signal" has happened on the event's source instance |
| VCF::NotifyEventHandler< SOURCE_TYPE > | |
| VCF::NotImplementedException | |
| NoToolKitFoundException | |
| VCF::Object | Base class for the entire Visual Component Framework |
| VCF::ObjectWithEvents | ObjectWithEvents is an object that may have 0 or more EventHandlers associated with it, and will automatically clean up these EventHandlers when it is destroyed |
| VCF::OpenGLControl | |
| VCF::OpenGLControlContext | |
| 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::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::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::OSXRunLoopPeer::TimerInfo | |
| 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::OSXUIToolkit | |
| OSXUIUtils | |
| VCF::OSXWindow | |
| VCF::OutOfBoundsException | |
| VCF::OutputReadyEvent | |
| VCF::OutputReadyEventHandler< SOURCE_TYPE > | |
| 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::Parser | A parsing utility class, at this moment (8/25/2001) meant for internal use only |
| 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 that objects that support persistence can implement |
| 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::PointOperation | |
| 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::PostedEvent | |
| 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 | |
| PRMJTime | |
| 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::PropertyChangeEventHandler< SOURCE_TYPE > | Classes implmenting this interface MUST throw PropertyChangeException if they do not want the change to be processed |
| 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 |
| VCFRemote::Proxy | |
| VCF::PushButton | Class PushButton documentation |
| VCF::RadialGradientFill | |
| VCF::RadioButtonControl | Class RadioButtonControl documentation |
| RECharSet | |
| 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::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 | |
| VCF::RunLoopPeer | |
| VCF::RunLoopSource | |
| VCF::Runnable | A class that represents a single executable task |
| VCF::RuntimeException | |
| 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::ScrollEventHandler< SOURCE_TYPE > | |
| 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 |
| VCFNet::ServerSocketEvent | |
| VCF::ShadowFill | |
| 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 > | |
| VCFNet::Socket | |
| VCFNet::SocketEvent | |
| VCFNet::SocketEventHandler< SOURCE_TYPE > | SocketEventHandler handles: onDataReceived onClientConnected onClientDisconnected |
| VCF::SocketException | |
| VCFNet::SocketListeningLoop | |
| VCFNet::SocketObject | Socket Object represents a connected client to the listening socket |
| VCFNet::SocketPeer | |
| VCF::Splitter | Class Splitter documentation |
| VCF::StandardContainer | Basic implementation of a container handles basic alignment,layout of child components |
| VCF::StaticEventHandlerInstance< EVENT > | StaticEventHandlerInstance's are used to provide a typesafe wrapper around a specific class's static function pointers, as opposed to method pointers (which take the implicit this pointer) |
| VCF::StatusBar | Class StatusBar documentation |
| 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::TableCellClickEvent | |
| 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::TableModel | |
| VCF::TableModelEvent | |
| VCF::TableModelEventHandler< SOURCE_TYPE > | TableModelEventHandler handles the following: onChange |
| 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::TabModelEventHandler< SOURCE_TYPE > | The handler class for a TabModelEvent |
| VCF::TabPage | |
| VCF::TabState | |
| 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::TextModelEventHandler< SOURCE_TYPE > | TextModelEventHandler handles the following: onTextChanged |
| VCF::TextOperation | |
| 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::Thread | The Thread class represents a thread of execution in a process |
| VCF::ThreadEvent | |
| VCF::ThreadException | |
| VCF::ThreadManager | |
| VCF::ThreadManagerPeer | |
| VCF::ThreadPeer | Basic Thread interface to wrap native thread OS calls |
| VCF::TileManager | |
| VCF::TimeOutHandler | |
| VCF::TimeOutHandler | |
| VCF::TimerComponent | The TimerComponent is used to fire timer events |
| VCF::TimerEntry | |
| VCF::TimerEvent | Class TimerEvent documentation |
| VCF::TimerEventHandler< SOURCE_TYPE > | |
| 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::ToolTipEventHandler< SOURCE_TYPE > | ToolTipEventHandler handles the following: onToolTipRequested onToolTip |
| VCF::TransparentWindow | |
| VCF::TransparentWindowPeer | |
| VCF::TreeControl | |
| VCF::TreeItem | |
| VCF::TreeItem::SubItem | |
| VCF::TreeListControl | |
| VCF::TreeModel | |
| VCF::TreeModelEvent | |
| VCF::TreeModelEventHandler< SOURCE_TYPE > | TreeModelEventHandler handles the following: onRootNodeChanged onNodeAdded onNodeDeleted |
| VCF::TreePeer | |
| VCF::TypeCastException | |
| VCF::UIApplication | Class UIApplication documentation |
| 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::UndoRedoEventHandler< SOURCE_TYPE > | UndoRedoEventHandler handles the following: onUndoCommand onRedoCommand onStackCleared onStackChanged onExecuteCommand |
| 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::URL | The URL class wraps a string that points to some resource, either on the local filesystem or over the internet |
| VCFNet::URL | |
| VCF::URLAuthenticationEvent | |
| VCF::URLEvent | |
| VCF::URLException | |
| VCF::Regex::UTF_16LE | Regex engine for UTF-16LE text |
| VCF::UVMap | |
| VCF::ValidationEvent | |
| 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::DeferredPropertySetter | |
| VCF::VFFOutputStream | The VFFOutputStream class is used to support writing a component ( and it's child components) to a stream |
| VCF::View | |
| ViewCreator< ViewType > | |
| VCF::Waitable | |
| WebBrowserCtrl | |
| VCF::WhatsThisHelpEvent | |
| VCF::WhatsThisHelpEventHandler< SOURCE_TYPE > | WhatsThisHelpEventHandler handles the following: onControlHelpRequested |
| VCF::Win32Application | |
| VCF::Win32AppResourceBundle | |
| VCF::Win32Button | |
| VCF::Win32Clipboard | Class Win32Clipboard documentation |
| VCF::Win32ColorDialog | |
| VCF::Win32ComboBox | |
| 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::Win32CustomControl | |
| VCFNet::Win32DatagramSocketPeer | |
| VCF::Win32Dialog | |
| VCF::Win32DragDropPeer | |
| VCF::Win32DragDropPeer::COMDragSource | |
| 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::Win32LibraryPeer | |
| VCF::Win32ListBox | |
| VCF::Win32Listview | |
| VCF::Win32LocalePeer | |
| VCF::Win32MenuBar | |
| VCF::Win32MenuItem | |
| VCF::Win32MenuManagerPeer | |
| VCF::Win32MSG | |
| VCF::Win32Mutex | Class Win32Mutex documentation |
| 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::Win32ResourceBundle | |
| VCF::Win32RunLoopPeer | |
| VCF::Win32RunLoopPeer::TimerInfo | |
| VCF::Win32ScrollPeer | Class Win32ScrollPeer documentation |
| VCF::Win32SemaphorePeer | Class Win32SemaphorePeer |
| VCFNet::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::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::WindowEventHandler< SOURCE_TYPE > | WindowEventHandler handles the following: onWindowClose onWindowRestore onWindowMaximize onWindowMinimize |
| VCF::WindowPeer | |
| VCF::Wizard | A Wizard is used to disaplay a UI in a wizard dialog |
| VCF::X11Application | |
| VCF::X11Context | A Context provides the lowest level graphics interface to the native systems 2D drawing operations |
| VCF::X11Control | |
| VCF::X11ControlContext | |
| VCF::X11Cursor | |
| VCF::X11Desktop | |
| VCF::X11Dialog | |
| VCF::X11EventMsg | This class is used as a wrapper around an XEvent |
| VCF::X11Font | |
| VCF::X11GraphicsDevice | Used as a placeholder for both a Window and GC, as both are required for most X graphics calls |
| VCF::X11GraphicsToolkit | Class X11GraphicsToolkit documentation |
| VCF::X11Image | |
| VCF::X11SimpleTextControl | X11SimpleTextControl |
| VCF::X11ToolkitMsg | This class is ONLY to be used internally in this X11 implementation of the UIToolkit |
| VCF::X11UIToolkit | |
| VCF::X11Window | |
| VCF::XCBAbstractControl | |
| VCF::XCBApplicationPeer | |
| VCF::XCBApplicationResourceBundlePeer | |
| VCF::XCBContextPeer | |
| VCF::XCBContextPeer::GlyphInfo | |
| VCF::XCBControlContextPeer | |
| VCF::XCBCursorPeer | |
| VCF::XCBDesktopPeer | |
| VCF::XCBFontPeer | |
| VCF::XCBGraphicsResourceBundlePeer | |
| VCF::XCBGraphicsToolkit | Class XCBGraphicsToolkit documentation |
| 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::XCBUIToolkit | |
| VCF::XCBUIToolkit::XCBCookieInfo | |
| VCF::XCBWindowPeer | |
| VCF::XMLAttr | Class XMLAttr documentation |
| VCF::XMLNode | Class XMLNode represents a single node in a parsed XML document |
| VCF::XMLParser | |
| VCF::XMLParserEvent | Class XMLParserEvent documentation |
| VCF::XMLParserHandler< SOURCE_TYPE > | Class XMLParserHandler documentation |
| VCF::XPMLoader | |
