Free constants 0.993 software for linux

Video::Info::MPEG::Constants is a suite of modules to probe video files for various attributes.

Previous versions of Video::Info depended on external modules, such as RIFF::Info and ASF::Info. This is no longer the case, you dont need to install them. All the functionality is now included with the Video::Info distribution.

To contribute, use Video::Info::FOO as a template to write a module, and email it to the Allen Day. Also see t/FOO.t as an example test script to verify the sanity of your code.

Installation:

To install this module type the following:

perl Makefile.PL
make
make test (optional)
make install

Etk::Constants is a Perl module with costants to use with Etk.

SYNOPSIS

use Etk::Constants qw/ButtonsOk ButtonsClose/;
#
use Etk::Constants qw/:messagedialog/;
#
use Etk::Constants qw/:all/;

This module contains constants to use while building Etk apps. The constants have numerical values which can be used instead.

Devel::Constants is a Perl module that translates constants back to named symbols.

SYNOPSIS

# must precede use constant
use Devel::Constants flag_to_names;

use constant A => 1;
use constant B => 2;
use constant C => 4;

my $flag = A | B;
print "Flag is: ", join( and , flag_to_names($flag) ), "n";

Declaring constants is very convenient for writing programs, but as Perl often inlines them, retrieving their symbolic names can be tricky. This worse with lowlevel modules that use constants for bit-twiddling.

Devel::Constants makes this much more manageable.

It silently wraps around the constant module, intercepting all constant declarations. It builds a hash, associating the values to their names, from which you can retrieve their names as necessary.

Note that you must use Devel::Constants before constant, or the magic will not work and you will be very disappointed. This is very important, and if you ignore this warning, the authors will feel free to laugh at you (at least a little.

By default, Devel::Constants only intercept constant declarations within the same package that used the module. Also by default, it stores the constants for a package within a private (read, otherwise inaccessible) variable. You can override both of these.

Passing the package flag to Devel::Constants with a valid package name will make the module intercept all constants subsequently declared within that package. For example, in the main package you might say:

use Devel::Constants package => NetPacket::TCP;
use NetPacket::TCP;

All of the TCP flags declared within NetPacket::TCP are now available.
It is also possible to pass in a hash reference in which to store the constant values and names:

my %constant_map;
use Devel::Constants %constant_map;

use constant NAME => 1;
use constant RANK => 2;
use constant SERIAL => 4;

print join( , values %constant_map), "n";

C::Scan::Constants Perl module contains slurp constants from specified C header (.h) files.

SYNOPSIS

## Intended for use in your modules Makefile.PL file, to
## add DWIMery to use of C constants within your module.

use C::Scan::Constants;

my @hdr_files = (
"/path/to/first_header.h",
"/path/to/second_header.h",
);

## Slurp a list of constant information from C headers
my @constants = extract_constants_from( @hdr_files );

## Create the C, XS, and pure-Perl machinery needed to
## provide automagical access to C constants at runtime.
write_constants_module( "Your::Module", @constants );

This module provides an alternative to using the h2ph command to generate Perl header (.ph) files that are then subsequently required by your module code. When you need access to C numeric and enumerated type constants, especially in a dynamic source tree environment, there are times when youd like something a little more automagical and closely tailored to what you actually need. Now you have it, in this module.

C::Scan::Constants was born out of a recognition that ModPerl::CScan and ExtUtils::Constant provide a wealth of capabilities in the area of C code parsing and autogenerated XS access to C constants, but that the actual mechanisms for harnessing them to do those things were really rather opaque. This module should help take (most of) the mystery out of those activities.

Rcss addresses issue of CSS maintainability. Even a minor change in complex stylesheet usually requires using search-and-replace.
A simple way to fix this flaw is to allow some kind of constant/variable substitution inside CSS. Using Rcss you can achieve that in three ways:
ERB templates
ERB templating is the most flexible solution. It uses standard ERB syntax (the same you can find in rhtml files). ERB allows you to inlude in the CSS values defined in controller. This gives access to database through ActiveRecord and allows database-driven CSS themes.
Strengths
Access to application data (through ActiveRecord)
Flexible Ruby syntax (allowing programmatic CSS)
Weaknesses
Syntax unfamiliar to CSS designers
A bit ugly and sometimes error-prone embedding
Not portable
Example
< % template_color = "#000"
template_background = "#fff"
template_highlight = "#fa3"
% >
body {
color: < %= template_color % >;
background-color: < %= template_background % >;
}
h1 {
color: < %= template_background % >;
background-color: < %= template_highlight % >;
}
Server-side Constants
Server-side Constants were originaly developed by Shaun Inman in PHP. SSC extends CSS syntax in a simple way. SCC is cross-platform and easy to use.
Rcss differs from original implementation in two ways :
Constants may have complex values (including spaces and commas)
Includes are not implemented
Strengths
Simple syntax
SSC-CSS files can be used in both Rails and PHP applications
Weaknesses
Only simple constant substitution
Example
@server constants {
template_color: #000;
template_background: #fff;
template_highlight: #fa3;
// Rcss specific (note spaces and commas)
template_font: "Trebuchet MS", "Bitstream Vera Sans", helvetica, sans-serif;
}
body {
color: template_color;
background-color: template_background;
font-family: template_font;
}
h1 {
color: template_background;
background-color: template_highlight;
font-family: template_font;
}
Enhancements:
- Ruby 1.8.2 is now used for builds, which fixes an invalid GEM problem and allows the software to actually be installed.

Video::Info can retrieve video properties such as: height width codec fps.

SYNOPSIS

use Video::Info;

my $info = Video::Info->new(-file=>my.mpg);

$info->fps();
$info->aspect();
## ... see methods below

Video::Info is a factory class for working with video files. When you create a new Video::Info object (see methods), something like this will happen: 1) open file, determine type. See Video::Info::Magic. 2) attempt to create object of appropriate class (ie, MPEG::Info for MPEG files, RIFF::Info for AVI files). 3) Probe the file for various attributes 4) return the created object, or a Video::Info object if the appropriate class is unavailable.

