Free hex editor software for linux

YAPE::Regex::Element contains sub-classes for YAPE::Regex elements.

SYNOPSIS

use YAPE::Regex MyExt::Mod;
# this sets up inheritence in MyExt::Mod
# see YAPE::Regex documentation

YAPE MODULES

The YAPE hierarchy of modules is an attempt at a unified means of parsing and extracting content. It attempts to maintain a generic interface, to promote simplicity and reusability. The API is powerful, yet simple. The modules do tokenization (which can be intercepted) and build trees, so that extraction of specific nodes is doable.

Methods for YAPE::Regex::Element

This class contains fallback methods for the other classes.
my $str = $obj->text;
Returns a string representation of the content of the regex node itself, not any nodes contained in it. This is undef for non-text nodes.
my $str = $obj->string;
Returns a string representation of the regex node itself, not any nodes contained in it.
my $str = $obj->fullstring;
Returns a string representation of the regex node, including any nodes contained in it.
my $quant = $obj->quant;
Returns a string with the quantity, and a ? if the node is non-greedy. The quantity is one of *, +, ?, {M,N}, or an empty string.
my $ng = $obj->ngreed;
Returns a ? if the node is non-greedy, and an empty string otherwise.

Methods for YAPE::Regex::anchor

This class represents anchors. Objects have the following methods:
my $anchor = YAPE::Regex::anchor->new($type,$q,$ng);
Creates a YAPE::Regex::anchor object. Takes three arguments: the anchor (^, A, $, Z, z, B, b, or G), the quantity, and the non-greedy flag. The quantity should be an empty string.
my $anc = YAPE::Regex::anchor->new(A, , ?);
# /A?/
my $type = $anchor->type;
Returns the string anchor.
Methods for YAPE::Regex::macro
This class represents character-class macros. Objects have the following methods:
my $macro = YAPE::Regex::macro->new($type,$q,$ng);
Creates a YAPE::Regex::macro object. Takes three arguments: the macro (w, W, d, D, s, or S), the quantity, and the non-greedy flag.
my $macro = YAPE::Regex::macro->new(s, {3,5});
# /s{3,5}/
my $text = $macro->text;
Returns the macro.
print $macro->text; # s
my $type = $macro->type;
Returns the string macro.

Methods for YAPE::Regex::oct

This class represents octal escapes. Objects have the following methods:
my $oct = YAPE::Regex::oct->new($type,$q,$ng);
Creates a YAPE::Regex::oct object. Takes three arguments: the octal number (as a string), the quantity, and the non-greedy flag.
my $oct = YAPE::Regex::oct->new(040);
# / 40/
my $text = $oct->text;
Returns the octal escape.
print $oct->text; # 40
my $type = $oct->type;
Returns the string oct.

Methods for YAPE::Regex::hex

This class represents hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::hex->new($type,$q,$ng);
Creates a YAPE::Regex::hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $hex = YAPE::Regex::hex->new(20,{2,});
# /x20{2,}/
my $text = $hex->text;
Returns the hexadecimal escape.
print $hex->text; # x20
my $type = $hex->type;
Returns the string hex.

Methods for YAPE::Regex::utf8hex

This class represents UTF hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::utf8hex->new($type,$q,$ng);
Creates a YAPE::Regex::utf8hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $utf8hex = YAPE::Regex::utf8hex->new(beef,{0,4});
# /x{beef}{2,}/
my $text = $utf8hex->text;
Returns the hexadecimal escape.
print $utf8hex->text; # x{beef}
my $type = $utf8hex->type;
Returns the string utf8hex.

Methods for YAPE::Regex::backref

This class represents back-references. Objects have the following methods:
my $bref = YAPE::Regex::bref->new($type,$q,$ng);
Creates a YAPE::Regex::bref object. Takes three arguments: the number of the back-reference, the quantity, and the non-greedy flag.
my $bref = YAPE::Regex::bref->new(2,,?);
# /2?/
my $text = $bref->text;
Returns the backescape.
print $bref->text; # 2
my $type = $bref->type;
Returns the string backref.

Methods for YAPE::Regex::ctrl

