Class listing
-------------
This file contains the names of each class, plus a brief description of the purpose of the
class. At then end of the file is a list of functions and global variables exported by
the FXEX library.

------------------------------------------------------------------------------------------

DbControl - widget
DbField - widget
DbNavigator - widget
DbQueryDialog - widget
	Support for an in-memory database scheme, plus associated widgets.

FXALContext - adapter
FXALDevice - adapter
	Adapter classes to connect to the OpenAL audio library.
	OpenAL is a library for audio in a similar vain to OpenGL is for graphics.

FXArray - helper
	Helper include file

FXAsciiStream - stream IO
	Replaces the \n\r combination with a \n

FXAtomicDataTarget - thread variable
	Similar to a normal FXDataTarget except that the value is read from an FXAtomic type
	rather than an int/double/etc.  This allows the GUI to read thread-based data
	without the programmer needing to provide any other glue logic.

FXAtomic - thread variable
	Thread-safe data types, such as FXAtomicInt, FXAtomicFloat, FXAtomicString, etc.
	Reading/writing to variables, is handled atomically.  (This allows the
	FXAtomicDataTarget to update GUI state, from values in another thread.)

FXBackBufferedCanvas - widget
	Allows you to draw into the back buffer, then blit the buffer onto the screen

FXBarrier - thread synchronisation
	Provides facility to synchronise the execution of multiple threads.  Generates
	FOX messages on important events.

FXBaseObject - base class
	A base class for utility classes to inherit from (its parent is FXObject).
	Implements app, target and message handling/serialisation/etc

FXBinaryLogger - log file
	Class for high-speed, low-disk-usage, application logging.  Normllay you would
	sub-class this, an provide the enumeration constants for the log values.

FXBinaryLogReader - log file
	Supporting class for reading the files generated with the FXBinaryLogger class.
	You can sub-class this, to read the enumerated values, then convert them to
	meaningful text.  Alternatively you could use the BinaryLogReader program to
	configure the text strings for the corresponding enumeration.

FXBufferedStream - stream IO
	This just buffers a stream!  Set your stream buffer size, so that your stream
	auto-flushes to the underlying stream.

	eg:  FXStream *s = new FXBufferedStream( new FXFileStream, ... );

	Stream decorators can inherit from this to decorate the stream with functionality
	ie see below FXBzipStream

FXBzipStream - stream IO
	Implements BZip de/compression on the incoming/outgoing stream.  The cool thing here
	is that the compression works on all stream types (memory, file, socket, etc),
	and that the compression happens when either, the buffer is full, or when the app
	calls flush on the buffered stream.

	eg: FXStream *s = new FXBufferedStream(new FXBzipStream(new FXSocketStream()))

	Note: compression is only done in-memory, on a specific buffer size.  This is an
	      artifact of the Bzip algorithm - it cant do finite-time compression - which
	      basically means that the application should really know how much data it
	      wants to compress _before_ writing to the stream.  This aint so bad - you
	      just let the internal buffer fill up, or call flush()...

FXCalendar - widget
	A calendar widget which allows the selections of a date

FXCheckList - widget
	A check box list widget?

FXCheckTreeList - widget
	A check box tree widget?

FXClockButton - widget
	A digital clock which generates events when clicked on.  Currently not scalable
	without custom FXFont handling.  Shows a date string as an FXTooltip.

FXClockDialog - dialog
	Simple dialog which alters the appearance of the FXClockButton widget

FXComboBoxEx
	Same as an FXComboBox, but uses an FXIconList rather than an FXList, so that the
	list appears with little icons beside the entries.

FXCondition - thread synchronisaiton
	Condition variable, which piggy backs on the FOX event mechanism.
	Generates FOX messages on important conditions.

FXDaemonApp - daemon
	A replacement for FXApp when you just want a daemon process

FXDaemon - daemon
	The base class that all daemon processes derive from.

FXDateTime
	This is a namespace for "time/date" routines, such as transposing times for localtime,
	current time, time strings.

	This replaces and enhances some functionality currently found in FOX's FXFile namespace.
	I'm not sure why the FX::FXFile namespace has time commands in them, just
	because FXFile methods return FXTime data...

FXDCHelper - drawing
	Helper routines for drawing onto a DC.

FXDCNativePrinter - drawing
	Native printer support for Win32

FXDLL - library loader
	Dynamically load a library...

FXExplorer - widget
	An enhanced implementation of FXFileList

FXExtendedException - extras
	More exception types; to allow users to throw more specific exceptions

FXExTreeItem - widget
	Tree items for FXExTreeList

FXExTreeList - widget
	A different implement of an FXTreeList...?

FXFastMutex - thread synchronisation
	Non-recursive, non-error checked mutex.

FXFileDialogEx - file IO - Win32
	A wrapper around the existing FXFileDialog to use the native WIN32 FileDialog
	so that the application can get access to the "Network Neighborhood" feature.

