Free binary clock software for linux

Beat Clock is a simple internet Beat Clock.

Internet time or Beat time is a system developed by Swatch (the watch company) where you devide the day into 1000 beats and use these units to messure the passage of time.

All Beat clocks display the same time dispite local times zones. GMT+1 is used as the reference zone. People can use beat time to help cordinate events with people that may span many times zones or political time zones without having to know what the local time is.

This can be most usfull if you dont know if someone elses country follows a form of Daylight Savings.

Beat Clock is my creation and it is my wish that it be protected with all rights entitled to me as its creator. Use of Beat Clock is at the users expense. Dont blame me if something goes wrong. I make all the best effort to correct all bugs but I do not guaranty that Beat Clock is perfect. No human designed system is perfect. Errors will happen so use at your own risk (please notify me of bugs so I can improve the software).

Simple Alarm Clock is a simple alarm clock SuperKaramba theme. I made this because I couldnt find one. To set the alarm scroll up for minutes and down for hours. The clock is set to update every minute so that means it can be off by a minute.

Make sure to test your alarm command with the top button. Starting amarok doesnt do much good if your speakers are off. It isnt perfect so if you find problems let me know.

Tips:
If you want kttsd to talk longer do something like this: good. morning. itt. iis. time. tooo. wake. upp. beep. beep. beep.

tbclock is a dirty little app that displays a full screen binary clock in your terminal (using curses). It doesnt support resizing (yet).
It is quite simple and features modules like guessbin a little game and chrono a timer with tenth of seconds. It was a fun way to learn curses.
Installation
make
make install
Enhancements:
- Resizing is now working. You can change the display mode on the fly with the "a" key in "clock" and "chrono".
- Colors can be selected from the command line with the -H and -M options.
- Decimal help is now triggered with -e instead of -H.
- The new -p option allows you to display time in AM/PM style instead of 24h.
- A new build system is used, so gmake is not needed.
- Signedness in mod_clock was fixed for Linux/PPC.
- A display bug in small terms was fixed.

Tree::Binary is a Object Oriented Binary Tree for Perl.

SYNOPSIS

use Tree::Binary;

# a tree representaion of the expression:
# ((2 + 2) * (4 + 5))
my $btree = Tree::Binary->new("*")
->setLeft(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("2"))
->setRight(Tree::Binary->new("2"))
)
->setRight(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("4"))
->setRight(Tree::Binary->new("5"))
);
# Or shown visually:
# +---(*)---+
# | |
# +-(+)-+ +-(+)-+
# | | | |
# (2) (2) (4) (5)

# get a InOrder visitor
my $visitor = Tree::Binary::Visitor::InOrderTraversal->new();
$btree->accept($visitor);

# print the expression in infix order
print $visitor->getAccumulation(); # prints "2 + 2 * 4 + 5"

# get a PreOrder visitor
my $visitor = Tree::Binary::Visitor::PreOrderTraversal->new();
$btree->accept($visitor);

# print the expression in prefix order
print $visitor->getAccumulation(); # prints "* + 2 2 + 4 5"

# get a PostOrder visitor
my $visitor = Tree::Binary::Visitor::PostOrderTraversal->new();
$btree->accept($visitor);

# print the expression in postfix order
print $visitor->getAccumulation(); # prints "2 2 + 4 5 + *"

# get a Breadth First visitor
my $visitor = Tree::Binary::Visitor::BreadthFirstTraversal->new();
$btree->accept($visitor);

# print the expression in breadth first order
print $visitor->getAccumulation(); # prints "* + + 2 2 4 5"

# be sure to clean up all circular references
$btree->DESTROY();

This module is a fully object oriented implementation of a binary tree. Binary trees are a specialized type of tree which has only two possible branches, a left branch and a right branch. While it is possible to use an n-ary tree, like Tree::Simple, to fill most of your binary tree needs, a true binary tree object is just easier to mantain and use.

Binary Tree objects are especially useful (to me anyway) when building parse trees of things like mathematical or boolean expressions. They can also be used in games for such things as descisions trees. Binary trees are a well studied data structure and there is a wealth of information on the web about them.

This module uses exceptions and a minimal Design By Contract style. All method arguments are required unless specified in the documentation, if a required argument is not defined an exception will usually be thrown. Many arguments are also required to be of a specific type, for instance the $tree argument to both the setLeft and setRight methods, must be a Tree::Binary object or an object derived from Tree::Binary, otherwise an exception is thrown. This may seems harsh to some, but this allows me to have the confidence that my code works as I intend, and for you to enjoy the same level of confidence when using this module. Note however that this module does not use any Exception or Error module, the exceptions are just strings thrown with die.

