Free simple ui software for linux

Simple Equation makes it simple to put equations on the Web. Simple Equation project does not bother the user with the layout of the equation; it just displays it. The focus is on being simple to use.

One of the biggest obstacles to using mathematical expressions on the web is that the user currently needs to worry about layout. Web users should not have to learn a layout engine.

The class is built as a recursive parser. It is pretty easy to add operations to the parser, but it will not scale to a huge set of operations. That is OK, we want to keep things simple. At some point a layout engine may be required for a complexity level. This is not a layout engine.

Currently, only graphical output is generated, but it is hoped that MathML output can be generated automatically if the browser supports it instead of the graphic.

LJ::Simple is a Perl module to provide a simple OOP-based API for accessing the LiveJournal system.
Main features:
- Log into LiveJournal
- Post a journal entry
- Edit a journal entry
- Delete a journal entry
Example
The following example posts a simple message into the test LiveJournal using the LJ::Simple::QuickPost method.
use LJ::Simple;
LJ::Simple::QuickPost(
user => "test",
pass => "test",
entry => "Just a simple entry",
) || die "$0: Failed to post entry: $LJ::Simple::errorn";
The next example shows how to post an entry into the test LiveJournal using the complete, object-based, interface:
use LJ::Simple;
my $lj = new LJ::Simple ({
user => "test",
pass => "test",
});
(defined $lj)
|| die "$0: Failed to log into LiveJournal: $LJ::Simple::errorn";
my %Event=();
$lj->NewEntry(%Event) ||
die "$0: Failed to create new entry: $LJ::Simple::errorn";
my $entry=SetMood(%Event,"happy")
|| die "$0: Failed to set mood: $LJ::Simple::errorn";
$lj->Setprop_nocomments(%Event,1);
my ($item_id,$anum,$html_id)=$lj->PostEntry(%Event);
(defined $item_id)
|| die "$0: Failed to post journal entry: $LJ::Simple::errorn";

HTML::Simple is a simple, dependency free module for generating HTML (and XML).

SYNOPSIS

Note: It turns out that TOMC owns the HTML::Simple namespace so Ive moved development of this module to HTML::Tiny. Please use HTML::Tiny in preference to this module.

use HTML::Simple;

my $h = HTML::Simple->new;

# Generate a simple page
print $h->html(
[
$h->head( $h->title( Sample page ) ),
$h->body(
[
$h->h1( { class => main }, Sample page ),
$h->p( Hello, World, { class => detail }, Second para )
]
)
]
);

# Outputs
< html>
< head>
< title>Sample page< /title>
< /head>
< body>
< h1 class="main">Sample page< /h1>
< p>Hello, World< /p>
< p class="detail">Second para< /p>
< /body>
< /html>

DFA::Simple is a Perl module to implement simple Discrete Finite Automata.

SYNOPSIS

my $Obj = new DFA::Simple
or
my $Obj = new DFA::Simple $Transitions;
or
my $Obj = new DFA::Simple $Actions, $StateRules;

$Obj->Actions = [...];
my $Trans = $LP->Actions;

$Obj->StateRules = [...];
my $StateRules = $LP->StateRules;

my $Obj = new DFA::Simple $Actions,[States];

This creates a simple automaton with a finite number of individual states. The short version is that state numbers are just indices into the array.

The state basically binds the rest of the machine together:

1. There might be something you want done whenever you enter a given state (Transition Table)
2. There might be something you want done whenever you leave a given state (Transition Table)
3. You can go to some states from the current state (Action table)
4. There are tests to decide whether you should go to that new state (Action table)
5. There are conditional tasks you can do while sitting in that new state (Action table)

This structure may remind you of the SysV run-level concepts. It is very similar.
At run time you dont typically feed any state numbers to the finite machine; you ignore them. Rather your program may read inputs or such. The tests for the state transition would examine this input, or some other variables to decide which new state to go to. Whenever your code has gotten enough input, it would call the Check_For_NextState() method. This method runs through the tests, and carries out the state transitions ("firing the rules").

JOpt Simple is a simple, test-driven command line parser for Java programs. JOpt Simple supports POSIX getopt() and GNU getopt_long().
What command line switch syntax does JOpt Simple support?
As closely as possible, JOpt Simple attempts to adhere to the rules of POSIX getopt() and GNU getopt_long(). You can find a brief summary of these rules in the javadoc for class OptionParser.
Enhancements:
- Minor internal changes.

Keep IT Simple is a simple, customizable, Conky-like theme for Superkaramba featuring a mail-checker and a temperatures monitor.
Enjoy!
It monitors:
- CPU usage
- HDD usage
- Network load
- Memory load
- e-mail inbox

PGPLOT::Simple is a simple Perl Interface to PGPLOT.

SYNOPSIS

use strict;
use PGPLOT::Simple qw(:essential);

die "Must provide a filename.n" unless @ARGV;

my $filename = shift;
chomp $filename;

unless ( $filename =~ /.ps$/ ) {
$filename .= ".ps";
}

set_begin({
file => "$filename/CPS",
});

set_environment({
x_min => 0,
x_max => 50,
y_min => 0,
y_max => 10,
});

write_label({
title => A Simple Graph Using PGPLOT::Simple,
color => Blue,
font => Italic,
});

draw_points({
x => [1, 3, 12, 32, 40],
y => [1, 5, 5, 3, 9],
color => Blue,
width => 20,
});

draw_error_bars({
x => [20],
y1 => [4],
y2 => [6],
terminal => 10,
width => 10,
color => Orange,
});

set_end;

PGPLOT::Simple is a simple interface to the PGPLOT library ala Perl, making simple things easy and difficult things possible.

Why simple? Because it has a simple and intiutive interface to the most common things you will need from PGPLOT, but also allowing you low-level access to the PGPLOT library.

PHP Simple Informer is a very simple network services monitoring application written in PHP. PHP Simple Informer can be run as a command line application (PHP compiled as cgi is required) or as a web php file.
Although is very simple, it does its function very well. Is very easy to configure with a single file and a couple of simple lines.
I dont know if this is going to be useful for anybody, but its for me. I have been testing several applications, and all of them are more complex that what I need or they dont perform so simple tasks.
Main features:
- Very simple installation and configuration: one single config file and done.
- Multiple hosts configuration
- Support for special features for services: mysql, http, https.
- Multiple contacts configuration
- Alerts are sent by email or with an executed external command.
- Logs issues to log file.
- Report / status web page.