Free insert into software for linux

KDE DivX subtitles editor is a good solution for people who create and edit subtitles for DivX movies.
It is able to edit,convert subtitles between different formats, and test subtitles using some linux DivX player (at present Mplayer).
Enhancements:
- After "Save As" correct name on the bar is displayed
- Some compilation problems fixed
- Fixed number of columns in new file after spliting a file
- Fixed problem with editing file created by spliting another one
- Some "segmentation fault" fixes
- Changed "Insert row under" into "Insert row above"

GD::Image::Orientation is a Perl extension for managing a GD::Images vertical or horizontal orientation (shapewise).

SYNOPSIS

use GD::Image::Orientation;

for(@images) {
my $img = GD::Image->new($_) or die $!;
$dbh->do("INSERT INTO photogallery.metainfo (Id,Orientation,File) VALUES (NULL,$img->isvertical,$dbh->quote($_))") or die $dbh->errstr;
}

Adds functionality to GD by adding class methods to determine orientation in boolean terms or in a string. Also included methods to set an images orientation;

isvertical()
$img->isvertical()

Returns true if an images height is greater than its width. Call it with a true argument:

$img->isvertical(1)

and it returns true if an images height is greater than its width or it is square.

ishorizontal()
$img->ishorizontal()

Returns true if an images width is greater than its height. Call it with a true argument:

$img->ishorizontal(1)

and it returns true if an images width is greater than its height or it is square.

issquare()

Returns true if an images width and height are the same.

orientation()

Returns a string describing its orientation in English. It returns horizontal, vertical, or square

print The image you uploaded is . $img->orientation . "
n";
vertical()

If the image is horizontal it is rotated 90 degrees clockwise to become vertical. Call it with a true argument and its rotated 90 degrees counter clockwise to become vertical.

It returns a new GD::Image object if modified or the original object if its already vertical or square.

my $vert_img = $img->vertical; # rotate $img clockwise 90 degrees if its horizontal
my $vert_img = $img->vertical(1); # rotate $img counter clockwise 90 degrees if its horizontal
$img = $img->vertical; # rotate $img clockwise 90 degrees if its horizontal, modifying the original object
If the second argument is true it will rotate it even if its sqare:
my $vert_img = $img->vertical(0,1); # rotate $img clockwise if its horizontal or square
my $vert_img = $img->vertical(1,1); # rotate $img counter clockwise if its horizontal or square

horizontal()

If the image is vertical it is rotated 90 degrees clockwise to become horizontal. Call it with a true argument and its rotated 90 degrees counter clockwise to become horizontal.

It returns a new GD::Image object if modified or the original object if its already horizontal or square.

my $hori_img = $img->horizontal; # rotate $img clockwise 90 degrees if its vertical
my $hori_img = $img->horizontal(1); # rotate $img counter clockwise 90 degrees if its vertical
$img = $img->horizontal; # rotate $img clockwise 90 degrees if its vertical, modifying the original object

If the second argument is true it will rotate it even if its square:

my $vert_img = $img->horizontal(0,1); # rotate $img clockwise if its vertical or square
my $vert_img = $img->horizontal(1,1); # rotate $img counter clockwise if its vertical or square

Tree::Binary::Search is a binary search tree for Perl.

SYNOPSIS

use Tree::Binary::Search;

my $btree = Tree::Binary::Search->new();

$btree->useNumericComparison();

$btree->insert(5 => "Five");
$btree->insert(2 => "Two");
$btree->insert(1 => "One");
$btree->insert(3 => "Three");
$btree->insert(4 => "Four");
$btree->insert(9 => "Nine");
$btree->insert(8 => "Eight");
$btree->insert(6 => "Six");
$btree->insert(7 => "Seven");

# this creates the following tree:
#
# +-------(5)----------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +----(8)
# | |
# (4) (6)-+
# |
# (7)
#

$btree->exists(7); # return true

$btree->update(7 => "Seven (updated)");

$btree->select(9); # return Nine

$btree->min_key(); # returns 1

$btree->min(); # returns One

$btree->max_key(); # return 9

$btree->max(); # return Nine

$btree->delete(5);

# this results in the following tree:
#
# +-------(6)-------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +-(8)
# | |
# (4) (7)
#

This module implements a binary search tree, which is a specialized usage of a binary tree. The basic principle is that all elements to the left are less than the root, all elements to the right are greater than the root. This reduces the search time for elements in the tree, by halving the number of nodes that need to be searched each time a node is examined.

Binary search trees are a very well understood data-structure and there is a wealth of information on the web about them.

