Free what is correct path name for directx 9 software for linux

Workspace Name Applet is a Gnome panel applet to display and edit the name of the current workspace.

AltaVista::SearchSDK is a Perl extension for AltaVista Search Software Development Kit.

SYNOPSIS

use AltaVista::SearchSDK;
avs_adddate(idx, yr, mo, da, startloc)
avs_addfield(idx, pFname, startloc, endloc)
avs_addliteral(idx, pWord, loc)
avs_addvalue(idx, valtype, value, loc)
avs_addword(idx, pWords, loc, pNumWords)
avs_buildmode(idx)
avs_buildmode_ex(idx, ntiers)
avs_close(idx)
avs_compact(idx, bMore_p)
avs_compactionneeded(idx)
avs_compact_minor(idx, bMore_p)
avs_count(idx, pWordPrefix, pCountsHdl)
avs_count_close(CountsHdl)
avs_count_getcount(CountsHdl)
avs_countnext(CountsHdl)
avs_count_getword(CountsHdl)
avs_default_options(pOptions)
avs_define_valtype(name, minval, maxval, valtype_p)
avs_deletedocid(idx, pDocId, pCount)
avs_enddoc(idx)
avs_errmsg(code)
avs_getindexmode(idx)
avs_getindexversion(idx)
avs_getindexversion_counts_v(countsHdl)
avs_getindexversion_search_v(searchHdl)
avs_getsearchresults(searchHdl, resultNum)
avs_getsearchterms(psearchHdl, termNum, term, count)
avs_lookup_valtype(name)
avs_makestable(idx)
avs_open(path, mode, pIdx)
avs_querymode(idx)
avs_release_valtypes()
avs_search(idx, pQuery, pBoolQuery, pOptions, pDocsFound, pDocsReturned, pTermCount, pSearchHdl)
avs_search_close(pSearchHdl)
avs_search_ex(idx, pQuery, pBoolQuery, pOptions, searchsince, pDocsFound, pDocsReturned, pTermCount, pSearchHdl)
avs_search_genrank(idx, pBoolQuery, pRankTerms, pRankSetup, pOptions, searchsince, pDocsFound, pDocsReturned, pSearchHdl)
avs_search_getdata(searchHdl)
avs_search_getdatalen(searchHdl)
avs_search_getdate(psearchHdl, year, month, day)
avs_search_getdocid(searchHdl)
avs_search_getdocidlen(searchHdl)
avs_search_getrelevance(psearchHdl)
avs_setdocdata(idx, pDocData, len)
avs_setdocdate(idx, year, month, day)
avs_setdocdatetime(idx, year, month, day, hour, minute, second)
avs_setparseflags(idx, parseflags)
avs_setrankval(idx, valtype, value)
avs_startdoc(idx, pDocId, flags, pStartLoc)
avs_timer(current)
avs_version()
avs_create_options(limit, timeout, flags)

This set of extensions provides wrappers for all the C functionality of the AltaVista Search software development kit (SDK) except for a few functions that did not make sense to export to perl.

All the functions of the 97 Rev B kit are available as advertised, except for the following:

avs_add_ms_callback UNIMPLEMENTED

It makes no sense to implement this function, since it would require being able to pass a C function handle through perl.

avs_addrankterms UNIMPLEMENTED

Internal function

avs_newdoc UNIMPLEMENTED

No easy way to provide filter function

avs_search_getdata_copy UNIMPLEMENTED

No need for this function

avs_search_getdocid_copy UNIMPLEMENTED

No need for this function

avs_search_getrelevance RETURN ARGUMENT

Relevance is returned as a string representation of the float

Techisa Desktop Environment is a lightweight alternative desktop environment developed using Qt.
The projects goal is to provide users with a comfortable environment using as few resources as possible. Only a Brazillian Portuguese translation is currently available.
Enhancements:
- Better support for KDE desktop files.
- Improved recognition of KDM/GDM sessions.
- New icon search paths.
- Enhancements to the TDE menu.
- Better handling of links and properties.
- TDESU shows correct error codes.
- Thumbnails.
- A tree view in the file browser. tdeopen accepts new parameters: [file name] directly executes a file or associated application, and -f [source] [destination] shows a popup allowing user to copy, move, or link.

File::PathList is a Perl module that can find a file within a set of paths (like @INC or Java classpaths).

SYNOPSIS

