Free prima tutorial 1.20 software for linux

Prima::Utils are miscellanneous routines.

The module contains several helper routines, implemented in both C and perl. Whereas the C-coded parts are accessible only if use Prima; statement was issued prior to the use Prima::Utils invocation, the perl-coded are always available. This makes the module valuable when used without the rest of toolkit code.

API

alarm $TIMEOUT, $SUB, @PARAMS

Calls SUB with PARAMS after TIMEOUT milliseconds.

beep [ FLAGS = mb::Error ]

Invokes the system-depended sound and/or visual bell, corresponding to one of following constants:

mb::Error
mb::Warning
mb::Information
mb::Question

get_gui

Returns one of gui::XXX constants, reflecting the graphic user interface used in the system:
gui::Default
gui::PM
gui::Windows
gui::XLib
gui::OpenLook
gui::Motif

The meaning of the return value is somewhat vague, and might be deprecated in future releases.

get_os

Returns one of apc::XXX constants, reflecting the platfrom. Currently, the list of the supported platforms is:

apc::Os2
apc::Win32
apc::Unix

ceil DOUBLE

Obsolete function.

Returns stdlibs ceil() of DOUBLE

find_image PATH

Converts PATH from perl module notation into a file path, and searches for the file in @INC paths set. If a file is found, its full filename is returned; otherwise undef is returned.

floor DOUBLE

Obsolete function.

Returns stdlibs floor() of DOUBLE

getdir PATH

Reads content of PATH directory and returns array of string pairs, where the first item is a file name, and the second is a file type.

The file type is a string, one of the following:
"fifo" - named pipe
"chr" - character special file
"dir" - directory
"blk" - block special file
"reg" - regular file
"lnk" - symbolic link
"sock" - socket
"wht" - whiteout

This function was implemented for faster directory reading, to avoid successive call of stat for every file.

path [ FILE ]

If called with no parameters, returns path to a directory, usually ~/.prima, that can be used to contain the user settings of a toolkit module or a program. If FILE is specified, appends it to the path and returns the full file name. In the latter case the path is automatically created by File::Path::mkpath unless it already exists.

post $SUB, @PARAMS

Postpones a call to SUB with PARAMS until the next event loop tick.

query_drives_map [ FIRST_DRIVE = "A:" ]

Returns anonymous array to drive letters, used by the system. FIRST_DRIVE can be set to other value to start enumeration from. Some OSes can probe eventual diskette drives inside the drive enumeration routines, so there is a chance to increase responsiveness of the function it might be reasonable to set FIRST_DRIVE to C: string.

If the system supports no drive letters, empty array reference is returned ( unix ).

query_drive_type DRIVE

Returns one of dt::XXX constants, describing the type of drive, where DRIVE is a 1-character string. If there is no such drive, or the system supports no drive letters ( unix ), dt::None is returned.

dt::None
dt::Unknown
dt::Floppy
dt::HDD
dt::Network
dt::CDROM
dt::Memory

sound [ FREQUENCY = 2000, DURATION = 100 ]

Issues a tone of FREQUENCY in Hz with DURATION in milliseconds.

username

Returns the login name of the user. Sometimes is preferred to the perl-provided getlogin ( see "getlogin" in perlfunc ) .

xcolor COLOR

Accepts COLOR string on one of the three formats:

#rgb
#rrggbb
#rrrgggbbb

and returns 24-bit RGB integer value.

Prima::Drawable is a 2-D graphic interface.

SYNOPSIS

if ( $object-> isa(Prima::Drawable)) {
$object-> begin_paint;
$object-> color( cl::Black);
$object-> line( 100, 100, 200, 200);
$object-> ellipse( 100, 100, 200, 200);
$object-> end_paint;
}

Prima::Drawable is a descendant of Prima::Component. It provides access to the object-bound graphic context and canvas through its methods and properties. The Prima::Drawable descendants Prima::Widget, Prima::Image, Prima::DeviceBitmap and Prima::Printer are backed by system-dependent routines that allow drawing and painting on the system objects.

Prima::Grids is a Perl module that contains grid widgets.

SYNOPSIS

use Prima::Grids;

$grid = Prima::Grid-> create(
cells => [
[qw(1.First 1.Second 1.Third)],
[qw(2.First 2.Second 2.Third)],
[qw(3.First 3.Second 3.Third)],
],
onClick => sub {
print $_[0]-> get_cell_text( $_[0]-> focusedCell), " is selectedn";
}
);

The module provides classes for several abstraction layers of grid representation. The classes hierarchy is as follows:

AbstractGridViewer
AbstractGrid
GridViewer
Grid

The root class, Prima::AbstractGridViewer, provides common interface, while by itself it is not directly usable. The main differences between classes are centered around the way the cell data are stored. The simplest organization of a text-only cell, provided by Prima::Grid, stores data as a two-dimensional array of text scalars. More elaborated storage and representation types are not realized, and the programmer is urged to use the more abstract classes to derive own mechanisms. To organize an item storage, different from Prima::Grid, it is usually enough to overload either the Stringify, Measure, and DrawCell events, or their method counterparts: get_cell_text, columnWidth, rowHeight, and draw_items.

