12th July 2007: TnFOX v0.87 is finally out after some sixteen months since the v0.86 release (sorry!). New features include:

• FOX v1.4.35 and FOX v1.6.28 merged.
• 2D and 3D graphing support of arbitrary datasets rendered using OpenGL along with official Visualisation Toolkit (VTK) support.
• Modular building support. You can now build separate no-GUI, SQL database and Graphing sublibraries. You can also toggle whether large proportions of FOX and TnFOX are compiled into your library or not, making for a very slimline standalone executables if you so choose.
• Added child process device i/o class QChildProcess. You can now redirect i/o and manage child processes on all supported platforms.
• An automated test suite now can perform full regression testing on all supported platforms. It stores its results inside a SQLite3 database and can output the database in HTML format (as you can see on the TnFOX website).
• TnFOX is now completely portable to any architecture (not just Intel based ones).
• Fixed stack backtracing on exception throw for Windows (which had become broken thanks to Microsoft) and added support for stack backtracing on Linux via glibc.
• Even more performance increases. Tn now runs on Linux slightly faster than Windows!
• Lots of bugs (some major) fixed.
  
• New platforms now officially supported: Apple Mac OS X (using Apple's X11 server), CoLinux and Microsoft Windows Vista. TnFOX is fully & officially supported on all 32 bit and 64 bit platforms.

Note that the v1.4 based branch will be dropped from this release onwards - only v1.6 or later shall be used in subsequent TnFOX releases. Anyone still using the v1.4 (non-Unicode) branch will need to upgrade.

FreeBSD precompiled binaries have not been provided this time round due to a (current) lack of a FreeBSD installation. There is no reason why it shouldn't compile and run.

The Python bindings have been much improved since the last release, but still aren't quite there (hence not supplying binaries). I am afraid that they are not a high priority for me currently, but I hope to get back to them relatively soon. I have a new computer whose extra power should greatly ease compiling & debugging them.

3rd April 2006: A year and two months later, the second STABLE release of TnFOX is out! Much of the long wait has been for FOX v1.6 STABLE to be released, and this version, v0.86 of TnFOX, comes in two flavours - v1.4.32 FOX based and v1.6.1 FOX based. I have spent the last week in testing and adding minor new features - I don't want a repeat of the embarrassing failure of v0.85 to work on Linux (fixing that was the first thing I committed to SVN)! Just to make absolutely sure it works on all platforms, this release comes with a TnFOX enhanced version of Adie, the FOX text editor of which precompiled binaries are provided.

Major new functionality in this release includes:

• Substantial speed improvements, especially multi-processor scalability improvements and even further optimisations for x64 architectures.
• Nanosecond accurate timers. Handy for timing short running code.
• x64 architecture support for Windows, Linux and FreeBSD.
• New GUI class FXHandedMsgBox, which supersedes FXMessageBox.
• QSSLDevice can now mix reads & writes and permits random access.
• All Qt-compatible classes are now prefixed with Q instead of FX. This was required as newer versions of FOX were calling classes the same names.
• FXTime is now a microsecond accurate count, and understands timezones. File metadata functions now work with host OS native resolution rather than to the nearest second.
• Non-GUI builds of TnFOX are now possible. Precompiled binaries are provided.
• SQL database support, including drivers for SQLite3 and via-IPC remote access. The way this feature integrates the SQL and C++ type systems by metaprogramming I just think is very, very cool! A copy of SQLite3 is bundled in with the library which has bulked up the binary a bit (you can always disable it).
• Portable windows shell link file support. This lets you read and write Windows format shell links even on Linux as though they were symbolic links. Tested on win2k and winxp (the shell link file format differs on each).
• Portable NTFS junction support. NTFS junctions now appear as symbolic links to TnFOX based code so your Unix code will work with them just fine. You can also create and delete NTFS junctions.
• ptmalloc2 has been replaced with nedmalloc, a superior malloc implementation. nedmalloc is currently the fastest (in real world code) memory allocator on Windows, Linux and FreeBSD at least - it even beats Hoard and tcmalloc in my real world tests and scales excellently with extra processors.
• Build support for msvc8 (Visual Studio .NET 2005) and GCC v4.1
• Thread processor affinity support where the host OS provides support.
• Transparent BZip2 file support
• UDP support in QBlkSocket
• Unicode support (on v1.6 FOX based versions only)
• Automatic UTF text translation support permitting transparent reading and writing of UTF16LE, UTF16BE, UTF32LE and UTF32BE (on v1.6 FOX based versions only)
• And many, many bug fixes

As v1.6 of FOX breaks Latin1 support, a v1.4.32 FOX based version of TnFOX remains available. The python bindings which were previously based on pyste are now based on pyplusplus and due to continuing teething problems with this very new tool, no python bindings come with this release. This should get fixed pretty soon. Enjoy!

22nd February 2006: Snapshot Five of v0.86 is out. See ChangeLog below. This is the one many of you have been waiting for, and finally a chance to run your code on the very latest FOX release!

The single biggest change from snapshot four is the merging of FOX v1.6.0 RC3. This is a highly experimental build, so expect breakages even though the test suite and adie work perfectly. Furthermore, the python bindings have not been included in this snapshot as they need substantial upgrading to support all the new API's. Also, as v0.86 release will use pyplusplus instead of pyste, so a whole new set of (much improved) bindings will be provided.

Any feedback on this experimental build would be much appreciated (post to the tnfox discussion mailing list). You may find the new "FOX compatibility layer" option inside config.py useful for compiling your existing code without changing too much.

Enjoy!

2nd January 2006: Snapshot Four of v0.86 is out. See ChangeLog below. I really must apologise for v0.86 itself not being released, but we are waiting on FOX v1.6 to be released and that just keeps on getting later and later. However, on the upside, you should have a shiny new set of python bindings based on pyplusplus which are far superior in quality to the old pyste based ones.

Other changes since snapshot 3 include full SQL database support with two embedded drivers for SQLite3 and accessing a remote SQL database via an IPC transport. This SQL database support uses heavy amounts of metaprogramming and makes usage especially easy with automatic C++ object to BLOB SQL type conversions. Some important speed tweaks were made yielding yet another 30% increase in Tn benchmarks. TnFOX can now be built without a GUI - this is intended for the Tn kernel as it runs as a daemon, but it's useful to others too. TnFOX applications now look identical on X11 as Windows if the right fonts are installed. TnFOX can now manipulate Windows shell link files even from Unix (by reverse engineering) and now understands NTFS junction points. You can now use one series of code to handle whatever symbolic link support is available on whichever platform.

In build support, there is now full support for MSVC 8.0 RTM as well as newer GCC's and FreeBSD 6.0. A new superior memory allocator called nedmalloc has replaced ptmalloc2 in TnFOX. There are also lots of other small improvements and bug fixes. Enjoy!

27th July 2005: Snapshot Three of v0.86 is out. See ChangeLog below. This release will break ALL code written for previous versions but it is easy to fix via file find & replace.

12th June 2005: You may be interested to know that the Python bindings for TnFOX are now complete and code from FXPy can be ported to them with a few changes. Note that despite being now complete, they still need bugs ironed out of them. You can get the improved Python bindings from SVN (see bottom of page).

14th May 2005: Snapshot Two of v0.86 is out. See ChangeLog below. The major new feature of this snapshot is x64 support for all supported platforms.

11th March 2005: Snapshot One of v0.86 is out. See ChangeLog below.

13th February 2005: It's been a year in coming, but finally the first STABLE release of TnFOX has been made! The decision to do this was an easy one, Tn is now finally testing most parts of TnFOX in real-world production code and the finding of bugs rate has dropped enormously in recent months. One can see the evidence of this maturity in the TnFOX completedness table on its homepage where green has become the prevalent colour!

Major new functionality this release includes:

• SMP and non-SMP builds. If a non-SMP build is chosen, TnFOX uses far faster FXAtomicInt primitive implementation at assembler level resulting in some serious performance increases for uniprocessor machines (between 48% and 106%). Of course, such a binary will not work on SMP machines.
• More optimisations in various places such as FXMutex, QDictBase etc.
• Rewrote the nested exception handling framework. It works now, honest! :)
• Fleshed out loads of little API's here and there.
• Added FreeBSD v5.3 and RedHat Fedora Core 3 support along with support for 64 bit architectures.
• As per user request, modified FXScrollBar to use 64 bit ranges.
• Merged FOX v1.4.1 and updated python bindings to use Boost v1.3.2.

