Free dosbox 0.71 software for linux

Zombie project is a library and server for developing networked apps/games.
The developer does not need to know anything about TCP/UDP in order to develop a networked application using Zombie.
All communication passes through a central server, which can handle many different applications at the same time.
Data can be multi/broad/unicasted and features such as teams are easy to use.
Enhancements:
- Minor fixes to buildscripts as well as RPM spec-file
- More changes to the build system. Now Zombie seems to install a lot cleaner than before.
- Removed a lot of old stuff that has been hanging around for ages.
- User and group for installation can now be specified with ./configure.

libxode is an XML library which wraps expat. In C even. It offers a very flexable DOM, and uses Memory Pools (which can also be created/used from this library).
libxode also features handling of XML streams and some convenience functions for string handling using memory pools.
Main features:
XML Parsing
- XStreams for parsing XML in a stream
- Xodes a highly flexible DOM
- On Demand child parsing (well, soon)
Memory Pools
- Organize related memory into one structure
- Save mallocs and frees with heap pre-allocation
Spools
- Simple handling of strings
- Simple concatencation
- Utilizes Pools for simple memory handling

SrvReport is a simple and featurefull server monitoring and reporting system. SrvReport project can send every day a mail with the latest state of the server including:
- network traffic report
- cpu usage report
- mail send/receive
- server warnings
- last logins
- other customized messages (like harddisk problems)
- web-server traffic report
- Xfer-logs (ftp)
- optional test for rootkits (with chkrootkit)
Main features:
A full report will show you the following information:
- Network traffic (including dayly, weekly and monthly graph)
- CPU-Usage (including dayly, weekly and monthly graph)
- Mail sent/receive report (to, from, size)
- Last authenticated users
- Server warnings
- Other customized messages (like harddisk problems)
- Optional web-server traffic report
- Optional Xfer-logs
- Optional test for rootkits (with chkrootkit)
It supports the following features as well:
- Several languages
- No need of rare perl libraries
- Easy to use (Just one configuration file to edit),
- Free (GNU GPL), with sources (perl scripts),

Devel::Modlist is a Perl extension to collect module use information.

SYNOPSIS

perl -d:Modlist script.pl

The Devel::Modlist utility is provided as a means by which to get a quick run-down on which libraries and modules are being utilized by a given script.
Just as compiler systems like gcc provide dependancy information via switches such as -M, Devel::Modlist is intended to assist script authors in preparing dependancy information for potential users of their scripts.

USAGE

Usage of Devel::Modlist is simple. The primary method of invocation is to use the -d option of Perl:

perl -d:Modlist script.pl

Alternately, one could use the -M option:

perl -MDevel::Modlist script.pl

In the case of this module, the two are identical save for the amount of typing (and option passing, see below). It is not recommended that this module be loaded directly by a script via the use keyword, as that would cause the dependancy reporting after every invocation until it was removed from the code.

OPTIONS

The following options may be specified to the package. These are specified either by:

perl -MDevel::Modlist=option1[,option2,...]

or

perl -d:Modlist=option1[,option2,...]

Options may also be given in an environment variable, which gets read at any invocation in which there are no options explicitly provided. If any options are given in the invocation, then the environment variable is ignored. Two different names are recognized:

Devel::Modlist
Devel__Modlist

The latter is to accomodate shells that do not like the presence of :: in an environment variable name.

The options:

cpan

Reduce the resulting list of modules by using the data maintained in the local CPAN configuration area. The CPAN module (see CPAN) maintains a very thorough representation of the contents of the archive, on a per-module basis. Using this option means that if there are two or more modules that are parts of the same distribution, only one will be reported (the one with the shortest name). This is useful for generating a minimalist dependancy set that can in turn be fed to the CPAN install command to ensure that all needed modules are in fact present.

cpandist

This is identical to the option above, with the exception that it causes the reported output to be the CPAN filename rather than the module name in the standard Perl syntax. This can also be fed to the CPAN shell, but it can also be used by other front-ends as a path component in fetching the requisite file from an archive site. Since the name contains the version number, this behaves as though noversion (see below) was also set. If both cpan and cpandist are set, this option (cpandist) takes precedence. If path is also specified, this option again takes precedence.

nocore

Suppress the display of those modules that are a part of the Perl core. This is dependant on the Perl private library area not being an exact substring of the site-dependant library. The build process checks this for you prior to install.

noversion

Suppress the inclusion of version information with the module names. If a module has defined its version by means of the accepted standard of declaring a variable $VERSION in the package namespace, Devel::Modlist finds this and includes it in the report by default. Use this option to override that default.

path

Display the path and filename of each module instead of the module name. Useful for producing lists for later input to tools such as rpm.

stop

Exit before the first actual program line is executed. This provides for fetching the dependancy list without actually running the full program. This has a drawback: if the program uses any of require, eval or other such mechanisms to load libraries after the compilation phase, these will not be reported.

OpenThought is a Web Application Environment which doesnt require page reloads.

SYNOPSIS

use OpenThought();

my $o = OpenThought->new( $OP );