The grid widget is designed to contain cells of variable extents, of two types, normal and indent. The indent rows and columns are displayed in grid margins, and their cell are drawn with distinguished colors. An example use for a bottom indent row is a sum row in a spreadsheet application; the top indent row can be used for displaying columns headers. The normal cells can be selected by the user, scrolled, and selected. The cell selection can only contain rectangular areas, and therefore is operated with two integer pairs with the beginning and the end of the selection.

The widget operates in two visual scrolling modes; when the space allows, the scrollbars affect the leftmost and the topmost cell. When the widget is not large enough to accommodate at least one cell and all indent cells, the layout is scrolled pixel-wise. These modes are named cell and pixel, after the scrolling units.

The widget allows the interactive changing of cell widths and heights by dragging the grid lines between the cells.

Prima::AbstractGridViewer

Prima::AbstractGridViewer, the base for all grid widgets in the module, provides interface to generic grid browsing functionality, plus functionality for text-oriented grids. The class is not usable directly.

Prima::AbstractGridViewer is a descendant of Prima::GroupScroller, and some properties are not described here. See "Prima::GroupScroller" in Prima::IntUtils.

IPTables-tutorials aim is to explain iptables in a complete and simple way. The iptables-tutorial is currently rather stable, and contains information on all the currently available matches and targets (in kernel), as well as a couple of complete example scripts and explanations. It contains a complete section on iptables syntax, as well as other interesting commands such as iptables-save and iptables-restore.

The tutorial has recently been under heavy scrutiny and updating, as can be seen in this, the latest version of the tutorial. It is now also available in bookform from Lulu.com. If you feel like contributing or donating to the author of this tutorial, please do buy the book! Thank you!

If you need help, you are better off by asking the netfilter mailing list which you can reach at netfilter at lists.netfilter.org. For more information on this, visit the netfilter mailinglist page. You may also contact the linuxsecurity mailing list at security-discuss AT linuxsecurity dotcom. Both are fairly large, and should be able to help you much much better than I can.

Imager::Tutorial is an introduction to Imager.

Before you start

If you have the necessary knowledge, install the image format libraries you want Imager image file support for, and Imager itself, otherwise arrange to have it done.
You will also want some sort of image viewer tool, whether an image editor like Photoshop or the GIMP, or a web browser.

Hello Boxes! - A Simple Start

As with any perl program its useful to start with a #! line, and to enable strict mode:

#!/usr/bin/perl -w
# you might to use warnings; instead of the -w above
use strict;

These lines will be omitted in further examples.

As with any module, you need to load it:

use Imager;

Now create a image to draw on:

my $image = Imager->new(xsize => 100, ysize => 100);

and draw a couple of filled rectangles on it:

$image->box(xmin => 0, ymin => 0, xmax => 99, ymax => 99,
filled => 1, color => blue);
$image->box(xmin => 20, ymin => 20, xmax => 79, ymax => 79,
filled => 1, color => green);

Since the first box fills the whole image, it can be simplified to:

$image->box(filled => 1, color => blue);

and save it to a file:

$image->write(file=>tutorial1.ppm)
or die Cannot save tutorial1.ppm: , $image->errstr;

So our completed program is:

use Imager;

my $image = Imager->new(xsize => 100, ysize => 100);

$image->box(filled => 1, color => blue);
$image->box(xmin => 20, ymin => 20, xmax => 79, ymax => 79,
filled => 1, color => green);

$image->write(file=>tutorial1.ppm)
or die Cannot save tutorial1.ppm: , $image->errstr;

Prima::image-load is a Perl module using image subsystem.

Simple loading

Simplest case, loading a single image would look like:

my $x = Prima::Image-> load( filename.duf);
die "$@" unless $x;

Image functions can work being either invoked from package, or from existing Prima::Image object, in latter case the caller object itself is changing. The code above could be also written as

my $x = Prima::Image-> create;
die "$@" unless $x-> load( filename.duf);

In both cases $x contains image data upon success. Error is returned into $@ variable ( see perldoc perlvar for more info).

Prima::PodView is Perl module for POD browser widget.

SYNOPSIS

use Prima qw(Application);
use Prima::PodView;

my $window = Prima::MainWindow-> create;
my $podview = $window-> insert( Prima::PodView,
pack => { fill => both, expand => 1 }
);
$podview-> open_read;
$podview-> read("=head1 NAMEnnIm also a pod!nn");
$podview-> close_read;

run Prima;

Prima::PodView contains a formatter ( in terms of perlpod ) and viewer of POD content. It heavily employs its ascendant class Prima::TextView, and is in turn base for the toolkits default help viewer Prima::HelpViewer.