So obviously, not a lot of new features - it's mostly bug fixes. From now on it is intended that TnFOX will mirror FOX stable releases, if one wants a newer version in between then there is always SVN access which has proved very popular. The biggest thing coming in the next version of TnFOX is improved FreeBSD support - right now performance is substantially lower than either Linux or Windows and considerably less consistent, hence for now TnFOX remains of BETA quality on FreeBSD. Much of this is because FreeBSD 5.x has only very recently become stable itself, but as it's the primary development platform for Tn on POSIX I'm expecting it to improve in quality substantially during the next few months.

15th December 2004: TnFOX SVN now has FOX v1.3.20 merged into it. It's as good as v0.85 as I have time to make it currently. Merry Christmas and a Happy New Year!

12th July 2004: This is a big release for the third beta release of TnFOX. As would be expected in over three months of testing, a huge number of bugs have been fixed but furthermore features have been tweaked for easier usage, small new features added and some optimisation done on certain classes now that they are mature. The TnFOX homepage now contains a table showing the completedness of each of the TnFOX extension classes.

I'll only list new features here:

• FOX v1.2.4 merged and FXString has been fully TnFOX-ised and now throws an exception if memory is not available for the string.
• Lots of default constructors added to classes which didn't have them. Many other small API tweaks here and there.
• FXIPCChannel is now mature having been very extensively tested and hand optimised:- New message routing facilities have been added and messages can now be tunnelled from one channel to another even ones unknown to the bridge; Messages now self-optimise endian conversion automatically; Extra robustness features are now present to allow FXIPCChannel to be attacked maliciously. Testing shows that FXIPCChannel is substantially faster than CORBA (OmniOrb).
• All QDictBase subclasses can now have their table size be dynamically adjusted according to runtime factors by QDICTDYNRESIZE.
• FXThreadPool now works, having been unintentionally completely broken in previous versions. It's also mature and hand optimised.
• Generic::instantiateH has been reimplemented - it now causes less compiler slowdown and is much faster to compile. All metaprogramming tools can now take up to four variable parameters.
• Build system has been much enhanced:- Whole Program Optimisation supported for compilers which have it (MSVC, ICC); Due to user request, build system can now always generate a static library; MSVC and ICC optimisation options have been hand tuned for performance.
• Full support for GCC v3.5 upcoming symbol visibility extension added - now all private classes are marked as such, substantially improving generated code quality.
• Linux kernel 2.6 support added. Kernel 2.6.6 is noticeably faster and less memory hungry than 2.4 which is good because 2.6.5 was slow and had broken shared memory too. All Linux precompiled binaries are now for RedHat Fedora Core 2.
• Substantial improvements to the custom memory pool infrastructure, including a new port of ptmalloc2 from glibc v2.3.3. Threads can now set a "current heap" which prevents remote resource depletion attacks. This infrastructure is now mature and hand optimised.
• Threading support is now mature and hand optimised. In particular, all operations involving a FXMutex are now as efficient as it's humanly possible to make it.
• Lastly, unfortunately the python bindings library on POSIX still doesn't work fully - any exceptions thrown by the library (eg; when python raises an exception) lose their typeinfo should they exit that shared object and thus fail to match any catch handler. This may be a long-standing bug in GCC/GNU ld/Linux (http://sources.redhat.com/ml/libc-alpha/2002-05/msg00222.html) or indeed, it may not. Let's hope I can find a solution by next release - v0.80 is actually a whole seven days late just from investigating this one issue :(

A few more words on FXIPCChannel performance - on my machine (dual Athlon 1700 running Win2k), I can sustain the following figures for operations across two IPC channels across pipes with a tunnel on the remote end:

Ops per sec: 29770 asynchronous, 5306 synchronous.

Multiply the first by two and the second by four to roughly calculate ops/sec across a single connection. Pipes are known to be much slower on Win2k than Linux.

With sockets: 12981 asynchronous, 3018 synchronous. With sockets and 128 bit AES encryption: 5633 asynchronous, 1469 synchronous.

All these figures can be improved upon again with Profile Guided Optimisation (ICC, the upcoming MSVC8) or even simply symbol ordering within the binary to improve cache locality.

9th April 2004: This release was ready on the 1st, but persistent problems with the TnFOX python bindings on POSIX kept being found and with the six hour rebuild time it's a long debug cycle - also, I really had to patch GCC to enable the TnFOX Python bindings to be at all useable (patch is now submitted for inclusion into GCC v3.5). However, with this release we at least now have partially working bindings on POSIX - and while I was at it, I added v1.31 Boost support plus now the latest BPL indexing suite from CVS is supported. However what made it realistically possible was that GCC v3.4 from CVS is now mature enough - which I had been waiting for - and on my machine at least the full bindings can be compiled inside seven hours (less than two with precompiled headers enabled). I am therefore pleased to be able to offer a prebuilt binary for Linux with this release.

As I've been finishing up Tn's user authentication support, the security facilities of TnFOX are now well tested and many bugs have been fixed plus small bits of new functionality added to round things out (eg; inheritable ACL's, user password checking). Optimisations have been made eg; FXFile now uses native Win32 calls, language translations are faster and SGI's FAM library is now used to implement FXFSMonitor on POSIX. The latter was done primarily as part of the new code enabling FreeBSD support with several key bits of code rewritten to use FreeBSD's native facilities, making matters on that platform often more efficient than on Linux. I am also pleased to be able to offer prebuilt binaries for FreeBSD 5.x too.

As the second beta release of TnFOX, I believe substantial improvement has been made. My thanks to Mykhaylo Sorochan for helping with the FreeBSD testing. Linux & FreeBSD binaries are still building at the time of writing, they shall be uploaded shortly.

9th March 2004: I was in two minds whether to do a release now as the real debugging effort is only just beginning and I'm sure there are many bugs yet to be found. However similarly, many bugs have been fixed and small but important bits of new functionality added, so I thought it best. This marks the first beta release of TnFOX and it also includes wider compiler support (with GCC v3.4 from CVS and Intel's C++ compiler v8).

There have been loads of bugs fixed, some new functional metaprogramming constructs like Generic::filter, Generic::apply, Generic::replicate, Generic::MapBools and Generic::dynamicAt (this is particularly cool, it assembles a const jump table at compile time making run time code about four instructions). Small screen support has been added, see the TnFOX website for example screenshots. User handed orientated interfaces just got easier with the new FXHandedInterfaceI base class which also can collapse its button well if the window gets too small. The old FOX problem of timers and chores not firing during a modal loop has also been fixed. IPC messaging has been the most tested thus far, so there are some API changes, FXBlkSocket::waitForConnection() now thread cancels correctly as well as now being able to timeout. FXPipe now supports deep pipes and FXIODeviceS can now wait on multiple FXIODeviceS instances for more data to arrive. FOX v1.1.48 has been folded in. Lastly the problem of page locking on Linux has been partially fixed, if you run your process with suid root then TnFOX realises and appropriately adjusts itself and the filing system access uid & gid to be as secure as possible.

Hereonafter will come point releases which probably won't have the python bindings nor the latest FOX updates - this is because it costs a few hours to do these things, and right now I'm wanting to push on with the Tn kernel namespace code which is at the heart of Tn as fast as possible.

7th February 2004: Well, after eight months of work I'm finally finished all the functionality I had in mind so now I can start Tn! (some of which is now in the TestSuite directory). There's loads of goodies this release, one or two of which made their way back into FOX itself. There will be no more significant new features from now on, only bug fixes as we drive through the beta period towards becoming a mature library.

More bugs have been fixed this release than in any other, I spent three days testing and while there's still two tests which partially fail on Linux, it's not too important. FXCursor now supports 32 bit alpha cursors and TnFOX's TestCursor shows portable, animated dynamically created full colour cursors in action. We now have the promised Inter Process Communication framework which is highly efficient with perhaps only a 15-25% overhead despite being able to transport arbitrary C++ object instances from A to B. The channel is multiplexable, allowing multiple protocols to coexist over the same transmission medium and it also has optional zlib compression for low bandwidth connections (eg; my 33k modem).

Another major new feature also promised since the start is per-thread event loops allowing multiple threads to operate multiple FOX window trees concurrently. It is very easy to upgrade your code to use this as each thread maintains a totally separate GUI environment so unless you write static data, you would need no code modifications.

I found out that you can't define operator new in a namespace according to the ISO C++ standard - despite GCC and MSVC happily accepting the code, GCC was screwing up when it got called which was causing the previous segfaults. I've reworked the secure heap while adding zeroing on any exit plus locking its pages in memory so that it now works perfectly on GCC and thus Linux.

More dynamism has been added to TnFOX with a real-time memory load indicator which correctly causes caches and thread pools to automatically shrink in low memory situations plus now programs can know the handedness of the user as so to place dialog buttons correctly. In fact the new FXPrimaryButton automatically places itself to the left and right appropriately and in future versions disability support will enable special semantics for this kind of button.

Lots more debugging tools have been added with a fatal exit upcall (ie; if a segfault or general protection fault happens), data dumping functions, improved error code to message decoding (I typed many in manually) and alternate mutex behaviour. FXRefedObject has been completely rewritten (again) to use a totally generic design based on Generic::ptr and it's likely nearly finished - reference counted objects are now easy! In combination with the new Qt-compatible FXLRUCache, it's easy to maintain a least recently used deletion cache of any arbitrary object, most especially FXRefedObject's.

FXIODevice and all file-type i/o devices now have read and write functions which don't need nor alter the current file position, thus easing multiple concurrent thread use plus substantially increasing efficiency for the memory mapped i/o device (as memory copies don't need a current file pointer). All file-type i/o devices now support the IO_ShredTruncate flag which causes any truncated data to be securely shredded, thus preventing leakage of secrets. The only thing remaining to make TnFOX as secure as it can be is root semantics for POSIX as memory page locking cannot be performed as a user (next version).