my $field_data;
$field_data->{myTextBox} = "Text Box Data";
$field_data->{myCheckbox} = "true";
$field_data->{myRadioBtn} = "RadioBtnValue";
$field_data->{mySelectList} = [
[ "text1", "value1" ],
[ "text2", "value2" ],
[ "text3", "value3" ],
];

my $html_data;
$html_data->{id_tagname} = "New HTML Code";

print $o->serialize({
fields => $field_data,
html => $html_data,
focus => "myTextBox",
javascript => $javascript_code
});

OpenThought is a powerful and flexible web application environment. OpenThought applications are different from other web applications in that all communication between the browser and the server is performed in the background. This gives a browser the ability to receive data from the server without ever reloading the currently loaded document. Data received can be displayed automatically on the existing page, can access JavaScript functions and variables, and can load new pages. Additionally, OpenThought completely manages all of your session data for you. These features give the look and feel of a full-blown application instead of just an ordinary Web page.

OpenThought is extended with OpenPlugin, also described briefly in this documentation.

OpenThought works by communicating with the server through the use of a hidden frame. Now some may say "Frames? Youre using frames??" No need to fret though, the frame is completely hidden. There is no visible way for your users to tell that they are using an application which makes use of frames.

This hidden frame performs all communication with the server for you, and allows your browser to talk to the server without reloading the content currently visible in your web browser. This is how OpenThought can update portions of the screen, and how the server can run JavaScript code in the browser, all without reloading the page.

Any time an OpenThought application is loaded, a unique session id is generated for that user. Each time communication takes place between the browser and server, OpenThought is careful to make sure that this session id is sent along with the request. There is nothing you need to do to make this work, it is done for you. When youre programming your application, you can always expect a session id to be sent to the server, and you can easily retrieve it along with the rest of the data sent by the browser.

In addition to being able to update portions of a screen, you can also load new pages within the content frame. If you choose to load new pages, your session continues to be maintained.

OpenThought gives you an easy way of tieing together multiple web pages, and allows you to build web applications which act like "real" applications. When an application is required, some people would decide to build it in Tk, Visual Basic, Gtk, or any number of other systems which offer a visual interface. But then, your application is either not available on the web, or you have to create a seperate web interface to interact with the backend.

Have you ever tried to create a web interface which minics the interface of a non-web based application? The web based application no longer looks or acts like your other interface, it acts like an ordinary webpage. It probably uses several screens to get the same amount of content that your application offered in one.

By not ever needing to reload the page, OpenThought offers this application look and feel thats been missing from the web. This allows you to create just one interface, for both LAN and web use.

Wiki::Toolkit is a toolkit for building Wikis.

Helps you develop Wikis quickly by taking care of the boring bits for you. You will still need to write some code - this isnt an instant Wiki.

SYNOPSIS

# Set up a wiki object with an SQLite storage backend, and an
# inverted index/DB_File search backend. This store/search
# combination can be used on systems with no access to an actual
# database server.

my $store = Wiki::Toolkit::Store::SQLite->new(
dbname => "/home/wiki/store.db" );
my $indexdb = Search::InvertedIndex::DB::DB_File_SplitHash->new(
-map_name => "/home/wiki/indexes.db",
-lock_mode => "EX" );
my $search = Wiki::Toolkit::Search::SII->new(
indexdb => $indexdb );

my $wiki = Wiki::Toolkit->new( store => $store,
search => $search );

# Do all the CGI stuff.
my $q = CGI->new;
my $action = $q->param("action");
my $node = $q->param("node");

if ($action eq display) {
my $raw = $wiki->retrieve_node($node);
my $cooked = $wiki->format($raw);
print_page(node => $node,
content => $cooked);
} elsif ($action eq preview) {
my $submitted_content = $q->param("content");
my $preview_html = $wiki->format($submitted_content);
print_editform(node => $node,
content => $submitted_content,
preview => $preview_html);
} elsif ($action eq commit) {
my $submitted_content = $q->param("content");
my $cksum = $q->param("checksum");
my $written = $wiki->write_node($node, $submitted_content, $cksum);
if ($written) {
print_success($node);
} else {
handle_conflict($node, $submitted_content);
}
}

wmappl is a simple scrolling application launcher for the WindowMaker dock. It is loosely based off of WMButton by Edward Flora.
Given a list of programs and icons, wmappl displays up to six icons at a time. Scroll buttons or the mouse scroll wheel may be used to cycle through additional programs.
Installation:
The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation.
It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.
Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, and a file `config.log containing compiler output (useful mainly for debugging `configure).
It can also use an optional file (typically called `config.cache and enabled with `--cache-file=config.cache or simply `-C) that saves the results of its tests to speed up reconfiguring. (Caching is disabled by default to prevent problems with accidental use of stale cache files.)
If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.
If you are using the cache, and at some point `config.cache contains results you dont want to keep, you may remove or edit it.
The file `configure.ac (or `configure.in) is used to create `configure by a program called `autoconf. You only need `configure.ac if you want to change it or regenerate `configure using a newer version of `autoconf.
The simplest way to compile this package is:
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.
Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.
2. Type `make to compile the package.
3. Optionally, type `make check to run any self-tests that come with the package.
4. Type `make install to install the programs and any data files and documentation.
5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.
There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.
Enhancements:
- man/wmapplrc.5: updated for tooltip_font option