# Create a basic pathset
my $inc = File::PathList->new( @INC );

# Again, but with more explicit params
my $inc2 = File::PathList->new(
paths => @INC,
cache => 1,
);

# Get the full (localised) path for a unix-style relative path
my $file = "foo/bar/baz.txt";
my $path = $inc->find_file( $file );

if ( $path ) {
print "Found $file at $pathn";
} else {
print "Failed to find $filen";
}

Many systems that map generic relative paths to absolute paths do so with a set of base paths.

For example, perl itself when loading classes first turn a Class::Name into a path like Class/Name.pm, and thens looks through each element of @INC to find the actual file.

To aid in portability, all relative paths are provided as unix-style relative paths, and converted to the localised version in the process of looking up the path.

List::RewriteElements is a Perl module that can create a new list by rewriting elements of a first list.

SYNOPSIS

use List::RewriteElements;

Constructor

Simplest case: Input from array, output to STDOUT.

$lre = List::RewriteElements->new( {
list => @source,
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
} );
Input from file, output to STDOUT:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
body_rule => sub {
my $record = shift;
$record .= q{,additional field};
},
} );
Provide a different rule for the first element in the list:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
header_rule => sub {
my $record = shift;
$record .= q{,ADDITIONAL HEADER};
},
body_rule => sub {
my $record = shift;
$record .= q{,additional field};
},
} );
Input from file, output to file:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
output_file => "/path/to/output/file",
} );
To name output file, just provide a suffix to filename:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
output_suffix => .out,
} );
Provide criteria to suppress output of header or individual record.
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
header_suppress => sub {
my $record = shift;
return if $record =~ /$somepattern/;
},
body_suppress => sub {
my $record = shift;
return if $record ne somestring;
},
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
} );

Generate Output

$lre->generate_output();

Report Output Information

$path_to_output_file = $lre->get_output_path();

$output_file_basename = $lre->get_output_basename();

$output_row_count = $lre->get_total_rows();

$output_record_count = $lre->get_total_records();

$records_changed = $lre->get_records_changed();

$records_unchanged = $lre->get_records_unchanged();

$records_deleted = $lre->get_records_deleted();

$header_status = $lre->get_header_status();

It is common in many situations for you to receive a flat data file from someone else and have to generate a new file in which each row or record in the incoming file must either (a) be transformed according to some rule before being printing to the new file; or (b) if it meets certain criteria, not output to the new file at all.

List::RewriteElements enables you to write such rules and criteria, generate the file of transformed data records, and get back some basic statistics about the transformation.

List::RewriteElements is useful when the number of records in the incoming file may be large and you do not want to hold the entire list in memory. Similarly, the newly generated records are not held in memory but are immediately printed to STDOUT or to file.

On the other hand, if for some reason you already have an array of records in memory, you can use List::RewriteElements to apply rules and criteria to each element of the array and then print the transformed records (again, without holding the output in memory).

QDGDF stands for Quick and Dirty Game Development Framework, and its a set of libraries designed to allow fast development of games under a variety of systems. Quick and Dirty Game Development Frameworks main goal is to show a platform-independent, consistent interface to UNIX/Linux and MS Windows.
Supported video systems:
- X11 Window System.
- MS Windows DirectX (DirectDraw).
- DJGPP.
- Linux SVGALIB.
Supported audio systems:
- Linux OSS.
- MS Windows DirectX (DirectSound).
- ESD (Enlightened Sound Daemon).
Enhancements:
- This release includes the following new functions: qdgdfv_load_pcx_pal(), which loads a 256 color PCX file and rearranges it to match the current palette; qdgdfv_load_pcx_pal_set(), which loads a 256 color PCX file and sets its palette as the active one; qdgdfv_home_dir() and qdgdfa_home_dir(), which return a path where a game can create a directory or write data; and qdgdfv_app_dir() and qdgdfa_app_dir(), which return a path where a game can look for its application data.

File::Basename is a Perl module to parse file paths into directory, filename and suffix.

SYNOPSIS

use File::Basename;

($name,$path,$suffix) = fileparse($fullname,@suffixlist);
$name = fileparse($fullname,@suffixlist);

$basename = basename($fullname,@suffixlist);
$dirname = dirname($fullname);

These routines allow you to parse file paths into their directory, filename and suffix.