The new FXMemoryPool is a dynamic allocator based on ptmalloc2, the standard allocator in glibc. I ported this to Win32 and its performance so totally smashed the Win32 dynamic allocator that I've replaced the global operator new and delete for TnFOX with it (on win32 only of course)! FXMemoryPool lets you create arbitrary custom memory pools which let your classes save on fragmenting the process heap, greatly speed mass deallocations and improve multithreaded performance too! The secure heap is in fact implemented as a FXMemoryPool.

The documentation has been greatly enhanced with a new categorised class list, clarified descriptions and extra examples. See for yourself at http://tnfox.sourceforge.net/TnFOX/html/

Lastly, I also fixed namespace problems caused by FOX using namespaces wrong across all the FOX sources, added serialisation with FXApp to FXSettings and a few other places, enabled by default the alpha Xft2 support for anti-aliased fonts, added FXDataTargetI a generic container combined with FOX data target and added the new SEL_APPLY message type which reflects Tn dialog apply semantics. Enjoy!

24th December 2003: v0.5 released. This is in fact the penultimate release of TnFOX alphas as v0.6 will contain the last lot of major new code and my apologies for the remainder of this release actually appearing on the 27th - some friends turned up mid-upload. This release has been very much centred around filling in the gaps so to speak and because the new features build on old ones, a particularly large number of bugs have been fixed (including all memory leaks known). I also took the opportunity to improve on hashing, memory use and removed some hard limits in previous versions.

