Free locations software for linux

Data::Locations - magic insertion points in your data
Did you already encounter the problem that you had to produce some data in a particular order, but that some piece of the data was still unavailable at the point in the sequence where it belonged and where it should have been produced?
Did you also have to resort to cumbersome and tedious measures such as storing the first and the last part of your data separately, then producing the missing middle part, and finally putting it all together?
In this simple case, involving only one deferred insertion, you might still put up with this solution.
But if there is more than one deferred insertion, requiring the handling of many fragments of data, you will probably get annoyed and frustrated.
You might even have to struggle with limitations of the file system of your operating system, or handling so many files might considerably slow down your application due to excessive file input/output.
And if you dont know exactly beforehand how many deferred insertions there will be (if this depends dynamically on the data being processed), and/or if the pieces of data you need to insert need additional (nested) insertions themselves, things will get really tricky, messy and troublesome.
In such a case you might wonder if there wasnt an elegant solution to this problem.
This is where the "Data::Locations" module comes in: It handles such insertion points automatically for you, no matter how many and how deeply nested, purely in memory, requiring no (inherently slower) file input/output operations.
(The underlying operating system will automatically take care if the amount of data becomes too large to be handled fully in memory, though, by swapping out unneeded parts.)
Moreover, it also allows you to insert the same fragment of data into SEVERAL different places.
This increases space efficiency because the same data is stored in memory only once, but used multiple times.
Potential infinite recursion loops are detected automatically and refused.
In order to better understand the underlying concept, think of "Data::Locations" as virtual files with almost random access: You can write data to them, you can say "reserve some space here which I will fill in later", and continue writing data.
And you can of course also read from these virtual files, at any time, in order to see the data that a given virtual file currently contains.
When you are finished filling in all the different parts of your virtual file, you can write out its contents in flattened form to a physical, real file this time, or process it otherwise (purely in memory, if you wish).
You can also think of "Data::Locations" as bubbles and bubbles inside of other bubbles. You can inflate these bubbles in any arbitrary order you like through a straw (i.e., the bubbles object reference).
Note that this module handles your data completely transparently, which means that you can use it equally well for text AND binary data.
You might also be interested in knowing that this module and its concept have already been heavily used in the automatic code generation of large software projects.
Enhancements:
- Fixed test file "02___refcount.t" to auto-adjust the offset dealing with self-ties not incrementing
- the refcount in some Perl versions.
- Added a warning to "Makefile.PL" that Perl versions including and between v5.6.1 and v5.7.0 are not fully supported (test file "11_______dump.t" dumps core).

Location Navigator is a Firefox extension that lets you grab a location, select a portion of the location that varies, and then navigate up or down from that starting spot.

main + location toolbar is a little hack for KDE (KDE improvement).

I dont know if there out is a hack to get maintoolbar + locationtoolbar in one line... but i did it by myself.

I get all normal bottons, location-depending bottons (in kghostview for exemple) and location toolbar (I tink find combo should work too).

edit ~/.kde/share/apps/konqueror/konqueror.rc:

-remove locationbar section
-maintoolbar section should be like the download (i cant put it here...)

I hope this work for anyone who prefers this toolbar way and in a easy way...

Image::ExifTool::Location is a Perl module with easy setting, getting of an images location information.

SYNOPSIS

use Image::ExifTool;
use Image::ExifTool::Location;

my $exif = Image::ExifTool->new();

# Extract info from existing image
$exif->ExtractInfo($src);
# Set location
$exif->SetLocation(54.787515, -2.341355);
# Set elevation
$exif->SetElevation(515);
# Write new image
$exif->WriteInfo($src, $dst);

Image::ExifTool is a versatile module for reading and writing EXIF data in a number of image formats. This module extends its interface adding methods that simplify the reading and writing of GPS location information.

Without this module the interface for working with GPS location information is cryptic. To store latitude and longitude a total of four EXIF values are used - two to store the latitude and longitude in degrees, minutes and seconds format and two to store the hemisphere (north / south, east / west).

This module replaces that cryptic interface with simple calls (GetLocation and SetLocation) that take care of encoding and decoding the latitude and longitude values correctly.