This class represents control character escapes. Objects have the following methods:
my $ctrl = YAPE::Regex::ctrl->new($type,$q,$ng);
Creates a YAPE::Regex::ctrl object. Takes three arguments: the control character, the quantity, and the non-greedy flag.
my $ctrl = YAPE::Regex::ctrl->new(M);
# /cM/
my $text = $ctrl->text;
Returns the control character escape.
print $ctrl->text; # cM
my $type = $ctrl->type;
Returns the string ctrl.

Methods for YAPE::Regex::named

This class represents named characters. Objects have the following methods:
my $ctrl = YAPE::Regex::named->new($type,$q,$ng);
Creates a YAPE::Regex::named object. Takes three arguments: the name of the character, the quantity, and the non-greedy flag.
my $named = YAPE::Regex::named->new(GREEK SMALL LETTER BETA);
# /N{GREEK SMALL LETTER BETA}/
my $text = $named->text;
Returns the character escape text.
print $named->text; # N{GREEK SMALL LETTER BETA}
my $type = $named->type;
Returns the string named.

Root Actions servicemenu is a replacement/alternate for the default Edit-as-root servicemenu.
It allows an admin user to perform several root only actions from konqueror (It of course asks for a password)
Usage:
The following actions can be performed (see the screenshot):
Edit as Text: Open file in Kate editor as root (shown with files)
Edit as Hex: Open file in KHexEdit (you may need to install khexedit package from universe) editor as root (shown with files)
Open in Konqueror: Open file/folder in root konqueror window
Change owner to root: Changes ownership to root:root
Change owner to user: Changes ownership to 1000:1000 (the default user)
The menu can be localized by editing the servicemenu .desktop files
Installation:
uncompress the two .desktop files to ~/.kde/share/apps/konqueror/servicemenus
Any comments, criticism and improvement suggestions welcomed.
Enhancements:
- As this seems to run as it should (and I havent gotten any show stopper bug reports), I feel courageous enough to remove the BETA status.
- Removed Preferred Applications section from the perl script. To change the default applications used by the menu, edit the desktop files instead. (This allows for different application preferences for different users and easy creation of custom Open with [application] entries to the menu.) See the README for customization howto.
- Fixed a bug with Rename when multiple items were chosen but the batch renamer application didnt start (the simple rename dialog was started instead).
- Added Dutch translation

Color::Object is a OO-Color Module.

A module for manipulation Colors within RGB, HSV and HSL color-spaces for usage within PDF-Documents especially with the Text::PDF::API modules.

SYNOPSIS

use Color::Object;

$cl = Color::Object->new;
$cl = Color::Object->newRGB($r,$g,$b);
$cl = Color::Object->newHSV($h,$s,$v);
$cl = Color::Object->newHSL($h,$s,$l);

$cl->setRGB($r,$g,$b);
$cl->addBrightness($br);
($h,$s,$l) = $cl->asHSL;

METHODS

Color::Object->new
Color::Object->newRGB $r, $g, $b
Color::Object->newHSV $h, $s, $v
Color::Object->newHSL $h, $s, $l
Color::Object->newGrey $grey
( $r, $g, $b ) = $cl->asRGB
Returns $cls rgb values. Range [0 .. 1].
( $h, $s, $v ) = $cl->asHSV
Returns $cls hsv values. Ranges h [0 .. 360], s/v [0 .. 1].
( $h, $s, $l ) = $cl->asHSL
Returns $cls hsl values. Ranges h [0 .. 360], s/l [0 .. 1].
$grey = $cl->asGrey
$grey = $cl->asGrey2
Returns $cls grey value. Range [0 .. 1]. Functions 2 returns the geometric mean of the corresponding RGB values.
( $c, $m, $y )= $cl->asCMY
Returns $cls cmy values. Range [0 .. 1].
( $c, $m, $y, $k )= $cl->asCMYK
( $c, $m, $y, $k )= $cl->asCMYK2
( $c, $m, $y, $k )= $cl->asCMYK3
Returns $cls cmyk values. Range [0 .. 1]. Function 2 returns a 25% lighter color-equivalent. Function 3 returns a 25% lighter color-equivalent.
$hex = $cl->asHex
Returns $cls rgb values as 6 hex-digits.
$cl->setRGB $r, $g, $b
Sets the $cls rgb values. Valid range [0 .. 1].
$cl->setHSV $h, $s, $v
Sets the $cls hsv values. Valid ranges: h [0..360], s/v [0..1].
$cl->setHSL $h, $s, $l
Sets the $cls hsl values. Valid ranges: h [0..360], s/l [0..1].
$cl->setGrey $grey
Sets the $cls grey value. Valid range [0 .. 1].
$cl->setHex $hex
Sets the $cls rgb values using 6 hex-nibbles.
$cl->addSaturation $saturation
Adds to the $cls saturation in the HSV model. Valid range [-1 .. 1].
$cl->setSaturation $saturation
Sets the $cls saturation in the HSV model. Valid range [0 .. 1].
$cl->rotHue $degrees
Rotates the $cls hue in the HSV/L model. Valid range [-360 .. 360].
$cl->setHue $hue
Sets the $cls hue in the HSV/L model. Valid range [0 .. 360].
$cl->addBrightness $brightness
Adds to the $cls brightness in the HSV model. Valid range [-1 .. 1].
$cl->setBrightness $brightness
Sets the $cls brightness in the HSV model. Valid range [0 .. 1].
$cl->addLightness $lightness
Adds to the $cls lightness in the HSL model. Valid range [-1 .. 1].
$cl->setLightness $lightness
Sets the $cls lightness in the HSL model. Valid range [0 .. 1].

