Free phpscheduleit 1.2.8 software for linux

Lexxia software is a multipurpose XML tool. It is built on the Limpid Open-Source C++ library.
Lexxia is a powerful tool for batch transformation of XML files, conversion between XML and other file formats: HTML, CSV, RJ (Eric Raymonds record jar format) and SXF (a new simplified XML format to simplify authoring). It also features stream editing and transformation of really huge files because it is not necessary to construct a full source or result document during transformation, and provides a tool for extraction of structured content from suitable HTML files (to improve the performance of search engines).
Lexxia now provides a simplified path to creating LaTeX and PDF files: it automatically generates a stylesheet for a particular XML data file, and uses it to transform the file. The result is a LaTeX file that can be converted to postscript and PDF files using standard (free) tools. The system is based on the Limpid XML/XPath/XSLT C++ library and is small and very fast. It was developed in Linux and has been ported to Windows.
Main features:
- Stylesheet Transformation;
- Interconversion between XML and other file formats: DTD, CSV, Eric Raymonds Record Jar format, and SXF format (simplified format for editing XML files);
- Stream editing of files;
- Batch processing, stream editing and multiple transformations on the same source file;
- Stepped processing, which permits transformation or stream editing on truly huge files;
- Recovery of structured content from HTML files;
- Validation and Reporting of DOM Statistics;
- Joining (merging) of multiple XML files.
- Verbose operating mode.
- Lexxia is released under the GNU General Public License;
- It is available for free download for both Linux and Windows;
- It was developed in C++, which means high speed and responsiveness.
- It was developed on Linux (using KDevelop) and ported to Windows using the Digital Mars compiler.
Advantages of using the Limpid Library:
- Working with efficient C++ code without struggling with the management of pointers.
- Absence of memory leaks.
- High and reproducible real-time performance without the intrusion of garbage collection.
- Programming interfaces that are standard and not subject to frequent change.
- Library code that is both portable and highly adaptable.
- Supporting classes make your own work more productive.

nmr-relax is designed for the study of the dynamics of proteins or other macromolecules though the analysis of NMR relaxation data. Its primary purpose is for the Lipari and Szabo model-free analysis of the R1 and R2 relaxation rates together with the steady state heteronuclear NOE. The program also supports relaxation curve fitting for the calculation of the R1 and R2 rates and their errors, the calculation of the NOE and its error, and reduced spectral density mapping.

Flexibility

The aim of relax is to provide a seamless and extremely flexible environment able to accept input in any format produced by other NMR software, able to faultlessly create input files, control, and read output from various programs including Modelfree and Dasha, output results in many formats, and visualise the data by controlling programs such as Grace, OpenDX, and MOLMOL.

All data analysis tools from optimisation to model selection to Monte Carlo simulations are inbuilt into relax. Therefore the use of additional programs is optional.

The power of Python

The flexibility of relax arises from the choice of either relaxs scripting capabilities or its Python prompt interface. Extremely complex scripts can be created from simple building blocks to fully automate data analysis. A number of sample scripts have been provided to help understand script construction. In addition, any of Pythons powerful features or functions can be incorporated as the script is executed as an arbitrary Python source file within relaxs environment.

srm is a secure replacement for rm.
Unlike the standard rm, it overwrites the data in the target files before unlinking them. This prevents command-line recovery of the data by examining the raw block device. It may also help frustrate physical examination of the disk, although its unlikely that it can completely prevent that type of recovery. It is, after all, a paper shredder for sensitive files.
srm is ideal for personal computers or workstations with Internet connections. It can help prevent malicious users from breaking in and undeleting personal files, such as old emails. Its also useful for permanently removing files from expensive media.
For example, cleaning your diary off the zip disk youre using to send vacation pictures to Uncle Lou. Because it uses the exact same options as rm(1), srm is simple to use. Just subsitute it for rm whenever you want to destroy files, rather than just unlinking them.
Enhancements:
- Minor bugfixes. Correctly handle symlinks. Build with most recent versions of automake.
- Documentation updates

Wmconfig is a free tool for creating menu entries for various X window managers. Wmconfig uses a very simple configuration and it is fast and small.
A special toolkit (Gtk or Qt / KDE) is not required and the menu entries may be edited with the text editor of your choice.
The goal is to provide an independent tool without patching any sources. A graphical menu editor and support for more window managers will come soon.
Before new versions are released, they are tested for some time under production systems.
Wmconfig and this site are published under the terms of the GNU General Public License.
Please note: The samples are included in the source archive and no longer needed for Version 1.1.7 and above.
Enhancements:
- The Pekwm and the Xfce4 output support were fixed.
- The Openbox option now generates a pipe-read output.

WMcp is a simple dockable pager for use in Window Maker.

Installation:

Unzip the file: gunzip wmcp-1.2.8.tar.gz
Untar the file: tar xvf wmcp-1.2.8.tar
CD to src dir: cd wmcp-1.2.8

