Free 1.0.3 software for linux

myOS project is minimalistic GNU/Linux based system. Beside the main goal - OpenGL capable, Linux based system without X, I was also looking to make system small and fast as possible, with quick kernel boot and system loading time. By making system small really took care of both since it can run entirely from RAM making it very fast and responsive.

It is bare bones Linux system, stripped down of everything, but core necessary files to compile and run OpenGL/C code. It has simplified directory structure and cleaned up internal cross referencing, it starts up with and in total has only a single script. Linux kernel is 2.6.20, compiled with only essential drivers.

Size can be reduced even more, read this for inspiration:

drun 1.0.3 provides you with an outstanding and powerfulGTK run dialog box with tab completion and a simple ui, which supports common features as well as history, files, directories, urls, and spelling correction.

Usage:

Type in a command, and press return to run it. Tab, up, and down can be used to cycle through possible completions for that command. Delete can be used to remove a completion from the list and history. Escape dismisses the completions or exits. Return runs a command, and Shift+Return runs a command in a terminal.

If you press tab on an empty entry, then you will get a list of recently run commands in the order that you last ran them. Otherwise, it will attempt to complete an executable, directory, or file. The completions will then be ordered by how many times they were previously run. A name beginning with an equals symbol will be expanded based on where it is located in the system path. If no completions are found, then your input will be manipulated based on spell checking to find any possible completions.

The programs used to run files, directories, and urls can be edited in ~/.drunrc:

• http-handler = firefox
• ssh-handler = xterm -e ssh
• file-handler = gnome-open
• directory-handler = nautilus
• terminal-handler = xterm -e
  

Normally, drun will run commands in the current directory it was launched in. If a single directory is passed in as a parameter, then it will run the command in that directory. If a non-directory or multiple files are passed in as a parameter, then it will run the command in the directory of the first parameter, and append the list of files to the end of the command.

Custom run actions can be added to thunars right-click menu by configuring them from thunars edit menu.
You can add the following commands to be able to run commands in a directory or on selections of files from a thunar window. Similar actions are possible from other file managers such as nautilus.

Major Features:

1. Tab completion
2. History
3. Runs files, directories, urls, and executables
4. Runs on thunar/nautilus file and directory selections
5. Spelling correction
6. Recursive directory completion
7. Completions ordered using history
8. Completes parameters from history

Enhancements:

• Run terminal on shift+return or control+return
• Run terminal in directory if shift+return or control+return is pressed with a path
• Modified reverse search behaviour
• Complete directories from history as well as file system
• Go to parent directory on alt+up, undo on alt+down
• Allow running of shortcuts and documents on Windows
• Allow * glob in input

Requirements: gtk+

Mneme provides an email reminder system.
Mneme is a combination of Web application and shell scripts that are used to help people remember upcoming events or action that they need to take.
The Web application portion allows a user to add, edit, view, and delete reminders.
There are two shell scripts to choose from that generate emails when the reminders are due.
Main features:
- Fast and simple to use.
- Clear view of up-coming reminders.

userv is a tool for system administrators, who often find themselves with a program running as one user which needs to be able to do certain things as another user.
For example, my machines news system needs to scan my users newsrcs to ensure that the right newsgroups are fetched. Before userv that part of the news system had to run as root, and clumsily use `su.
It can be also a component for application authors. For example, imagine a version of `cron which didnt need to run as root, so that a security bug in cron would just mean that bad people could get cron jobs to run at the wrong times, rather than everyone on the system being able to break in completely. Imagine being able to do sophisticated mail filtering at delivery time without the mail transfer or delivery agents needing to be root.
Enhancements:
- Count -continued lines properly in error message line numbers.
- Fix lexing bugs with "-quoted strings and -continuation.
- Fix interpretation of n etc. in "-quoted strings.
- Fix bug which ignored erroneous read/write after ignore-fd/reject-fd.

