Free 1.66 1 software for linux

Wolfshade mud project is an an original MUD code base written in C++.
Wolfshade is an all new MUD (Multi-User Dimension), completely written in C++, with an object-oriented model and open source code. It is complete with full ANSI color, thousands of rooms, 27 races, 13 classes, 300+ spells, moving maps, God-run quests, race wars, and much more.
Linux Instructions:
# mkdir wolfshademud and copy the gzipped tar file into that directory
Unzip/tar: using
# tar zxvf wolfshademudx.xx.x
cd into src directory
Run the configure script:
# ./configure
Type
# make all
#cd ..
Type:
# ./AutoRun.sh
Enhancements:
- More bug fixes, more spells and potions, and a few more god commands. Note: WolfshadeMUD will no longer be hosted at the Wolfshade site.
- Code update releases are planned, but hosting a site has become an impossibility, for reasons beyond the authors control.

Dynagraph libraries are written in platform-neutral C++. As such, Dynagraph itself does not render to the screen, bitmaps, etc. Instead, the Dynagraph executable can be piped to a front end using the custom incrface language, or the library can be used directly in C++ programs, or in Windows programs via COM wrapper classes.
Gordon Woodhull maintains and improves Dynagraph continually. It is based on the brilliant work of the Graphviz team at AT&T Research, particularly Stephen North and Emden R. Gansner.
While Gordon consulted for AT&T Research from 1997 to 2003, he designed a new architecture and ported the DynaDAG and FDP engines from C to C++. Since his departure from AT&T, he has continued to rearchitect Dynagraph and add powerful new features.
Dynagraph is licensed under the Common Public License.
Whats New in 1.1.5.9 Stable Release:
- This improves the build system for *nix, esp using automatically generated dependencies.
- Requires gnu make.
Whats New in 1.1.6.1 Development Release:
- Contains a fix for the nodecross bug.
- Also parallel edges appear to be working.

monq.jfa is the core Java class library used to implement Whatizit. The project allows for fast and flexible text filtering with regular expressions.
In contrast to java.util.regex, monq.jfa allows to bind a regular expression to an action that is automatically called whenever a match is spotted in an input stream.
In addition it is possible to combine several tenthousand regex/action pairs into one machinery (called DFA).
The DFA filters input to output by looking for matches of all regular expressions in parallel, calling their actions to reformat the text or to incrementally built up a data structure.
The filtering speed is 1.5MB/s on P4 2.6GHz and is mostly unrelated to the number of regex/action pairs.
Enhancements:
- This is a bugfix release to correct improper unsynchronized reuse of an object within monq.jfa.actions.Printf.
- The user visible symptom would be garbled output.

SchemaSpy is a Java-based tool that analyzes the metadata of a schema in a database and generates a visual representation of it in a browser-displayable format. It lets you click through the hierarchy of database tables via child and parent table relationships.
The browsing through relationships can occur though HTML links and/or though the graphical representation of the relationships. Its also designed to help resolve the obtuse errors that a database sometimes gives related to failures due to constraints.
SchemaSpy is free software, distributed under the terms of the Lesser GNU Public License. Your donations are, however, greatly appreciated.
SchemaSpy uses the dot executable from Graphviz to generate graphical representations of the table/view relationships. This was initially added for people who see things visually.
Now the graphical representation of relationships is a fundamental feature of the tool. Graphvis is not required to view the output generated by SchemaSpy, but the dot program should be in your PATH (not CLASSPATH) when running SchemaSpy or none of the graphs will be generated.
Some Linux users have experienced problems with dot version 2.6. Version 2.6 (or higher) is preferred, but if it doesnt work then try 2.2.1. Note that SchemaSpy takes advantage of some dot 2.6+ features so graphs wont be as well formed when using 2.2.1.
SchemaSpy uses JDBCs database metadata extraction services to gather the majority of its information, but has to make vendor-specific SQL queries to gather some information such as the SQL associated with a view and the details of check constraints.
The differences between vendors have been isolated to configuration files and are extremely limited. Almost all of the vendor-specific SQL is optional.
Enhancements:
- This is a bugfix release primarily intended to address the Graphviz 2.9+ changes that broke SchemaSpy.
- It fixes bug 1602135 (an exception using dot version 2.9), bug 1571711 (failure to use a precompiled version of dot on Mac OS X), and bug 1597609 (quoting and Sybase ASE).

EL4J, the Extension Library for the J2EE, adds incremental improvements to the Spring Java framework.
Main features:
- The ability to split applications in modules
- A module can consist of code, jar-files and configurations
- There can be transitive dependencies between modules
- A module can automatically enable its spring configuration when it is present
- The order and the location of configuration-information works accross various J2EE containers
- Simplified remoting
- Optional implicit context passing to cleanly add technical context with remote method invocations (e.g. to add a security principal or the sub-company on whose behalf a request is being made)
- Remote a POJO as SLSB or SFSB, remote a POJO via SOAP
- Clean remoting support for interfaces that lack a RemoteException in their interface where its required
- A light daemon manager service
- Various improvements
- Make the active beans and their configuration visible in JMX
- A light exception handling framework that implements a safety facade
- Simplified configuration of attribute-interceptor mappings
Enhancements:
- Many clean-ups in the build infrastructure and in the file organization
- Added a database plugin that allows to execute SQL scripts on the database.
- It can optionally launch an embedded database (Derby for now).
- Added a dependency plugin that illustrates the dependencies between modules graphically.
- Added a basic EL4J archetype to get started more easily
- We provide a mechanim to override the configuration files that are in the automatic Tomcat download (files etc/tomcat are copied to Tomcat).
- Test run now in the maven integration phase (in order for us to launch the database in the right moment).
- Some issues in the site-generation were fixed.
- Added an experimental version plugin that checks whether there are new versions available of existing maven plugins or of other jar-files a project depends on.
- Provided fixes for the external exec plugin
- Upgrade to some newer maven plugins: eclipse, javadoc, deploy.

