| 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 | |
| VC |
