Free to manipulate software for linux

CAD::Drawing::Manipulate is a Perl module to manipulate CAD::Drawing objects.

Move, Copy, Scale, Mirror, and Rotate methods for single entities and groups of entities.

Group Methods

These methods are called with required values, followed by a hash reference of option values. Note the difference between this and the individual entity manipulation syntax shown below. The absence of an %options hash reference implies everything in the drawing.

For details about each of the group manipulation methods, see the corresponding individual entity manipulation method.

Options

The $opts value shown for each of the group manipulation methods is fed directly to CAD::Drawing::select_addr(). See the documentation for this function for additional details.
One of the most common methods of selection (after the implicit all) may be the explicit list of addresses. This is done by simply passing an array reference rather than a hash reference.

GroupMove

Move selected entities by @dist.

$drw->GroupMove(@dist, $opts);

GroupCopy

Returns a list of addresses for newly created entities.

@new = $drw->GroupCopy(@dist, $opts);

GroupClone

Returns a list of addresses for newly created entities.

@new = $drw->GroupClone($dest, $opts);

place

Clones items from $source into $drw and moves them to @pt. Selects items according to %opts and optionally rotates them by $opts{ang} (given in radians.)

$drw->place($source, @pt, %opts);

GroupMirror

Mirrors the entities specified by %options (see select_addr()) across @axis.

@new = $drw->GroupMirror(@axis, %options);

GroupScale

Sorry, @pt is required here.

$drw->GroupScale($factor, @pt, %opts);

GroupRotate

Rotates specified entities by $angle. A center point may be specified via $opts{pt} = @pt.

$drw->GroupRotate($angle, %opts);

Individual Methods

Move

Moves entity at $addr by @dist (@dist may be three-dimensional.)

$drw->Move($addr, @dist);

Copy

$drw->Copy($addr, @dist);

Clone

Clones the entity at $addr into drawing $dest.

$drw->Clone($addr, $dest, %opts);

%opts may contain:

to_layer => $layer_name, # layer to clone into

Mirror

Mirrors entity specified by $addr across @axis.
Returns the address of the manipulated entity. If $opts{copy} is true, will clone the entity, otherwise modify in-place.

$drw->Mirror($addr, @axis, %opts);

Scale

$drw->Scale($addr, $factor, @pt);

Rotate

Rotates entity specified by $addr by $angle (+ccw radians) about @pt. Angle may be in degrees if $angle =~ s/d$// returns a true value (but I hope the "d" is the only thing on the end, because Im not looking for anything beyond that.) $angle = "45" . "d" will get converted, but $angle = "45" . "bad" will be called 0. Remember, this is Perl:)

$drw->Rotate($addr, $angle, @pt);

Internal Functions

pointrotate

Internal use only.

($x, $y) = pointrotate($x, $y, $ang, $xc, $yc);

pointmirror

@point = pointmirror($axis, $pt);

angle_of

angle_of(@segment);

Polygon Methods

These dont do anything yet and need to be moved to another module anyway.

CutPline

$drw->CutPline();

IntPline

$drw->IntPline();

intersect_pgon

intersect_pgon();

CAD::Drawing::Manipulate::Graphics - Gimp meets CAD.

Methods

All of these are CAD::Drawing methods (I force my own inheritance:)

image_init

Initialize the image at $addr based on the value at the fullpath key. This establishes the contained Image::Magick object and loads the image into memory in the image_handle key.

$drw->image_init($addr);

image_crop

Crops an image and its definition (actually, changes its insert point) according to the points given by @crop_points (which maybe had better be within the object (but I dont really sweat that.))

@crop_points should be in world coordinates as follows:

@crop_points = (
[$lower_left_x , $lower_left_y ],
[$upper_right_x, $upper_right_y],
);
# note that you can get these as
# ($drw->getExtentsRec($something))[0,2]

$drw->image_crop($addr, @crop_points);

image_scale

Scales both the image and the definition by $scale, starting at @base_point.

$drw->image_scale($addr, $scale, @base_point);

image_rotate

This leaves the definition orthoganal, expands the underlying image object, and resets the insert point and size properties accordingly.

$drw->image_rotate($addr, $angle, @point);

The current implementation does not handle the change to the image clipping boundary.

image_swap_context

This involves a scaling of the image (the contexts should be aligned over each other at this point or everything will go to hell.) Do your own move / rotate / crop before calling this, because all this does is to scale the underlying image object such that the vec property of the image definition at $dest_addr can be used correctly.