NOTE: dirname() and basename() emulate the behaviours, and quirks, of the shell and C functions of the same name. See each functions documentation for details. If your concern is just parsing paths it is safer to use File::Specs splitpath() and splitdir() methods.

It is guaranteed that

# Where $path_separator is / for Unix, for Windows, etc...
dirname($path) . $path_separator . basename($path);

is equivalent to the original path for all systems but VMS.

fileparse
my($filename, $directories, $suffix) = fileparse($path);
my($filename, $directories, $suffix) = fileparse($path, @suffixes);
my $filename = fileparse($path, @suffixes);

The fileparse() routine divides a file path into its $directories, $filename and (optionally) the filename $suffix.

$directories contains everything up to and including the last directory separator in the $path including the volume (if applicable). The remainder of the $path is the $filename.

# On Unix returns ("baz", "/foo/bar/", "")
fileparse("/foo/bar/baz");

# On Windows returns ("baz", "C:foobar", "")
fileparse("C:foobarbaz");

# On Unix returns ("", "/foo/bar/baz/", "")
fileparse("/foo/bar/baz/");

If @suffixes are given each element is a pattern (either a string or a qr//) matched against the end of the $filename. The matching portion is removed and becomes the $suffix.

# On Unix returns ("baz", "/foo/bar", ".txt")
fileparse("/foo/bar/baz", qr/.[^.]*/);

If type is non-Unix (see fileparse_set_fstype()) then the pattern matching for suffix removal is performed case-insensitively, since those systems are not case-sensitive when opening existing files.

You are guaranteed that $directories . $filename . $suffix will denote the same location as the original $path.

basename
my $filename = basename($path);
my $filename = basename($path, @suffixes);

This function is provided for compatibility with the Unix shell command basename(1). It does NOT always return the file name portion of a path as you might expect. To be safe, if you want the file name portion of a path use fileparse().

basename() returns the last level of a filepath even if the last level is clearly directory. In effect, it is acting like pop() for paths. This differs from fileparse()s behaviour.

# Both return "bar"
basename("/foo/bar");
basename("/foo/bar/");

@suffixes work as in fileparse() except all regex metacharacters are quoted.

# These two function calls are equivalent.
my $filename = basename("/foo/bar/baz.txt", ".txt");
my $filename = fileparse("/foo/bar/baz.txt", qr/Q.txtE/);

Also note that in order to be compatible with the shell command, basename() does not strip off a suffix if it is identical to the remaining characters in the filename.

dirname

This function is provided for compatibility with the Unix shell command dirname(1) and has inherited some of its quirks. In spite of its name it does NOT always return the directory name as you might expect. To be safe, if you want the directory name of a path use fileparse().

Only on VMS (where there is no ambiguity between the file and directory portions of a path) and AmigaOS (possibly due to an implementation quirk in this module) does dirname() work like fileparse($path), returning just the $directories.

# On VMS and AmigaOS
my $directories = dirname($path);

When using Unix or MSDOS syntax this emulates the dirname(1) shell function which is subtly different from how fileparse() works. It returns all but the last level of a file path even if the last level is clearly a directory. In effect, it is not returning the directory portion but simply the path one level up acting like chop() for file paths.

Also unlike fileparse(), dirname() does not include a trailing slash on its returned path.

# returns /foo/bar. fileparse() would return /foo/bar/
dirname("/foo/bar/baz");

# also returns /foo/bar despite the fact that baz is clearly a
# directory. fileparse() would return /foo/bar/baz/
dirname("/foo/bar/baz/");

# returns .. fileparse() would return foo/
dirname("foo/");

Under VMS, if there is no directory information in the $path, then the current default device and directory is used.

fileparse_set_fstype
my $type = fileparse_set_fstype();
my $previous_type = fileparse_set_fstype($type);

Normally File::Basename will assume a file path type native to your current operating system (ie. /foo/bar style on Unix, foobar on Windows, etc...). With this function you can override that assumption.

Valid $types are "MacOS", "VMS", "AmigaOS", "OS2", "RISCOS", "MSWin32", "DOS" (also "MSDOS" for backwards bug compatibility), "Epoc" and "Unix" (all case-insensitive). If an unrecognized $type is given "Unix" will be assumed.
If youve selected VMS syntax, and the file specification you pass to one of these routines contains a "/", they assume you are using Unix emulation and apply the Unix syntax rules instead, for that function call only.