Free shift software for linux

ShiftJIS::Regexp contains regular expressions in Shift-JIS.

SYNOPSIS

use ShiftJIS::Regexp qw(:all);

match($string, p{Hiragana}{2}p{Digit}{2});
match($string, pH{2}pD{2});
# these two are equivalent:

This module provides some functions to use regular expressions in Shift-JIS on the byte-oriented perl.

The legal Shift-JIS character in this module must match the following regular expression:

[x00-x7FxA1-xDF]|[x81-x9FxE0-xFC][x40-x7Ex80-xFC]

To avoid false matching in multibyte encoding, this module uses anchoring technique to ensure each matching position places at the character boundaries.

cf. perlfaq6, "How can I match strings with multibyte characters?"

Functions

re(PATTERN)

re(PATTERN, MODIFIER)

Returns a regular expression parsable by the byte-oriented perl.

PATTERN is specified as a string. MODIFIER is specified as a string. Modifiers in the following list are allowed.

i case-insensitive pattern (only for ascii alphabets)
I case-insensitive pattern (greek, cyrillic, fullwidth latin)
j hiragana-katakana-insensitive pattern (but halfwidth katakana
are not considered.)

s treat string as single line
m treat string as multiple lines
x ignore whitespace (i.e. [x20nrtf]) unless backslashed
or inside a character class; but comments are not recognized!

o once parsed (not compiled!) and the result is cached internally.
o modifier
while ( ) {
print replace($_, (perl), $1, igo);
}
is more efficient than

while ( ) {
print replace($_, (perl), $1, ig);
}

because in the latter case the pattern is parsed every time
whenever the function is called.

match(STRING, PATTERN)

match(STRING, PATTERN, MODIFIER)

An emulation of m// operator aware of Shift-JIS. But, to emulate @list = $string =~ m/PATTERN/g, the pattern should be parenthesized (capturing parentheses are not added automatically).

@list = match($string, pH, g); # wrong; returns garbage!
@list = match($string,(pH),g); # good
PATTERN is specified as a string. MODIFIER is specified as a string.
i,I,j,s,m,x,o please see re().

g match globally
z tell the function the pattern matches an empty string
(sorry, due to the poor auto-detection)

replace(STRING or SCALAR REF, PATTERN, REPLACEMENT)

replace(STRING or SCALAR REF, PATTERN, REPLACEMENT, MODIFIER)

An emulation of s/// operator but aware of Shift-JIS.
If a reference to a scalar is specified as the first argument, substitutes the referent scalar and returns the number of substitutions made. If a string (not a reference) is specified as the first argument, returns the substituted string and the specified string is unaffected.

MODIFIER is specified as a string.

i,I,j,s,m,x,o please see re().
g,z please see match().

jsplit(PATTERN or ARRAY REF of [PATTERN, MODIFIER], STRING)

jsplit(PATTERN or ARRAY REF of [PATTERN, MODIFIER], STRING, LIMIT)

An emulation of CORE::split but aware of Shift-JIS.
In scalar/void context, it does not split into the @_ array; in scalar context, only returns the number of fields found.
PATTERN is specified as a string. But as PATTERN has no special meaning; it splits the string on a single space similarly to CORE::split / /.

When you want to split the string on whitespace, pass an undefined value as PATTERN or use the splitspace() function.

jsplit(undef, " x81x40 This is x81x40 perl.");
splitspace(" x81x40 This is x81x40 perl.");
# (This, is, perl.)

If you want to pass pattern with modifiers, specify an arrayref of [PATTERN, MODIFIER] as the first argument. You can also use "Embedded Modifiers").

MODIFIER is specified as a string.

i,I,j,s,m,x,o please see re().

splitspace(STRING)

splitspace(STRING, LIMIT)

This function emulates CORE::split( , STRING, LIMIT). It returns a list given by split STRING on whitespace including "x81x40" (IDEOGRAPHIC SPACE). Leading whitespace characters do not produce any field.

Note: splitspace(STRING, LIMIT) is equivalent to jsplit(undef, STRING, LIMIT).