Note that this does not "swap" the image to $dest_addr, rather it uses the image definition of $dest_addr to change the image object and definition at $source_addr.
Also note that the image must fit completely inside (I think) of the destination in order for the composite to work correctly.

$drw->image_swap_context($source_addr, $dest_addr);

Tom is a software environment for defining transformations in Java. TOM programming language is an extension of Java designed to manipulate tree structures and XML documents. It is compatible with Java: a Java program is a correct Tom program.
Data are represented using an efficient tree based data-structure. Java built-ins (int, char, String, etc) can be used. Tom provides pattern matching facilities to inspect objects and retrieve values. A powerful strategy language can be used to control transformations.
Enhancements:
- The Eclipse plugin is now available again.
- In the %match construct, the sort of the subject is now optional.
- It is automatically inferred from the patterns when possible.
- Gom generates congruence strategies and offers new functionalities, such as the length of a list.
- A new "!" construct can be used to denote anti-patterns.
- The strategy library has been extended such that strategy expressions can be matched, like any other term.
- A strategy can now take another strategy in its argument.
- Support for Java bytecode analysis and transformation has been added.

File::Attributes is a Perl module to manipulate file metadata.

SYNOPSIS

use File::Attributes qw(set_attribute list_attributes get_all_attributes);

my $file = foo.txt;
set_attribute($file, type => text/plain);
set_attribute($file, encoding => utf8);

my @attributes = list_attributes($file);
# @attributes = qw(type encoding)

%attributes = get_attributes($file);
# $attributes{type} will be text/plain
# $attributes{foo} will be undefined.

File::Attributes is a wrapper around modules in the File::Attributes hierarchy. If you use this module directly (instead of one of the aforementioned decendants), then your attribute manipulations will Just Work, regardless of the underlying filesystem.

Module::Pluggable is used to find all File::Attributes:: modules that inherit from File::Attributes::Base and that are applicable on your system. If it finds one, it uses that. If not, it uses File::Attributes::Simple, which is bundled with this module and works everywhere.

As of version 0.04, plugins are now set up per-file, not per-system. This means that if you have File::Attributes::Extended installed, extended attributes will be used where available, but Simple attributes will be used on files where extended attributes dont work (a FAT filesytem on a Linux machine, for example). Existing simple attributes will be read even if extended attributes are available, but writes will affect only the extended attributes.

This means that you can switch to a better attribute plugin at any time, without losing any old data!

NanoBlogger is a small weblog engine written in Bash for the command line. NanoBlogger uses common UNIX tools such as cat, grep and sed to create static HTML content. Its free to use and modify under the GNU General Public License.
Main features:
- intuitive commandline interface
- highly configurable and scriptable :)
- easy drafting, editing, and management of entries
- archiving by category, entry, and month
- pagination
- permanent and navigational links
- templates and CSS style sheets for full control over layout
- placeholders for easy template manipulation
- support for multiple weblogs
- support for multiple categories
- support for relative and absolute links
- support for date manipulation of entries
- Atom syndication (comes with 1.0 format)
- RSS syndication (comes with RSS 1.0 and 2.0 formats)
- plugins for calendar, recent entries, weblog status, etc.
- plugins for text formatting (e.g. line breaks translate to HTML)
- global (nb.conf) and per-weblog (blog.conf) configuration
- intelligent build system - only updates relative files
- simple cache system for improved effeciency
- independent of java-script and server-side scripting (e.g. PHP)
- independent of external database (stores data in flat-files)
- multi-language support
- multi-platform portability (just bash and the required commands)
Enhancements:
- This release includes many logical bugfixes, user contributed patches, and a new --query option which combines with other options, such as --edit, to manipulate entries by date.
- It introduces friendly (title based) links and archiving by day.
- Of course, it also includes all the changes and bugfixes from the previous 3.3 release candidates.

Sprite is a Perl module to manipulate text delimited databases using SQL.

SYNOPSIS

use Sprite;

$rdb = new Sprite;

$rdb->set_delimiter (-Read => ::) ## OR: (Read, ::);
$rdb->set_delimiter (-Write => ::) ## OR: (Write, ::);

$rdb->set_os (Win95);

## Valid arguments (case insensitive) include:
##
## Unix, Win95, Windows95, MSDOS, NT, WinNT, OS2, VMS,
## MacOS or Macintosh. Default determined by $^O.

$rdb->set_lock_file (c:win95tmpSprite.lck, 10);

$rdb->set_db_dir (Mac OS:Perl 5:Data) || die "Cant access dir!n";

$data = $rdb->sql (<<less