The generic tools library now has generic functors and bound functors which are used throughout TnFOX now - all callback style code is gone. You can also instantiate a typelist into a container which is very powerful plus we now have a policy driven Alexandrescu-style smart pointer. This unfortunately causes yet more problems with GCC but I've submitted the bug reports.

There are more extensions to the QTL, including QPtrVector, QStringList and QFileInfoList plus a generic policy driven list sort algorithm which easily outperforms ANSI qsort() never mind being far more flexible. Qt compatibility is further enhanced with API compatible FXFileInfo and FXDir.

Improved host OS facilities include FXThreadPool (with timed dispatches as well as instant) and FXFSMonitor, the latter allowing infinite monitoring of filesystem paths for changes. Security gets another boost with FXACL & FXACLEntity which provide Access Control List based security for Windows NT and SE-Linux with a reasonable emulation for POSIX - all FXIODevice's now permit reading of device permissions and most permit setting. There is no longer any technical reason why TnFOX based code can't run as a NT service.

Python support is now more or less finished with FXPythonInterp completely rewritten. You can now embed python into your C++ /extremely/ easily in the form of mini-scripts or even just manipulate python variables directly from C++. You can also run multiple interpreters and multiple threads within those interpreters with remarkable ease - it's all abstracted away and taken care of for you. Lastly, the old problem of FOX GUI sort functions now has a very useable workaround based on some particularly heinous template code :)