ELFIO is a C++ library for reading and generating files in the ELF binary format. This library is unique and not based on any other product. It is also platform independent. The library uses standard ANSI C++ constructions and runs on a wide variety of architectures.
While the librarys implementation does make your work easier: a basic knowledge of the ELF binary format is required. Information about ELF is included in the TIS (Tool Interface Standards) documentation you received with the librarys source code.
The ELFIO library consists of two independent parts: ELF File Reader (IELFI) and ELF Producer (IELFO). Each is represented by its own set of interfaces. The library does not contain any classes that need to be explicitly instantiated. ELFIO itself provides the interfaces that are used to access the librarys functionality.
To make the program recognize all ELFIO interface classes, the ELFIO.h header file is needed. This header file defines all standard definitions from the TIS documentation.
#include < ELFIO.h >
This chapter will explain how to work with the reader component of the ELFIO library. The first step is to get a pointer onto the ELF File Reader:
IELFI* pReader;
ELFIO::GetInstance()->CreateELFI( &pReader );
Now, that there is a pointer on the IELFI interface: initialize the object by loading the ELF file:
char* filename = "file.o";
pReader->Load( filename );
From here, there is access to the ELF header. This makes it possible to request file parameters such as encoding, machine type, entry point, etc. To get the encoding of the file use:
unsigned char encoding = pReader->GetEncoding();
Please note: standard types and constants from the TIS document are defined in the ELFTypes.h header file. This file is included automatically into the project. For example: ELFDATA2LSB and ELFDATA2MSB constants define a value for little and big endian encoding.
ELF binary files consist of several sections. Each section has its own responsibility: some contain executable code; others describe program dependencies; others symbol tables and so on. See the TIS documentation for a full description of each section.
To see how many sections the ELF file contains, including their names and sizes, is demonstated in the following code:
int nSecNo = pReader->GetSectionsNum();
for ( int i = 0; i < nSecNo; ++i ) { // For all sections
const IELFISection* pSec = pReader->GetSection( i );
std::cout GetName() GetSection( .symtab );
Second, create a symbol section reader:
IELFISymbolTable* pSymTbl = 0;
pReader->CreateSectionReader( IELFI::ELFI_SYMBOL,
pSec,
(void**)&pSymTbl );
And finally, use the section reader to process all entries (print operations are omitted):
std::string name;
Elf32_Addr value;
Elf32_Word size;
unsigned char bind;
unsigned char type;
Elf32_Half section;
int nSymNo = pSymTbl->GetSymbolNum();
if ( 0 < nSymNo ) {
for ( int i = 0; i < nSymNo; ++i ) {
pSymTbl->GetSymbol( i, name, value, size,
bind, type, section );
}
}
pSymTbl->Release();
pSec->Release();
All interfaces from the ELFIO library should be freed after use. Each interface has a Release() function. It is not enough to only free the high level interface because one of the sections or readers will still be held and its resources will not be cleared.
The interfaces are freed immediately after their use, in this example we will free only the pReader object:
pReader->Release();
The source code for the ELF Dumping Utility can be found in the "Examples" directory; included there are more examples on how to use different ELFIO reader interfaces.
Enhancements:
- Fixes endian conversion in the ELFIRelocation and ELFINote sections adapters.

Shale is a modern web application framework, fundamentally based on JavaServer Faces. Architecturally, Shale is a set of loosely coupled services that can be combined as needed to meet particular application requirements.
Shale provides additional functionality such as application event callbacks, dialogs with conversation-scoped state, a view technology called Clay, annotation-based functionality to reduce configuration requirements and support for remoting. Shale also provides integration links for other frameworks, to ease development when combinations of technologies are required.
Main features:
- View Controller - Convenient mechanism to associate a "backing" Java class with each JavaServer Faces view in an application, with predefined event handers for events significant to an application developer.
- Dialog Manager - Mechanism to define a "conversation" with a user that requires multiple HTTP requests to implement, modeled as a state diagram.
- Application Manager - Traditional application wide front controller features that should be applied to every request.
- Validation - Integration with the Jakarta Commons Validator Framework, supporting both client side and server side validations based on a single set of configured validation rules.
- Remoting - Server side support for applications that employ AJAX (Asynchronous JavaScript and XML) style interactions.
- Spring Integration - Integration with the Spring Framework, allowing the use of Springs dependency injection framework to create JavaServer Faces managed beans.
- Clay - An alternative to JSP where you define views in pure HTML, in a fashion similar to Tapestry and Facelets. An innovative sub-framework for supporting the configuration of reusable subtrees of JavaServer Faces components for customizable reuse.
- Test Framework - Set of mock objects and JUnit test case base classes suitable for testing both the framework classes themselves, as well as application components built on top of the framework.
- Tiger Extensions - Optional add-on library that adds additional ease-of-use features for Shale applications that run on Java Standard Edition 5 (popularly known by its code name during development, "tiger").

xtarot project is an application which plays Tarot cards.

It tells your fortune with virtual Tarot cards. Three tarot spreads are available via a simple user interface.

xtarot is designed to be as flexable as possible.

For this reason I have now split it into two packages. This should be very good for people who want to keep up with the latest version because you now no longer need to download over 3 Meg of graphics every time there is a change to the code!