This object uses a number of methods copied from another module of mine, Tree::Simple. Users of that module will find many similar methods and behaviors. However, it did not make sense for Tree::Binary to be derived from Tree::Simple, as there are a number of methods in Tree::Simple that just wouldnt make sense in Tree::Binary. So, while I normally do not approve of cut-and-paste code reuse, it was what made the most sense in this case.

Scriptol to binary Compiler is a C++ native compiler.

Installation:

It is better to install Scriptol at root of a disk, for example:
c:scriptolc

Once the archive is extracted into the scriptolc directory, you have just to change to this directory to run the compiler.

To use the compiler at command line from any directory, you have to put the compiler into the path variable.

The setup script installs required file into sub-directories, or into the directory given as argument. Before to use the compiler, you have to read the licence, in the doc
directory: licence.html.

Usage:

Just type:
./solc mysource

Type "solc" only to list the options.

If your program is a multi-file project, the source given as parameter must be the main source file, the compiler will know dependencies from "include" statements and will build what is needed.

Exemples:

Type from the main scriptol directory:
./solc -bre demosfibo

Configuring:

By editing the solc.ini file, you may change the second pass compiler (you may have to rebuild the libsol library for this compiler), change the options of the compiler or add header files to include.

To add header files, just add "header=someheader.hpp" lines into the config file.

A xxx.cfg file may be written for each project main source beeing xxx, and if present, it overloads the solc.ini file.

XCclock is a small application which offers a nice clock and an alarm function.

Simply push the right mouse button above the clock and select something in the popup menu.

To run and build the Xclasses X11 layout library is required.

Usage of XCclock:

xclock [-q] [-m] [-t]

q : disables quit functions in menus
m : disables minutes in clock (usefull if you use a really small one)
t : disables the textbox below the clock that shows the alarm time

Convert::Binary::C is a Binary Data Conversion using C Types.

SYNOPSIS

Simple
use Convert::Binary::C;

#---------------------------------------------
# Create a new object and parse embedded code
#---------------------------------------------
my $c = Convert::Binary::C->new->parse( DEC, day => 24 };

my $packed = $c->pack( Date, $date );
Advanced
use Convert::Binary::C;
use Data::Dumper;

#---------------------
# Create a new object
#---------------------
my $c = new Convert::Binary::C ByteOrder => BigEndian;

#---------------------------------------------------
# Add include paths and global preprocessor defines
#---------------------------------------------------
$c->Include( /usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include,
/usr/include )
->Define( qw( __USE_POSIX __USE_ISOC99=1 ) );

#----------------------------------
# Parse the time.h header file
#----------------------------------
$c->parse_file( time.h );

#---------------------------------------
# See which files the object depends on
#---------------------------------------
print Dumper( [$c->dependencies] );

#-----------------------------------------------------------
# See if struct timespec is defined and dump its definition
#-----------------------------------------------------------
if( $c->def( struct timespec ) ) {
print Dumper( $c->struct( timespec ) );
}

#-------------------------------
# Create some binary dummy data
#-------------------------------
my $data = "binaryteststring";

#--------------------------------------------------------
# Unpack $data according to struct timespec definition
#--------------------------------------------------------
if( length($data) >= $c->sizeof( timespec ) ) {
my $perl = $c->unpack( timespec, $data );
print Dumper( $perl );
}

#--------------------------------------------------------
# See which member lies at offset 5 of struct timespec
#--------------------------------------------------------
my $member = $c->member( timespec, 5 );
print "member( timespec, 5 ) = $membern";

Convert::Binary::C is a preprocessor and parser for C type definitions. It is highly configurable and should support arbitrarily complex data structures. Its object-oriented interface has pack and unpack methods that act as replacements for Perls pack and unpack and allow to use the C types instead of a string representation of the data structure for conversion of binary data from and to Perls complex data structures.

Actually, what Convert::Binary::C does is not very different from what a C compiler does, just that it doesnt compile the source code into an object file or executable, but only parses the code and allows Perl to use the enumerations, structs, unions and typedefs that have been defined within your C source for binary data conversion, similar to Perls pack and unpack.

Beyond that, the module offers a lot of convenience methods to retrieve information about the C types that have been parsed.