Unfortunately the namespace scoping bug of GCC v3.2 is also present in v3.3.2 and there's also a problem with GCC ignoring templated friends with that release. v3.4 CVS is just not ready yet with issues concerning building the stdc++ as well as linking against it. Hence once again no binaries will be provided for Linux as you get a segmentation fault on process exit.

Next version will see the IPC messaging classes imported from Tornado - however I'll be reworking them to use thread pools and a finite state machine so the performance problems when you created a data stream in Tornado (it took half a second) caused by deeply recursing message handlers goes away. I also need to tackle FXCursor with a full colour & animated replacement so Tornado's funky hourglass code can be ported. And after that, it will be betas only! Happy Christmas!

9th November 2003: v0.4 released. Wow, can't believe it's really been three and a half months (15 weeks) since the last release! The reason has been python support which has proved extremely difficult & frustrating to complete. However, almost all of the horse work is done and once pyste in Boost.Python is fixed, the solution is complete (if a little untested currently).

I estimate that around 750 hours has gone into this release which is not an insignificant portion of one's overall lifespan! However what TnFOX now has is a world-class set of python bindings which self-generate (so I can keep up with development drops of FOX easily) plus are extremely easy to extend and encompass any other code. The framework for this is totally generic - you just write some return policies once-off plus a few patches to work around unsupported areas, and the rest is taken care of for you. In combination with BPL, classes such as FXPython and FXPythonInterp allow you to easily embed python into your applications or indeed be embedded into a python application (or any mixture of the two, including running multiple interpreters and next release, threads).

