Table of Contents
- 1.1. Features
- 1.2. Downloading the VCF
- 1.3. Required Tools
- 1.4. Installing the VCF
- 1.5. Building the VCF
- 1.5.1. VCF Tools
- 1.5.2. Building the VCF Libraries
- 126.96.36.199. Win32
- 188.8.131.52. Building with Bakefiles
- 184.108.40.206.1. The Bakefile utility
- 220.127.116.11.2. Patching of the Bakefile utility
- 18.104.22.168.3. Environment Variables
- 22.214.171.124.4. Baked Make Files
- 126.96.36.199.5. Baked Project Files
- 188.8.131.52.6. Building Examples
- 184.108.40.206.7. Using bakefiles in your own project
- 220.127.116.11.8. Regenerating makefiles and VS6 project files
- 18.104.22.168.9. All-in-1 VS6 project
- 22.214.171.124. MacOSX
- 126.96.36.199. Linux
- 1.5.3. Library Support by Compiler
- 1.6. Contributing
- 1.7. Standards
- 1.8. Bugs
- 1.9. Mailing lists
- 1.10. Forums
The VCF features an easy to use programming API and class hierarchy. Below is a list briefly describing the key features in the framework.
Modern C++ design - use of modern C++ techniques like exceptions, templates (where useful), name spaces, and heavy use of the Standard Template Library.
Modular - built across several libraries as opposed to one huge monolithic library that then becomes difficult to break apart. This means that while the VCF is incredibly powerful as a framework for writing GUI based applications, if you just want to use the core features, such as threads, file IO, and RTTI you can do so, without having dependencies on all the GUI code.
Support for Thread, Mutexes, Semaphores, Files, Streaming data, error logging, string utility functions, and other basic services. All of this is part of the FoundationKit and has no dependencies on the graphics or UI code.
Advanced RTTI features that allow for such things as dynamic object creation given a registered class name or a registered UUID string that represents the class, dynamic introspection of a given object's class and listing such data as the class name, super class, the properties of the class, member methods, and implemented interfaces.
Memory leak detection in debug mode for catching VCF::Object derived classes that have not been freed. This can be turned completely off in debug by recompiling the libraries.
Easy to use and powerful event system, suitable for console as well as GUI based applications.
Graphics classes for easily drawing on a graphics context, as well as working with images. This includes easily manipulating things like the current color, pen and brush attributes, and current transformation matrix.
A simple image-loading architecture that allows multiple formats to be registered for loading up a variety of different graphics formats. On Win32 systems the default image loading support is limited to BMP files, but by using the ImageFormats library (also a part of the VCF) a wide variety of additional image types are also supported. Currently the ImageFormats library uses FreeImage to support image types such as .TIFF, .TGA, .PSD, .PNG, .PCX, .SGI, .MNG, .RAS, .PBM, .PPM, and many others.
More advanced classes for customizing the drawing process with application defined behaviors. Advanced features also include support for anti-aliased vector graphics through the use the Anti Grain Graphics libraries.
A complete set of powerful GUI classes, including a common set of base classes enabling advanced custom control creation. Some of the control classes include tree controls, list controls, check box and radio controls, push buttons, single line and multi line text controls, and many others.
A standard set of application classes for things like resources, loading windows or forms dynamically at application startup, saving of application state, a registry class for common storage of system and application information.
Other application classes include an Undo/Redo architecture based on commands that allow for undoing and redoing commands as well as notifying other objects of the events.
GUI controls that support both alignment and anchoring. Any control may be aligned to the top, bottom, left or right of it's parent container control. Alternately controls may use their anchoring properties to anchor themselves to the left, right, top and/or bottom sides of their parent container control.
The GUI provides a set of Model and View classes for using in MVC patterns. A series of models like the ListModel, TreeModel, and TextModel are used in controls to provide separation of the data from the UI presentation code. Because a View can be dynamically attached to a Control at runtime, it will be possible to develop "themes" in the future.
Because of the RTTI features and the event handlers, the VCF easily supports component programming. Objects can easily register event handlers with other objects in the system at runtime, without knowing the specifics of each other.
As much as possible, VCF tries to be as flexible as possible, allowing you to use the parts you want, and allowing for interoperability with other frameworks. Thus VCF controls can be used inside of an MFC app if you like.
No need of special preprocessor tools - if you have a reasonably complete C++ compiler then you're all set to go.
Heavy use of the Standard Template Library throughout the VCF, as well as templates, that make up the RTTI extensions the VCF implements.
Ability to access the low level handles for most native objects. For example, by accessing the Thread's peer class, you can get a handle to the native thread handle itself. For a control, you can access the control's peer and get a handle id that represents the windowing systems native handle for a window/widget. This allows you to use platform specific calls when neccessary.