Graphics::ColorPicker is a Perl module for WYSIWYG web applications that allow selection of HEX color numbers.

SYNOPSIS

use Graphics::ColorPicker;
or
require Graphics::ColorPicker;

make_page($path_to_images);
send_page($html_txt,$type);
$time_string = http_date($time);
$name = script_name;
$html_text=frames($websafe);
$html_text = msie_frame;
$html_text=picker($darkimg,$liteimg,$size,$bsize,greyimg);
$html_text=no_picker;
$html_text=cp216_ds($clrdot,$border,$square)
$javascript_text = jslib;
$html=make_buttons(%look_n_feel,$url,$active,@buttons,$xtra);
$html_text=pluck($color);

Wcalc is a very capable calculator. Wcalc has standard functions (sin, asin, and sinh for example), many pre-defined constants (pi, e, c, etc.), support for using variables, a command history, hex/octal/binary input and output, unit conversions, bit-shifting, embedded comments, and an expandable expression entry field. It evaluates expressions using the standard order of operations.
Wcalc is a very capable calculator. It supports abitrary precision, has standard functions (sin, asin, and sinh for example, in either radians or degrees), many pre-defined constants (pi, e, c, etc.), support for using variables, "active" variables, a command history, hex/octal/binary input and output, unit conversions, embedded comments, and an expandable expression entry field. It evaluates expressions using the standard order of operations.
Wcalc uses intuitive expressions. For example, Wcalc will evaluate: 5sin 4!-7*2(4%6)^2 to be -221.96631678
Wcalc also comes in a command-line version that works on most (if not all) forms of Unix (including Linux and BSD). To support arbitrary precision, Wcalc relies on the GMP and MPFR libraries.
In the MacOSX release, these are compiled-in, so you shouldnt have to install them yourself. NOTE: GMP comes with a broken version of MPFR (I really wish they wouldnt do that). You have to install a real version of MPFR for Wcalc to work.
Enhancements:
- This has plenty of bugfixes and a couple nifty new features. In the GUI realm, Wcalc now also serves as a System Service, and so adds a "Wcalc Compute" entry to the Services menu of other applications.
- In the CLI realm, Wcalcs error reporting is now more friendly, and will tell you exactly where in the line the error occurred.
- Also, Wcalc now uses tab-completion in the CLI, and can tab-complete just about anything (variables, conversion units, commands, functions, etc.).

Engine_pkcs11 is an implementation of an engine for OpenSSL. Engine_pkcs11 project can be loaded using code, config file or command line and will pass any function call by openssl to a PKCS#11 module.
Engine_pkcs11 is meant to be used with smart cards and software for using smart cards in PKCS#11 format, such as OpenSC. Originaly this engine was a part of OpenSC, until OpenSC was split into several small projects for improved flexibility.
OpenSC was written by an international team and is licensed as Open Source software under the new BSD license.
Engine_pkcs11 is based on the Libp11 library.
Enhancements:
- The wiki export script was updated.
- Some dead code was disabled.
- The maximum length for a pin is now 32 bytes.
- Internal variables and code are now static.
- The slot is now also parsed as hex.
- Support for selecting slots by label was added.