ZatriX is a black and green matrix theme for KDE created in Slackware 11.0 with KDE 3.5.4.

DBFW is a PHP-based database framework for rapid application development and rapid prototyping.
DBFW project allows the creation of almost complete Web/database-based applications in no more than few hours, as well as faster development cycles.
It uses automatic DB schema discovery with XML configuration files to automatically implement a basic user interface that can be extended through the use of ad-hoc PHP code.
This framework aims to provide the developer with a tool that can be used first to iron out the database structure through as many iterations as required, but without forcing the developer to rewrite everything at every iteration.
It provides many features aimed to reduce this round-trip in the requirement and specification analisys phase, thanks to its ability to provide an auto-updating and working prototype of the user interface that can be used to access data from the DB under construction.
Main features:
- autodetection of the entire DB schema. The framework engine will retrieve all required informations from the DB itself (like all user visible tables, foreign keys, column types, and so on). It will cache the discovered infos in a file under the directory cache/ of the application. If you change the schema, the tables, add/remove columns and so on, you will just need to remove the cache file and the framework will redo the discovery process.
- XML-based User Interface specification. The user interface of the application is specified through a set of XML files, which will contain the templates for the application forms and browsers as well as the application menus, the reports and so on....
- automatic handling of CRUD functionality. By default, it is able to provide support for creation, read, update and delete of records from all your tables.
- automatic handling of Foreign Keys. The framework knows all foreign keys defined among tables, and it will allow its automatic handling whenever you will say so. The automatic handling means navigable html links during the browsing of records from a given table as well as search or select widgets in the editing forms.
- multi database support. The framework uses a driver based interface for DB access, which means that new databases backend may be added later, by simply creating the related driver. The framework currently supports the following DB:
- PostgreSQL 7.3.X and later (The 8.X needs more tests, thought)
- MySQL 4.1.X and later (Check the driver specifications for known limitations)
- Oracle 9i and later (it should work, even if it hasnt been used by few years)
- The framework uses the PEAR library for DB access, so the its internal driver will add only the functionality required by the discovery process and few others not directly provided by the PEAR driver.
- simple creation of Reports. You can create a Report (or a group of Reports) simply by specifying the SQL query which generate the data and by choose the output, be it a textual one using a template, or a graphical one, using the GD library or a SVG generator. It supports the following output formats: HTML, PDF (still under development, thought), TSV (tab Separated Values) and XLS (Excel Spreadsheets);
- DHTML forms: hierarchical forms are implemented using DHTML so they are handled by the web client for the most part, avoiding unnecessary round-trips. (It should work with almost all recently web browsers).
- form nesting. This allows you to create nested forms for editing of related sets of records. All modifications to the set will be committed as a unique transaction, so they will fail or success as a whole.
- form validation and error handling: all forms will be validated before their use, and all errors will be notified to the user. The framework uses the exernal JavaScript library overlib to handle tooltips as well as error notifications ( you may find more info at http://www.bosrup.com/web/overlib/ )
- support for record history. You may create two additional columns in your tables (a start-of-validity one and a end-of-validity one), tell the framework of them and then it will handle all modifications as storicized modifications (i.e. the records will not be really deleted, just marked as expired).
- integrated support for PDF generation, through the external library html2ps based on FPDF
- javascript calendar for web client date handling (a really wonderful JavaScript library. Check it out at http://students.infoiasi.ro/~mishoo/site/calendar.epl
- dynamically generated menus: you can generate menus dinamically using SQL queries.
- internationalization: it supports full internationalization for both framework and applications using Gettext. They may be handled separately, so you can maintain your application messages indipendently from those of the framework.
- privileges: the framework will respect all privileges defined on the DB tables, as well as it will enforce additional privileges, like record based ones (yes, really record based... I need to document how they work, though... )
- automatic generation of user documentation: (Work In Progress) Since the application behaviour is specified for the most part in the XML configuration files, its possible to process those files to generate automatically the core of the User Documentation. Of course, it still need to be completed and edited by hand, but this time you may concentrate on its content. BTW, the generated document will be in DocBook XML format.
- support for pop-up based details views.
- many more feature, like the handlers (PHP code which can be hooked to specific engine events like the decode event or the post_retrieve and so on), triggers (to allow the use of special triggers on DB that doesnt support triggers that access the tables under modifications, like Oracle and MySQL), foreign key and browser filtering, order-by handling, externally linked pages, and so on...
Enhancements:
- A new online help subsystem, a code cleanup, more work on the documentation, more support for data exports, and many bugfixes.