LowCal is a lightweight Web-based calendar of events.
These instructions assume you have root access to the machine youre installing on. If you dont, youre not likely to be able to install new apache modules without help (and permission) from a system administrator.
You need to actually install the code to the appropriate directories. Running install.pl in the directory where you unpacked the tarball will do this. By default, the LowCal module itself will install under /usr/local/lib/site_perl and command-line utilities will be installed in /usr/local/bin. If these locations are not appropriate for your system, edit the values of $module_dir and/or $util_dir near the top of the script before running it.
Enhancements:
- Cleaned up handling of day-of-month past end-of-month (PR#7)

libpcapnav is a libpcap wrapper library that allows navigation to arbitrary locations in a tcpdump trace file between reads.
The API is intentionally much like that of the pcap library. You can navigate in trace files both in time and space: you can jump to a packet which is at appr. 2/3 of the trace, or you can jump as closely as possible to a packet with a given timestamp, and then read packets from there. In addition, the API provides convenience functions for manipulating timeval structures.
Like libpcap, this library handles things through an opaque handle struct. For trace file navigation and reading packets, this handle is enough. If you need to apply BPF filters or write packets to disk, you can access the familiar pcap handle that is used internally.
At the core of libpcapnav is the ability to resynchronize to the sequence of packets contained in a tcpdump trace file at arbitrary location of the file position indicator.
The algorithm is based on Vern Paxsons method from the the tcpslice tool, that basically works as follows: the point near which the file position indicator is to be synchronized with the packet sequence is undershot a little bit, as it is much easier to scan forwards to the desired location, once the packet sequence has been detected.
The file is scanned from that initial offset in single-byte steps, at each step assuming a libpcap packet header is present and sanity-checking the values read. Several checks analyze this potential header for sane timestamps, capture lengths etc. If the header appears valid, the next packet header is examined in a similar function, based upon the offset that the checked header provides.
If a sequence of three packets seems valid, the algorithm considers the file position pointer to be synchronized with the packet flow and scans as closely as possible to the desired location. If the synchronization point is supposed to be a packet with a given timestamp, some interpolation is done and the process repeated, until the packet closest to the desired timestamp has been found.x
Enhancements:
- This release introduces large file support and better build support on OS X.

Log::Report::Lexicon::PO is a Perl module with one translation definition.

METHODS

Constructors

Log::Report::Lexicon::PO->new(OPTIONS)

Option --Default
automatic ""
comment []
format []
fuzzy false
msgid
msgid_plural undef
msgstr "" or []
references []
. automatic => PARAGRAPH

Automaticly added comments. See addAutomatic().

. comment => PARAGRAPH

Translator added comments. See addComment().

. format => ARRAY-OF-PAIRS|HASH

See format().

. fuzzy => BOOLEAN

The string is not yet translated, some smart guesses may have been made. See fuzzy().

. msgid => STRING
. msgid_plural => STRING
. msgstr => STRING|ARRAY-OF-STRING

The translations for the msgid. When msgid_plural is defined, then an ARRAY must be provided.

. references => STRING|ARRAY-OF-LOCATIONS

The STRING is a blank separated list of LOCATIONS. LOCATIONs are of the form filename:linenumber, for instance lib/Foo.pm:42 See addReferences()

Attributes

$obj->addAutomatic(LIST|ARRAY|STRING)

Add multiple lines to the translators comment block. Returns an empty string if there are no comments.

$obj->addComment(LIST|ARRAY|STRING)

Add multiple lines to the translators comment block. Returns an empty string if there are no comments.

$obj->addFlags(STRING)

Parse a "flags" line.

$obj->addReferences(STRING|LIST|ARRAY)

The STRING is a blank separated list of LOCATIONS. The LIST and ARRAY contain separate LOCATIONs. A LOCATION is of the form filename:linenumber. Returns the internal HASH with references.

$obj->automatic([LIST|ARRAY|STRING])

Returns a STRING which contains the cleaned paragraph of automatically added comments. If an argument is specified, it will replace the current comment.

$obj->comment([LIST|ARRAY|STRING])

Returns a STRING which contains the cleaned paragraph of translators comment. If an argument is specified, it will replace the current comment.

$obj->format(LANGUAGE|PAIRS|ARRAY-OF-PAIRS|HASH)

When one LANGUAGE is specified, it looks whether a LANGUAGE-format or no-LANGUAGE-format is present in the line of FLAGS. This will return 1 (true) in the first case, 0 (false) in the second case. It will return undef (also false) in case that both are not present.

You can also specify PAIRS: the key is a language name, and the value is either 0, 1, or undef.

Example: use of format()

if($po->format(c)) ...
unless($po->format(perl-brace)) ...
if(defined $po->format(java)) ...

$po->format(java => 1); # results in java-format
$po->format(java => 0); # results in no-java-format
$po->format(java => undef); # results in
$obj->fuzzy([BOOLEAN])

Returns whether the translation needs human inspection.

$obj->isActive

Returns whether the translation has any references, or is the header.

$obj->msgid

Returns the actual msgid, which cannot be undef.

$obj->msgstr([INDEX, [STRING]])

With a STRING, a new translation will be set. Without STRING, a lookup will take place. When no plural is defined, use INDEX 0

$obj->plural([STRING])

Returns the actual msgid_plural, which can be undef.

$obj->references([STRING|LIST|ARRAY])

Returns an unsorted list of LOCATIONS. When options are specified, then those will be used to replace all currently defined references. Returns the unsorted LIST of references.

$obj->removeReferencesTo(FILENAME)

Remove all the references to the indicate FILENAME from the list. Returns the number of refs left.

Parsing

Log::Report::Lexicon::PO->fromText(STRING, [WHERE])

Parse the STRING into a new PO object. The WHERE string should explain the location of the STRING, to be used in error messages.

$obj->toString(OPTIONS)

Format the object into a multi-lined string.

Option --Default
nr_plurals undef
. nr_plurals => INTEGER

If the number of plurals is specified, then the plural translation list can be checked for the correct lenght. Otherwise, no smart behavior is attempted.

$obj->unused

The message-id has no references anymore and no translations.