Currently, Video::Info can create objects for the following filetypes:

Module Filetype
-------------------------------------------------
Video::Info::ASF ASF
MP3::Info MPEG Layer 2, MPEG Layer 3
Video::Info::MPEG MPEG1, MPEG2, MPEG 2.5
Video::Info::RIFF AVI, DivX
Video::Info::Quicktime MOV, MOOV, MDAT, QT
And support is planned for:
Module Filetype
-------------------------------------------------
Video::Info::Real RealNetworks formats

Template::Plugin::Java::Constants is a Perl module with constants for the Java Template plugin modules.

SYNOPSIS

use Template::Plugin::Java::Constants qw/:regex/; use Template::Plugin::Java::Constants qw/:boolean/; use Template::Plugin::Java::Constants qw/:all/;

regex

The "regex" tag exports qr// compiled regular expressions SCALAR, PRIMITIVE, STRING and ARRAY, these are for matching Java types. All of these match a whole line, with no extra whitespace, and return the matched java type as $1. They may be used as:

$string =~ /@{[SCALAR]}/; # Ugly but effective and relatively fast.

SCALAR

Any primitive or encapsulated primitive: int, or Integer, or String, etc.

PRIMITIVE

Only primitive types like int, float, double, byte, etc.

STRING

An incarnation of java.lang.String.

ARRAY

A java.util.Vector.

boolean

The boolean tag just exports the constants TRUE as 1 and FALSE as 0.
all

Exports all of the proceeding.

Mac::Apps::Seasonality::Constants is a Perl module for static definitions of aspects of Seasonality.

SYNOPSIS

use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_NAME
$SEASONALITY_CREATOR
$SEASONALITY_HISTORY_DATABASE_PATH
};


use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_HISTORY_TABLE
$SEASONALITY_HISTORY_COLUMN_ICAO
$SEASONALITY_HISTORY_COLUMN_TEMPERATURE_C
};


use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_DB_STATUS_TABLE
$SEASONALITY_DB_STATUS_COLUMN_NEW_RECORDS_SINCE_VACUUM
};


use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_HISTORY_COLUMNS_REF
$SEASONALITY_HISTORY_COLUMN_NUMBERS_BY_COLUMN_NAME_REF
$SEASONALITY_HISTORY_COLUMN_NAMES_BY_COLUMN_NUMBER_REF
};

use Mac::Apps::Seasonality::Constants qw{
$SEASONALITY_INVALID_DATA
$SEASONALITY_TEMPERATURE_MINIMUM
$SEASONALITY_TEMPERATURE_MAXIMUM
};


use Mac::Apps::Seasonality::Constants qw{ :all };
use Mac::Apps::Seasonality::Constants qw{ :application };
use Mac::Apps::Seasonality::Constants qw{ :database };
use Mac::Apps::Seasonality::Constants qw{ :data };
use Mac::Apps::Seasonality::Constants qw{ :growl };

This provides static metadata about Seasonality via "constants". The exposed values are made immutable via Readonly and not constant, so they are usable within string interpolation, etc.

None of the values are exported by default to avoid the possibility of name clashes, though the names should be unique enough for most uses. Each value must individually be imported or with one of the following tags:

:all

All constants.

:application

The application name and creator code. The name of and default path to the weather history database.

:database

The database table and column names.

:data

The missing data indicator value and the limits on each type of data.

:growl

The values to be used in talking to Growl.