Free imsafe 0.2.2 software for linux

MAST project is set of audio streaming tools using RTP over IPv4 and IPv6 Multicast/Unicast.

Unlike VAT and RAT, which are designed primerily for audio conferencing, MAST is designed to be used for audio distribution and broadcast. It is currently limited to recieving a single audio source, unlike RAT which can mix serveral sources.

It supports many of the audio payload types in the Audio-visual Profile (RTP/AVP).

MAST is licenced under the GNU General Public License.

Bakefile project is cross-platform, cross-compiler native makefiles generator. It takes compiler-independent description of build tasks as input and generates native makefile (autoconfs Makefile.in, Visual C++ project, bcc makefile etc.).
Bakefiles task is to generate native makefiles, so that people can keep using their favorite tools. There are other cross-platform make solutions, but they either arent native and require the user to use unfamiliar tools (Boost.Build) or they are too limited (qmake).
Beware that Bakefile is currently under heavy development (version 0.1.x) and is very likely to change significantly and to contain bugs. It is being used for wxWidgets new build system and you can expect it to be usable for production once we fully convert wxWidgets to use it.
Enhancements:
- Bakefile was relicensed from the GPL to the MIT license.
- Support for Visual Studio 2005 project files was added.
- Many small fixes and improvements were made.

Pieforms project provides a simple, unified way to create, validate and process forms all with a common look and feel, with support for pluggable elements, renderers and validation rules.

Huh? What does all that mean?

In simple terms, Pieforms provides a library for building HTML forms. So rather than writing all that HTML yourself for building forms, handling the validation and processing of them in whatever messy, inconsistent way youre doing it currently, you simply define a big hash in your script that describes your form. Pieforms does all of the legwork involved with building the form HTML from this hash (using elements and renderers), and also handles the validation of input using rules. In the general case, after youve defined you form, all you need to do is write a callback function that gets called when the form has been submitted with the data valid according to the rules.

Sounds interesting! Show me an example...

Okay, so youre writing a simple form that has a standard < input type="text" > and a textarea on it, with a submit button. Youd write a script similar to the following:

require_once(pieform.php);
$form = array(
name => myform,
method => get,
elements => array(
text => array(
type => text,
title => Text Element,
description => A little text box for you
rules => array(
required => true
)
),
textarea => array(
type => textarea,
title => Textarea,
defaultvalue => Some default text for the textarea,
rows => 7,
cols => 50
),
submit => array(
type => submit,
value => Submit form!
)
)
);

echo pieform($form);

function myform_submit($values) {
echo "Your submitted values:< br >";
foreach ($values as $key => $value) {
echo "$key: $value< br> ";
}
}

You see how easy that is? You didnt have to write any HTML - in fact, the entire definition is in PHP, which means if you make mistakes theyll show up as parse errors, rather than HTML validity errors (which are generally less often checked for). You only called one function to have everything done for you. And you can write a function to handle submission, full well knowing that the text element will always have a value that isnt the empty string.

After that, the submnit function is almost academic. You just save whatever you want to the database or whatever, and then the last thing you should do is redirect the user somewhere, perhaps to the same page or perhaps elsewhere.

For AJAX forms, all you have to do is add ajaxpost => true in the $form array, and then make your submit function output JSON in the form {error: [false or true], message: some message}, and then exit. Pieforms includes an implementation of json_encode for your convenience.

Okay, that looks easy! What else can it do?

The best part is that the elements, renderers and rules for your forms are pluggable. For example, you could write a wysiwyg element which behaves like the textarea one, but also includes javascript necessary to turn the textarea into a full WYSIWYG editor. Or you could write an element with two select boxes, arrows to move items left and right, and AJAX searching of the boxes. The possibilities are limitless! You can also write your own rules for reuse later (and change how elements respond to those rules if necessary), and write your own renderers (which handle the HTML surrounding the elements), so you can do things like add a little help icon next to each element with a link to a page explaining how the element works.

Smartmenu is a menuing application for Lirc. Its purpose is to make use of an infra-red remote controller with a Linux box as easy and smart as possible.
It handles displaying and browsing menus in a way that is usable for typical user of a remote controller.
Such a user must be able to use the menus when he is a few meters away from the monitor or even with monitor turned off.
Enhancements:
- This release provided better control of lirc key repeating.

CURSEL project is a freeware FMLI implementation, a small language that allows you to quickly make a form- and menu- based character interface to shell scripts and other programs.

CURSEL filenames normally start with either "Menu", "Form" or "Text".

For example, the command,

./cursel Menu.example

would interpret the contents of the file "Menu.example" and display an example Menu.

CURSEL provides a language similar to the AT&T FMLI shell. Note that the language is similar to, but certainly not the same as, a /bin/sh shell; in particular, backquoted expressions are NOT evaluated by a shell such as BASH, but rather by the builtin CURSEL "shell" (which does not have all features of e.g. BASH).

There are also a few CURSEL extensions:

1. text frames can use the "alignment" descriptor, a CURSEL extension, which allows you to left or right align text in a Text frame (centering and justification is also supported).

2. backquoted expressions can use () grouping of parentheses, as in the UNIX shell

ECC is a package for Elliptic Curve cryptography.

ECC is implemented by using OpenSSL 0.9.6a or higher, for message digests and symmetric ciphers, and by using the Portable Object Compiler and Computer Algebra Kit for the elliptic curve cryptography.

Important note: you need version 3.2.5 of the compiler to compile this package.

See the README and INSTALL files in the package for instructions on how to use and how to install the ec-keygen, ec-sign, ec-verify, ec-crypt and ec-decrypt commands.

List nicknames of curves:

ec-keygen -l
c47n23r1:secp112r1:secp112r2:secp160r1:secp384r1:sect113r1:sect163k1

Generate a public and private key:

ec-keygen -e secp112r2 -o stes

Generated files:

ls -ltr stes.pub stes.prv
-rw-r--r-- 1 stes users 311 Jul 12 22:00 stes.pub
-rw------- 1 stes users 135 Jul 12 22:00 stes.prv

Digital Signature:

ec-sign -c sha1 -k stes.prv -f README -s README.sign

Verify the signature:

ec-verify -k stes.pub -f README -s README.sign
echo $?
0

Encrypt:

ec-crypt -c aes-128-cbc -k stes.pub -f README -s README.key -o enc
ec-crypt: unable to get 16 bytes of key from this curve, use a different curve
ec-crypt -c rc4-40 -k stes.pub -f README -s README.key -o enc

Decrypt:

ec-decrypt -k stes.prv -f enc -s README.key -o myREADME

LibAran is a 2D/3D Fast Multipole Method software library.
Main features:
- 2D FMM algorithms through Laurent Series.
- 3D FMM algorithms through complex spherical harmonics series. These series can handle Newton/Coulomb potentials. Sparse translationoperators (O(p^3) complexity) are included.
- Dynamic QTree/OcTree LibVsg (VsgPRTree2d and VsgPRTree3d) particles filtering.