#include "fx.h"
/*
This is a classical programming example. Doing it graphically
using FOX is, as you see, not a whole lot more involved than
its command-line equivalent!
Note the following things:
- Each FOX application needs one (and only one) application
object (FXApp).
- Before doing anything, the application object needs to be
initialized. You need to pass argc and argv so that certain
command line arguments may be filtered out by FOX (e.g. -display).
- You need to create at least one toplevel window; in this case,
that is FXMainWindow.
- FOX widgets are nested simply by creating them in the right order.
Here, we create FXButton as a child of "main."
- A single call to FXApp::create() will create X windows for each
widget. Until calling create(), a widget exists only at the client,
and has no associated X window yet.
- Finally, FXApp::run() will start the main event loop. This will
only return when the application is done.
*/
// The entry point where the program starts running
int main(int argc,char **argv){
// Each FOX GUI program needs one, and only one, application object.
// The application objects coordinates some common stuff shared between
// all the widgets; for example, it dispatches events, keeps track of
// all the windows, and so on.
// We pass the "name" of the application, and its "vendor", the name
// and vendor are used to search the registry database (which stores
// persistent information e.g. fonts and colors).
FXApp application("Hello","FoxTest");
// Here we initialize the application. We pass the command line arguments
// because FOX may sometimes need to filter out some of the arguments.
// This opens up the display as well, and reads the registry database
// so that persistent settings are now available.
application.init(argc,argv);
// This creates the main window. We pass in the title to be displayed
// above the window, and possibly some icons for when its iconified.
// The decorations determine stuff like the borders, close buttons,
// drag handles, and so on the Window Manager is supposed to give this
// window.
FXMainWindow *main=new FXMainWindow(&application,"Hello",NULL,NULL,DECOR_ALL);
// Here we create a button. The button has a label on it, but no icon in
// this case. An '&' followed by a letter introduces a hot-key so you can
// invoke this button from the keyboard.
// The button sends an ID_QUIT message to the application object, which
// in its default implementation causes the program to quit.
new FXButton(main,"&Hello, World!",NULL,&application,FXApp::ID_QUIT);
// This "realizes" the widget tree. This is necessary because GUI's are
// a client-server system, i.e. there are actually two programs involved,
// a client (in this case, "hello world"), and a server (The X11 server or
// Windows GDI). We can build our C++ widgets but something extra is needed
// to tell the server that we want windows on the screen. Besides windows,
// there are various other resources that need to be created, such as icons,
// fonts, and so on. This call recurses through the entire widget tree and
// creates them all, insofar as it can know about them.
application.create();
// Pretty self-explanatory:- this shows the window, and places it in the
// middle of the screen.
main->show(PLACEMENT_SCREEN);
// Now, we actually run the application. This does not return until we
// quit. The function run() is a simple loop which gets events from the
// user, executes them, and then waits for the next event, and so on until
// we hit the button.
return application.run();
}