splitchar(STRING)

splitchar(STRING, LIMIT)

This function emulates CORE::split(//, STRING, LIMIT). It returns a list given by split of STRING into characters.
Note: splitchar(STRING, LIMIT) is equivalent to jsplit(, STRING, LIMIT).

Superswitcher project is a more feature-ful replacement of the Alt-Tab window switching behavior.

SuperSwitcher is a (more feature-ful) replacement for the Alt-Tab window
switching behavior and Ctrl-Alt-Left/Right/Up/Down workspace switching behavior that is currently provided by Metacity.

When running, use the "Super" key (also known as the "Windows" key) to switch between windows and workspaces. This key is usually found between the Ctrl and Alt keys on the keyboard.

Super-Tab works just like Alt-Tab does (with and without Shift), but also:

Super-Up and Super-Down cycles through all windows in the current workspace in a fixed order (as opposed to Alt-Tab or Super-Tab, whose list of windows is ordered by most-recently-used first - which is good if you want recently used windows, but its clumsy to cycle through, for example, all three or four windows in the one workspace). Hold down Shift to re-order the list instead of switching between windows.

Super-PageUp and Super-PageDown maximize and minimize the active window (or restores them if it was already maximized or minimized). Super-Ctrl-PageUp and Super-Ctrl-PageDown do this to all windows on the current workspace, not just the active one.

Super-Left and Super-Right cycles through your workspaces. Hold down Shift
to also bring across the active window into the new workspace. Hold down Shift and Ctrl to bring across all windows from one workspace to the next. Unlike Metacitys Ctrl-Alt-Left and Ctrl-Alt-Right, this "loops" so that, when you get to the end of the list, you cycle back to the start.

Super-F1 moves to workspace number 1, Super-F2 moves to workspace number 2, and so on, up to Super-F12. Again, hold down Shift to bring across the active window, and both Shift and Ctrl to bring across a flock of windows, just like as described above.

Super-Insert creates a new, empty workspace. Again, hold down Shift to also
bring across the active window (if there is one) into the new workspace.

Super-Delete deletes the current workspace, if it is empty. Super-Shift-Delete will delete all empty workspaces, down to a minimum of one.

Super-Escape closes the active window. Super-Ctrl-Escape will close all windows on this workspace.

Whilst holding down Super, typing regular letters or numbers will show you only those windows whose titles match that pattern. Pressing Enter (whilst still holding down Super) will then cycle through the matches, regardless of which workspace you are on. For example, if you have a lot of windows open, and you want to get to your web browser window that is showing planet.gnome.org, then hold down Super, then type "p" "l" "a" "Enter" and then release the Super key.

Shift-Enter goes in the other direction than Enter (i.e., up and left with
Shift, versus down and right without Shift). Use the Space key to enter
multiple word fragments, such as "pla gn", to further refine your search.

Finally, when holding down Super, click on image or text representing a window or a workspace to activate it.

Building, Installing, Running:

To build (and install), the standard

./autogen.sh --prefix=/usr
make
(and optionally) sudo make install

should work. After that, just run src/superswitcher. This will listen
indefinitely for Super key presses, until you kill the process (e.g., with
Ctrl-C).

SuperSwitcher is best enjoyed if you automatically start the program
whenever you log in. To do this, from System -> Preferences -> Sessions, go to the Startup Programs tab and add superswitcher.

Term::ShellUI is a fully-featured shell-like command line environment.

SYNOPSIS

use Term::ShellUI;
my $term = new Term::ShellUI(
commands => {
"cd" => {
desc => "Change to directory DIR",
maxargs => 1, args => sub { shift->complete_onlydirs(@_); },
proc => sub { chdir($_[0] || $ENV{HOME} || $ENV{LOGDIR}); },
},
"pwd" => {
desc => "Print the current working directory",
maxargs => 0, proc => sub { system(pwd); },
},
"quit" => {
desc => "Quit using Fileman", maxargs => 0,
method => sub { shift->exit_requested(1); },
}},
history_file => ~/.gdbui-synopsis-history,
);
print Using .$term->{term}->ReadLine."n";
$term->run();

Term::ShellUI uses the history and autocompletion features of Term::ReadLine to present a sophisticated command-line interface to the user. It tries to make every feature that one would expect to see in a fully interactive shell trivial to implement. You simply declare your command set and let ShellUI take care of the heavy lifting.
This module was previously called Term::GDBUI.

ProgressMonitor is a flexible and configurable framework for providing feedback on how a long-running task is proceeding.

SYNOPSIS

use strict;
use warnings;

use Time::HiRes qw(usleep);

use ProgressMonitor::Stringify::ToStream;
use ProgressMonitor::Stringify::Fields::Bar;
use ProgressMonitor::Stringify::Fields::Fixed;
use ProgressMonitor::Stringify::Fields::Percentage;

sub someTask
{
my $monitor = shift;

$monitor->prepare();
$monitor->begin(100);
for (1 .. 40)
{
usleep(100_000);
$monitor->tick(1);
}

anotherTask($monitor->subMonitor({parentTicks => 20}));

for (1 .. 40)
{
usleep(100_000);
$monitor->tick(1);
}

$monitor->end();
}

sub anotherTask
{
my $monitor = shift;

$monitor->prepare();
$monitor->begin(3000);

for (1 .. 3000)
{
usleep(1_000);
$monitor->tick(1);
}

$monitor->end();
}

someTask(
ProgressMonitor::Stringify::ToStream->new(
{
fields =>
[
ProgressMonitor::Stringify::Fields::Bar->new,
ProgressMonitor::Stringify::Fields::Fixed->new,
ProgressMonitor::Stringify::Fields::Percentage->new,
]
}
)
);

stabilize is a tool for stabilizing shaking movies.

Sometimes videos are recorded with a free hand, which produces shaky movies.

This program compares each frame with previous frames and tries to find out to which offset it should shift that frame to make the movie more stable.

Usage

Compile it:

$ g++ -o stabilize stabilize.cpp -Llib -lavformat -lavcodec -lz -I/usr/include/ffmpeg/

Run it:

$ ./stabilize test.avi | ffmpeg -f imagepipe -img pnm -i - -sameq output.avi

Jar::Signer Perl module ease the process of creating a signed Jar file.

SYNOPSIS

# using FindBin is just a suggestion.
use FindBin qw( $RealBin );
use Jar::Signer;
my $signer = Jar::Signer->new;
# location of the keystore, created if needed.
$signer->keystore("$RealBin/MyKeyStore");
# dname properties of the certificate.
$signer->dname("CN=Mark Southern, O=My Corporation, L=My State, C=USA");
# name for .fingerprint and ..cert files, created if needed.
$signer->alias("$RealBin/MyCert");
# the Jar file that we want to sign.
$signer->jar(shift);
# if signed_jar is undefined then the default is basename.signed.jar where basename is the basename of the Jar file.
$signer->signed_jar(shift);
# create the signed Jar.
$signer->process;

This module, and the script that uses it make it a lot simpler to generate signed Jar files for use in Java applets etc. It steps through all the needed jar, jarsigner and keytool command lines.

Sub::Assert - Design-by-contract like pre- and postconditions, etc.

SYNOPSIS

use Sub::Assert;

sub squareroot {
my $x = shift;
return $x**0.5;
}

assert
pre => $PARAM[0] >= 1, # for the sake of simplicity
post => $VOID or $RETURN squareroot,
context => novoid,
action => carp;

print squareroot(2), "n"; # prints 1.41421 and so on
print squareroot(-1), "n"; # warns
# "Precondition 1 for main::squareroot failed."
squareroot(2); # warns
# "main::squareroot called in void context."

sub faultysqrt {
my $x = shift;
return $x**2;
}

assert
pre => $PARAM[0] >= 1, # for the sake of simplicity
post => $RETURN faultysqrt;

print faultysqrt(2), "n"; # dies with
# "Postcondition 1 for main::squareroot failed."