FXFileIO - file IO
	Interface for acces files on disk.
	Supports seeking around a file.
	Supports read and write locking
	Memory mapping of file
	64bit file size support (if possible)

FXFileMonitor - file IO
	Monitor the activity of a file, via FOX messages.

FXGarbageCollector
	Automatically destroy objects on program exit.

FXGzipStream - stream IO
	Implements Gzip compression similar to FXBzipStream.

FXHistoryItems - widget
	General purpose history list tranversal menu widget

FXHistoryList - widget
	Implements a history list that can be branched eg. an UndoList or URL list

FXInterlock - thread synchronisation
	Base class for sequenced events.

FXIOHandle - general purpose IO - Unix
	Abstract class for handling IO...

FXIOStream - stream IO
	Base class to support event driven streams.

FXJulianDate - date/time
	General purpose julian date class

FXLCDClock - widget
	A scalable LCD looking clock widget

FXLCDLabel - widget
	Implements an LCD looking text widget using 'seven segment' digits

FXLCDSymbol - widget
	A little marker widget for the LCD clock (ie one of :.- )

FXLockable - thread synchronisation
	Base class for lockable object.

FXLogger - log file - Unix, Win32
	Used for application logging (hint: good for debugging)

FXMutex - thread synchronisation
	mutual exclusion object

FXNetworkDialogEx - widget
	umm...

FXNetworkListEx - widget
	umm...

FXNetworkSelectorEx - widget
	umm...

FXNullMutex - thread synchronisation
	Simulate a real mutex, for cases when you are trying to debug a multithreaded app.
	You can convert the app to use a single thread.  Essentially just provides the
	lock/unlock API.

FXNullThread - threads
	Simulate a running thread, using the FOX addChore functionality.  This allow you to
	debug multi-thread apps, without needing to use multiple threads.

FXObjectLoader - dynamic loader
	Load a FOX object from a file/dll.

FXPaneHeader - widget
	This is a widget which takes a text label describing the pane.
	It contains a close button, which hides the pane. Probably could be extended a bit...
	Look at MS explorer's tree pane for an example.

FXProcess - process manager - Win32
	Used to communicate with child processes via stdin/stdout/stderr
	FIXME: there is also an FXProcess in the contrib directory - still to be looked into

FXRecentItems - widget
	Implements a 'most recently used items first' list menu widget

FXRegionHelper - drawing
	Helper routines for defined regions.

FXRotatableFont - drawing
	Draws text at an angle, rather that horizontally.

FXRunnable - threads
	Base class for the thread class

FXSerialPort - serial port access
	Interface to the serial port hardware

FXSettingsDataTarget - data target
	A data target which directly accesses an FXSettings database so that the app
	doesn't need to connect the data target to some application variable.  This is
	useful when you want to use an application registry variable.

FXSevenSegment - widget
	Implements a seven segment display, like those found on lots of LCD displays

FXSocketClient
	You can connect to an Internet or Unix domain socket.

FXSocket - socket IO
	A socket class!  Actually not that useful on its own, unless you already have a
	file descriptor / FXInputHandle, in which case you can read data from a socket...
	It even supports reading the data as a text string - what a bonus!
	The socket class generates SEL_XXX events when data is to be read, which makes
	implementing socket handling next to trivial.

FXSocketServer
	Sets up a socket ready to accept incoming connections (Unix or Internet domain).
	The connections are managed by the server object.
	Any incoming data generates SEL_XXX events which the app can handle.
	Connections can be denied by handling the SEL_CLOSE event.

FXSocketStream - stream IO
	Provides socket stream functionality, when used in conjunction with an FXSocket.

FXSplashWindow - dialog
	A dialog (normally) used upon application startup, to annoy the user! What joy...

FXSpriteArc - widget
	An arc widget to be used with FXSpriteCanvas

FXSpriteArcText - widget
	An arc with text widget to be used with FXSpriteCanvas

FXSpriteBox - widget
	A box widget to be used with FXSpriteCanvas

FXSpriteBoxText - widget
	A box with text widget to be used with FXSpriteCanvas

FXSpriteCanvas - widget
	A canvas for sprite manipulation.  Includes sprite classes for text, polygon,
	images, boxes, etc - check it out, the FOX implementation of the classic game
	'Breakout' was created with this...

FXSpriteImage - widget
	An image widget to be used with FXSpriteCanvas

FXSpriteLayer - widget
	Each widget can specify a layer to be situated on so that can appear in front
	or behind other objects

FXSpriteLine - widget
	An line widget to be used with FXSpriteCanvas

FXSpriteObject - widget
	Base class for widget which are going to use the FXSpriteCanvas

FXSpritePolygon - widget
	An polygon widget to be used with FXSpriteCanvas

FXSpriteText - widget
	A text widget to be used with FXSpriteCanvas

FXStringTokenizer
	Provides 'string token'ization functionality.  Split a string into parts as defined
	by the seperators.  Uses a hasNext/hasPrev and next/prev API.

