FOX toolkit
From Wikipedia, the free encyclopedia
| FOX toolkit | |
 FOX applications |
|
| Developer: | Jeroen van der Zijp,FOX community |
|---|---|
| Latest release: | 1.6 (Major stable) / February 22, 2007 |
| OS: | Cross-platform |
| Use: | Development Library |
| License: | LGPL |
| Website: | [1] |
In computing, the FOX toolkit is an open source, cross-platform widget toolkit, that is, a library of basic elements for building a graphical user interface (GUI). FOX stands for Free Objects for X.
It features a (currently hard-wired) Windows 95-style theme available for both Microsoft Windows itself as well as the X Window System (which is used on many UNIX and UNIX-like operating systems).
The FOX toolkit has been released under the GNU Lesser General Public Licence. Development began 1997 by Jeroen van der Zijp while he was affiliated at CFDRC. Since then, Jeroen van der Zijp maintains the core library and test applications, with the help of a growing user community.
The FOX toolkit is written in C++. Bindings are available for Python, Ruby and Eiffel. The FOX source code distribution supports building with many different (commercial and free) C++ compilers.
Contents |
[edit] Cross-platform Compatibility
FOX differentiates itself in the following way from other cross-platform toolkits:
- Tk is a cross-platform toolkit but does not have all of the widgets that FOX considers desirable.
- Qt has a different licensing model (which may require a commercial license in some cases where FOX will not)
- wxWidgets promotes the use of native widgets on each supported platform
- FLTK is a fast, low-footprint library that supports rapid application development, and requires less code to use, but lacks advanced widgets
Both Qt and wxWidgets have some support for programming natively on Mac OS and Mac OS X platforms, which FOX currently does not support.
FOX uses a technique similar to the Java Swing-style approach to display a graphical user interface to the screen, using only graphical primitives available on that platform, as opposed to the original Java AWT-style approach which used native widgets.
A major advantage of this canvas-based approach is that the GUI is supposed to look and behave identically on all supported platforms. Some rather consider it a disadvantage, though, as it usually means that on at least some platforms FOX application will look and feel different from other, native applications for those platforms.
One disadvantage of the Swing-style approach is that certain native platform features may not be available immediately, such as comprehensive printing support, support for anti-aliased fonts, or internationalized input handling, because they will need to be re-implemented in a cross-platform way before they can be used in FOX.
[edit] Messaging system
A major advantage of the FOX toolkit is the simplicity and clarity of the code and programming paradigm that results in a steep learning curve. It offers a bi-directional messaging system that is transparent. Each Widget sends its message to a certain target. Each message is composed by a selector that identifies its kind and an id that is unique and provided by the widget's enumeration. The advantage is that each widget can call a target widget's method in a transparent manner, even if the method does not exist. Vice versa, in the implementation of the individual message handler, since the sender is known, the target can also dispatch a message to the sender. This is a particularly important feature in component oriented software, where components may be writen by different people, or even different organizations.
The FOX messaging system simplifies the GUI update strategy: during widget update, the widgets can ask from their targets to update them. This means that a command message does not also have to explicitly update any widgets as it is typical. In case an application implements N command messages each updating M widgets, then M*N updates must be executed and at most M*N messages must be implemented. On the other hand, if widgets request for update, only N command messages and at most M update messages are implemented. This strategy separates the GUI update from data changes, making the GUI a real-time reflection of the underlying data structures.
[edit] Hello World
The following example creates a FOX application and a dialog with a button:
#include "fx.h"
int main(int argc, char *argv[]) {
FXApp application("Hello","FoxTest");
application.init(argc,argv);
FXMainWindow *main=new FXMainWindow(&application,"Hello",NULL,NULL,DECOR_ALL);
new FXButton(main,"&Hello, World!",NULL,&application,FXApp::ID_QUIT);
application.create();
main->show(PLACEMENT_SCREEN);
return application.run();
}
[edit] Software built on FOX
- ABAQUS/CAE is the pre- post- processor of the ABAQUS finite element suite.
- Intel Modular Test Architecture (IMTA)
- LinkCAD is a commercial format-conversion application for various CAD formats
- TMP Vision and SLIM were designed to meet the needs of complex FEA models.