Another major area of update for TnFOX is security - TnFOX now boasts a generic strong encryption i/o device called FXSSLDevice capable of transparently encrypting any other i/o device, whether file or communication. For communication type devices, the full v2 & v3 auto-negotiated SSL protocol is used plus TLS. Public keys (RSA) and symmetric keys (Blowfish or AES) can be loaded and stored to disc or transmitted over a secure link. X509 PEM translation support is provided for interoperability. When combined with a secure C++ namespace plus a portable high-quality entropy gatherer (FX::Secure::Randomness), TnFOX makes adding strong encryption both easy and secure.

The last major area of update is a generic meta-programming library (in FX::Generic) providing basic compile-time logic and introspection facilities, including typelists, type traits and custom user-definable traits. Addition of this unfortunately means support for MSVC6 and GCC v3.2 can no longer be provided.

TnFOX has finally done away with makefiles and anything like them - it now uses scons which is a much superior replacement, not least because there is now a unified environment across all platforms which autodetects what's available and disables what's not needed.

Lastly, several major bugs were fixed which actually caused the last release to terminate if an exception was thrown (whoops!). Since no one has downloaded TnFOX yet, I figured I didn't need to issue an update :)

I expect that due to there being so much new code, there will be a long list of new bugs I haven't discovered yet. Indeed, some code remains untested and where this is so I have marked so in the documentation. Furthermore, things like threads in python are currently unsupported as they await generic functor & binding support (next release). Lastly, unfortunately just before release testing on RH9 turned up a namespace scoping bug in GCC v3.2 so there won't be any prebuilt binaries for RH9 till v0.5 (it couldn't handle the generic tools anyway).

27th July 2003: v0.3 released - out of interest, the TnFOX extensions now occupy 15,668 lines which in two months isn't bad! I've concentrated on the i/o classes mostly this time, especially IPC-capable i/o classes. We now have a named pipe class (FXPipe) which offers the best available IPC speed on either Windows or POSIX - however there's also a local process pipe class (FXLocalPipe) if you wish to connect two threads together. For connecting processes running on different machines across the internet there is an IPv4 and IPv6 capable socket class (FXBlkSocket) with an IP address container class (FXHostAddress, which is Qt compatible).

File i/o performance has also been substantially improved (indeed testing here shows a 3x performance increase) if you substitute a FXMemMap for a FXFile which transparently lets you map sections of a file into memory where naturally they can be accessed much faster and indeed managed by the host OS for you. The traditional problems with memory mapped sections have been abstracted away for you so you can treat a FXMemMap exactly like a FXFile. Furthermore as the name implies, FXMemMap can also provide shared memory between processes.

Small QTL enhancements have been made with a QSortedList (something Qt doesn't have but it seems a logical extension) and the last major new feature is thread-safe reference counting classes. They are intended for use with a filing system type structure with individual node locking yet with correct lock transference semantics to avoid deadlocks.

Lastly a large number of bugs have been fixed as the new tests I've added to the test suite are much more demanding. v0.4 is already in the works, for this I intend to add python bindings for all TnFOX extensions so you can use TnFOX directly from python!

Note: The DeviceIO test will hang when testing FXLocalPipe on RH9. This is in fact a bug in the glibc library and an update can be downloaded from RedHat (I lost three hours of my life due to this, delaying release by a day and I'm not pleased :( )

9th July 2003: v0.2 released. There are loads of new features:

B Fixed bug where copy to clipboard in error reporting box wasn't working on X11
B Fixed bug where FXProcess' destructor was not destructing static inits
B Fixed bug where FXThread was not calling primary thread registered cleanup calls

+ Added string literal extraction to CppMunge.py & generation of translation file
* Merged fox v1.1.29
+ QDict, QDictIterator, QIntDict, QIntDictIterator added
+ Altered xincs.h to use 64 bit file addressing on both Unix & Windows + as many API's
as I could find now use FXfval to indicate file size and position
+ Added FXIODevice
+ Added FXFile
* Revamped FXStream:
  + Now uses an FXIODevice for i/o
  + Added much more error detection
  + Carefully changed to maintain backwards API compatibility
* Altered FXFileStream to thunk to FXStream + FXFile combination
+ Added QMemArray<> and QByteArray
+ Added FXBuffer
* Altered FXMemoryStream to thunk to FXStream + FXBuffer combination
* Altered fxgifio.cpp, fxjpegio.cpp, fxpngio.cpp, fxrgbio.cpp, fxtifio.cpp &
fxxpmio.cpp to be compatible with new 64-bit i/o structure
+ Added utext() and wtext() to FXString for eventual unicode transition.
+ Added FXGZipDevice, removed FXGzStream
+ Added FXStream overloads for all the QTL thunks, FXException, FXBuffer.
* Merged fox v1.1.30
+ Added FXMemDbg, plus added it to all my source files.
+ Added generic FXStream overload for all FXIODevice's
+ Added stdio() method to FXFile (really needs FXPipe)
+ Added transaction rollback support (FXRollback*)
+ Implemented FXTrans plus added FXTransString
+ Moved to new TnFOX MSVC project, changed file extensions to .cxx, installed
custom build configuration to have CppMunge.py process all C++ source before compilation.
+ Added dynamically loaded library support to FXProcess and FXTrans
+ Generated MSVC7.1 project files for all parts
+ Added -sysinfo on the command-line
+ Added FXProcess::mappedFiles() which now means FXTrans knows where to find its
translation files
+ Added automatic GZip decompression and compression support to FXTrans
+ Added delayed DLL loading on Win32 for mostly unused DLL's
+ Added StripSymbols to generate .dbg files for MSVC release builds
+ Merged fox v1.1.31

Indeed there is so much it's hard to test it all adequately. My apologies if you find things don't work as they should - I did put in a week finding and fixing bugs, but the spider-sense tells me it isn't adequate - however, you can be consoled that the IPC stuff will seriously hammer all this code so once that's tested and working, so is everything added this release.

What's up for next release? It's basically more merging in of Tornado code - things like FXPipe, FXBlkSocket, FXMemMap along with some originally QTL extensions like an always sorted list, thread-safe reference counting template classes, primary button support (this is an idea direct from Tornado actually and has no parallel in existing mainstream GUI's) plus tidying up odds and ends. After that comes extending Python/FOX bindings for the extra TnFOX functionality, extra mouse cursor support (colour!), typelist facilities and lastly the IPC classes out of Tornado. I'd imagine the final version before I port Tornado over to TnFOX will be v0.5 (estimated completion is for end of August) so you have three more releases pending before then!

You may be wondering about binary and API compatibility with FOX. I never break API compatibility unless there's a really good reason and currently 99.9% of FOX applications will compile against TnFOX fine. Across releases of TnFOX binary API compatibility will be maintained after v1.0 - until then with things being so much in flux, there's no point promising something I won't keep. Note though that TnFOX like all my C++ code has been written to ease maintaining binary compatibility (hiding of member data etc.) however I note that FOX itself has not been written that way - thus binary compatibility breaks in FOX will obviously break TnFOX.

19th June 2003: v0.1 released! This is about five days late, mostly because of problems with autoconf & automake and while what's implemented is 99.9% finished, there still remains quite a lot to go before the spec above is reached.

What is implemented is best seen in the documentation which you can browse below - currently this includes the threading classes, qvaluelist & qptrlist, Qt API extensions to FXString, ordered static data initialisation and the exception handling framework (though without transaction support and the CppMunge.py tool mentioned has yet to be released - you don't need it though, it just makes life easier). FXTrans exists so you can compile against it though it currently translates no text (coming next release)

v0.2 will be out within the next month, and you'll find a lot of the above problems will have been fixed. See the Todo.txt file in the project.