FXSynchronise - thread synchronisation
	Provides serialised access to a piece of code (when used in conjunction with a class
	mutex).

FXSystemLogger - syslog
	Logs messages to the OS logging facility, such as syslog.

FXTableBox - widget
	A table box widget?

FXTextVScroller - widget
	Automatically vertically scroll a text widget; can be used for showing 'credits'.

FXThreadedObject - threads
	Base class of a threaded object which can communicate using FOX messages.

FXThreadEvent - threads
	Used internally to communicate from a worker thread to the main thread.

FXThreadFunction - threads
	Execute a function call in a worker thread

FXThread - threads
	Execute code in a worker thread.  Derive fro mthis class, then implement the 'run'
	method.

FXThreadManager - threads
	Used to manipulate worker threads.  Can be used to manage a 'pool of threads'.

FXTicker - widget
	Horizontally scroll some text, left or right.

FXToolbarButton - widget
	A button which supports the notion that the text label can be hidden (by sending
	it an event), such as those found on MS Explorer. It also has a drop button for
	displaying an FXPopup

FXTreeEditor - widget
	Edits a tree item 'in tree'

FXTreeListEx - widget
	A tree list which supports the FXTreeEditor widget

FXVtkWindow - adapter
	An adapter class for connecting FOX to the Vtk (visualisation) library.

FXWaitable - widget
	A base class for thread objects which can enter a wait state.  Binds to a thread
	manager so as to allow the main thread to wake the object out of the wait state.
	Sends FOX messages to the main thread for interesting events.

FXWizardDialog - widget
	A dialog which implements standard 'wizard' dialog navigation functionality.

FXWizardPage - widget
	Implements generic functionality for taking part in a FXWizardDialog.

FXXmlParser - XML
	Absorbs the FOX tag messages, as generated by the FXXmlreader class, transposing
	the content as appropriate. ie translates the &...; strings into the correct symbol,
	removing whitespace, etc.

FXXmlReader - XML
	Reads a stream, generating events for each matching pair of braces. eg <tag>


Exported Functions / Constants / Variables
------------------------------------------
void saveEndianness(FXStream& store)
	save the machine dependant endianness value to the stream

void loadEndianness(FXStream& store)
	load the machine dependant endianness value from the stream,
	and setup stream to swap the bytes if the stream byte order
	is non-native to the CPU architecture

FXuint fxrandomseed()
	create a random seed for use with fxrandom
	it is based on the current time, so its a _reasonably_ random seed

FXint fxrand(FXint upperBound,FXint lowerBound=0)
FXfloat fxrand(FXfloat upperBound,FXfloat lowerBound=0.0);
	a useful function call for generating random numbers
	generate an integer/float number in the set [lowerBound,upperBound)

void setFontOfChildren(FXComposite* w,FXFont* f)
	set the font of all children

FXuint fxfilemode(FXFilePermission permissions)
	set the flags appropriately for the platform

FXbool loadFileImage(const FXString& file,FXImage *img)
	load image data from a file

FXbool loadFileIcon(const FXString& file,FXIcon *ico)
	load icon data from a file

FXImage* loadImage(const FXString& file)
	load an image from a file, based on file extension; return an FXImage.
	... dont forget to delete the image, when finished with...

FXIcon* loadIcon(const FXString& file)
	load an icon from a file, based on file extension; return an FXIcon
	... dont forget to delete the icon, when finished with...

FXEXTERN
	handle 'extern' correctly depending if we are compiling for Win32 DLL.

endl
	insert a 'newline' character at the current position eg \n, \n\r. 

COMPRESS_MAX
COMPRESS_NORMAL
COMPRESS_FAST
COMPRESS_NONE
	Compression factors to be used with the BZip and GZip classes.

MKUSHORT
	make a 'short int' from two 'char's

MKULONG
	make a 'long int' from two 'int's

FXDeclare(Class)
FXDeclareAbstract(Class)
FXDefMap(Class)
FXImplementAbstract(Class,Parent)
FXImplement(Class,Parent)
FXFuncDecl(Func)
FXFuncImpl(Class,Func,tgt,sel,ptr)
FXMapTypes(Class,FromType,ToType,Func)
FXMapType(Class,SelType,Func)
FXMapFuncs(Class,SelType,FromId,ToId,Func)
FXMapFunc(Class,SelType,Id,Func)
	Alternative forms of the FOX macros; these provide syntactic sugar to your code
		to make it easier to read.

FXSEND(tgt,sel,msg,ptr)
FXROUTE(src,tgt,sel,msg,ptr)
	Alternative mechanism for generating a FOX event; sometimes these names make
		more sense in the context of the code

FXCTOR()
FXMETHOD(methodname)
FXDTOR()
	Alternative methods for generating FXTRACE statements.

INVALID_HANDLE
	Used to define the status of an invalid file descriptor / Win32 HANDLE.

fxexversion
	Global array variable containing the current FXEX version number.