do one of these makes:

make -- make wmcp using the default button scheme (scalpel)
make scalpel -- make wmcp using the scalpel style button colors
make gv -- make wmcp using the ghostview style button colors

copy wmcp to some directory in your $PATH.
( ie: cp wmcp /usr/local/bin )

type wmcp

Grab the appicon and move it to the dock.

If make doesnt work, you may need to fiddle with the settings in the Makefile.

Tested on:

WindowMaker-0.20.3
WindowMaker-0.50.2
X Clients: Red Hat 5.0, Red Hat 6.0, HP-UX 10.20
X Servers: XFree86, Exceed, AccelX

Usage:

usage: wmcp [-g geometry] [-d dpy] [-n workspaces] [-a alt key] [-v]
[-c] [-w i/n/w] [-s y/n] [-x #] [-y #] [-h]

-g geometry: ie: 64x64+10+10
-d dpy: Display. ie: 127.0.0.1:0.0
-n workspaces: How many buttons to start with.
-a alt key: integer 1-4 defining ModXMask (default 1 Mod1Mask).
-w i/n/w: Window State: Iconic, Normal, Withdrawn (default Withdrawn)
-s y/n: Shaped window: yes or no (default y)
-c Sends CTRL + ALT + Key (default only sends ALT + key)
-v Verbose. 0=off, 1=on (default 0)
-x # Number of buttons on the x-direction (1,2,3 or 4)
-y # Number of buttons in the y-direction (1,2,3 or 4)
-h Help. This screen.

Left mouse button:

Selects the workspace to switch to.

Right / Middle mouse buttons:

Change the number of buttons displayed.

XML::Mini is a Perl implementation of the XML::Mini XML create/parse interface.

SYNOPSIS

use XML::Mini::Document;

use Data::Dumper;


###### PARSING XML #######

# create a new object
my $xmlDoc = XML::Mini::Document->new();

# init the doc from an XML string
$xmlDoc->parse($XMLString);

# You may use the toHash() method to automatically
# convert the XML into a hash reference
my $xmlHash = $xmlDoc->toHash();

print Dumper($xmlHash);


# You can also manipulate the elements like directly, like this:

# Fetch the ROOT element for the document
# (an instance of XML::Mini::Element)
my $xmlRoot = $xmlDoc->getRoot();

# play with the element and its children
# ...
my $topLevelChildren = $xmlRoot->getAllChildren();

foreach my $childElement (@{$topLevelChildren})
{
# ...
}


###### CREATING XML #######

# Create a new document from scratch

my $newDoc = XML::Mini::Document->new();

# This can be done easily by using a hash:
my $h = {
spy => {
id => 007,
type => SuperSpy,
name => James Bond,
email => mi5@london.uk,
address => Wherever he is needed most,
},
};

$newDoc->fromHash($h);



# Or new XML can also be created by manipulating
#elements directly:

my $newDocRoot = $newDoc->getRoot();

# create the < ? xml ?> header
my $xmlHeader = $newDocRoot->header(xml);
# add the version
$xmlHeader->attribute(version, 1.0);

my $person = $newDocRoot->createChild(person);

my $name = $person->createChild(name);
$name->createChild(first)->text(John);
$name->createChild(last)->text(Doe);

my $eyes = $person->createChild(eyes);
$eyes->attribute(color, blue);
$eyes->attribute(number, 2);

# output the document
print $newDoc->toString();
This example would output :
< ?xml version="1.0"? >
< person>
< name>
< first>
John
< /first>
< last>
Doe
< /last>
< /name>
< eyes color="blue" number="2" />
< /person>

XML::Mini is a set of Perl classes that allow you to access XML data and create valid XML output with a tree-based hierarchy of elements. The MiniXML API has both Perl and PHP implementations.

It provides an easy, object-oriented interface for manipulating XML documents and their elements. It is currently being used to send requests and understand responses from remote servers in Perl or PHP applications. An XML::Mini based parser is now being tested within the RPC::XML framework.

XML::Mini does not require any external libraries or modules and is pure Perl. If available, XML::Mini will use the Text::Balanced module in order to escape limitations of the regex-only approach (eg "cross-nested" tag parsing).
The Mini.pm module includes a number of variables you may use to tweak XML::Minis behavior. These include:

$XML::Mini::AutoEscapeEntities - when greater than 0, the values set for nodes are automatically escaped, thus $element->text(4 is > 3) will set the contents of the appended node to 4 is > 3. Default setting is 1.

$XML::Mini::IgnoreWhitespaces - when greater than 0, extraneous whitespaces will be ignored (maily useful when parsing). Thus Hello There will be parsed as containing a text node with contents Hello There instead of Hello There . Default setting is 1.

$XML::Mini::CaseSensitive - when greater than 0, element names are treated as case sensitive. Thus, $element->getElement(subelement) and $element->getElement(SubElement) will be equivalent. Defaults to 0.