Trees are a naturally recursive data-structure, and therefore, tend to lend themselves well to recursive traversal functions. I however, have chosen to implement the tree traversal in this module without using recursive subroutines. This is partially a performance descision, even though perl can handle theoreticaly unlimited recursion, subroutine calls to have some overhead. My algorithm is still recursive, I have just chosen to keep it within a single subroutine.

muchine project is a small virtual machine that comes with its own assembler.
It features stackdump, memdump, and variable execution speed. Its actually a kind of programming exercise, and has a clean coding style.
Thus, it may be used for educational purposes.
Enhancements:
- GPL License notes inserted into source.
- Insert the vim:ts=3:sw=3 statements into all source files.
- Make it ready for uploading to sourveforge.net.

Libtext is a C library for creating, reading, and performing operations on growable text / string buffer objects with optional error callbacks. Libtext performs actions such as append, delete, find, get, insert, prepend, replace, and reverse.

Libtext can also append, insert, overwrite, and prepend printf style formats. Further options include rejecting binary characters, setting a maximum size, and setting a mask that controls for which errors the callback will be executed.

All of which can be set for each individual object. Libtext is general purpose enough that it can be used to build more complex routines, while still being simple enough to use as is in rudimentary applications with little effort, learning the API within minutes.

SQL::Interpolate is a Perl module to interpolate Perl variables into SQL statements.

SYNOPSIS

use SQL::Interpolate qw(:all);

# Some sample data to interpolate:
my $s = blue; my @v = (5, 6);

# Variable references are transformed into bind parameters.
# The most basic usage involves scalarrefs (as well as arrayrefs
# preceeded by "IN").
my ($sql, @bind) = sql_interp
SELECT * FROM table WHERE x = , $s, AND y IN, @v;
# RESULT:
# $sql = SELECT * FROM mytable WHERE x = ? AND y IN (?, ?)
# @bind = ($s, @v);

# In certain contexts, an arrayref or hashref acts as a single tuple:
my ($sql, @bind) = sql_interp
INSERT INTO table, {x => $s, y => 1};
# RESULT:
# $sql = INSERT INTO mytable (x, y) VALUES(?, ?);
# @bind = ($s, 1);
my ($sql, @bind) = sql_interp
UPDATE table SET, {x => $s, y => 1}, WHERE y , 2;
# RESULT:
# $sql = UPDATE mytable SET x = ?, y = ? WHERE y ?;
# @bind = ($s, 1, 2);

# In general, a hashref provides a shortcut for specifying
# a logical-AND construction:
my ($sql, @bind) = sql_interp
SELECT * FROM table WHERE, {x => $s, y => @v};
# RESULT:
# $sql = SELECT * FROM mytable WHERE (x = ? AND y IN (?, ?));
# @bind = ($s, @v);

# In general, an arrayref acts as a result set or reference to
# a temporary table:
my ($sql, @bind) = sql_interp
[[1, 2], [4, 5]], UNION, [{x => 2, y => 3}, {x => 5, y => 6};
# RESULT:
# $sql = (SELECT ?, ? UNION ALL SELECT ?, ?) UNION
# (SELECT ? AS x, ? AS y UNION ALL SELECT ?, ?);
# @bind = (1,2,4,5, 2,3,5,6);
my ($sql, @bind) = sql_interp
SELECT * FROM, [[1, 2], [4, 5]]
# RESULT:
# $sql = SELECT * FROM (SELECT ?, ? UNION ALL SELECT ?, ?) AS tbl0;
# @bind = (1,2,4,5);

# Each result above is suitable for passing to DBI:
my $res = $dbh->selectall_arrayref($sql, undef, @bind);

# Besides these simple techniques shown, SQL-Interpolate includes
# various optional modules to further integrate SQL::Interpolate with
# DBI and streamline the syntax with source filtering and macros (see
# the L section):

use DBIx::Interpolate FILTER => 1;
...
my $rows = $dbx->selectall_arrayref(sql[
SELECT thid, date, title, subject
FROM threads
WHERE date > $x AND subject IN @subjects
]);

simple instant messaging (sim) is an IRC client specialized for use with bitlbee. It is based on sic (http://suckless.org). It reads commands from standard input and prints all server output to standard output.
simple instant messaging also multiplexes all channel traffic into one output, so you dont have to switch to different channel buffers. sim must be customized by editing its source code to insert the correct username, server, password, and identification information.
Enhancements:
- The command operator was changed.
- Some code simplifications were done.
- The output format was adjusted.