Free file software for linux

VFU is console (text mode) file manager for UNIX/Linux.

During the years I tried to make short attractive list of features which VFU has. Attractive as Advertising above :) and it does not seem to work... at least it didnt for me and I never liked it.

I made all possible to make VFU cover all file managing needs and offer large set of behaviour options. If I succeeded or not, you can decide for yourself but without trying I believe noone can say for sure.

Installation:

1. how to compile vfu

run `make from vfu base directory

this should compile everything

to compile each part of vfu manually do this:

-- go to `vslib directory
-- run `make
-- go to `vfu directory
-- run `make

if something goes wrong, check these:

-- if your `curses.h file locations is not `/usr/include/ncurses
you have to change this in the Makefile.

-- if vslib library is not in the `../vslib directory you also
have to change this in the Makefile.

2. how to install vfu

run `install script from vfu base directory

install script checks if all required files are available/built and then does this:

cp vfu/vfu rx/rx_* /usr/local/bin
cp vfu.1 /usr/local/man/man1
cp vfu.conf /usr/local/etc

3. how to install vfu manually

-- you have to copy `vfu in the `/usr/local/bin or
`/usr/bin directory and set mode to 755 `rwxr-xr-x
the owner is not significant ( root is also possible ).

-- there is preliminary man page ( vfu.1 ) which could be
copied to /usr/man/man1.

-- copy all `rx/rx_* tools to /usr/local/bin
-- install Net::FTP perl module if needed.
(this is used for FTP support)

WARNING: make sure to remove all old personal cache files!

i.File is a file manager for Linux written for the Windows refugees that are arriving in Linux only to find that the state of the user interface is rather poor. I personally somewhat fall into this catagory, although more as a power user than the average Joe.
Both the leading file managers for KDE and Gnome are well... not to put too fine a point on it: crap. There are just not ready for everyday use by normal people, because of the untold number of bugs in the usability and function that are STILL there 3 years after they first infested Linux desktops.
Not that this project will start off any better, but my hope is that itll end far more successfully than the aforementioned software. i.File project is targetted at other developers in an attempt to get some help with bringing it up to speed. Enough of the basic code layout and implementation is done so that the user can see how things should work. And now its just time to fill in the blanks and bust those bugs.
Main features:
- Be fast. i.File doesnt load icons for every file by its mime type. Because that takes too long. All the algorithms are designed to make it fast. The use of hashtables is pervasive. At no point should "eye candy" ever take precedence over speed. Startup/shutdown time should be sub-second. Drag and drop should have latencies around 100ms at most.
- All views of the same inode (file/dir/etc) point back to the same object, thus when the object changes, all views of that automatically update.
- Network accesses and all other tasks that can take time should be threaded. There is no excuse for locking up the GUI thread while the application goes off to get some data.
- Be minimal. i.File is not a thumb nail viewer, or any other type of viewer. Applications do the viewing, not the file manager. Viewing tasks bloat up the file manager.
- Every file is typed with a mime type. This is marginally better than using a files extension to associate it with an application.
- The Win2k implementation of Windows Explorer is the basis for some of the user interface because it works, people are used to it, and its "the standard". And no the experiments with file manager UI in Linux didnt work. They suck badly, thats why there is i.File in the first place.

File::Stat::ModeString - conversion file stat mode to/from string representation.

SYNOPSIS

use File::Stat::ModeString;

$string = mode_to_string ( $st_mode );
$st_mode = string_to_mode ( $string );
$type = mode_to_typechar( $st_mode );

$record = < IN >; chomp $record;
$record =~ m/^some_prefixs+$MODE_STRING_REs+some_suffix$/o
or die "invalid record format";

die "Invalid mode in $string"
if is_mode_string_valid( $string );

This module provides a few functions for conversion between binary and literal representations of file mode bits, including file type.

All of them use only symbolic constants for mode bits from File::Stat::Bits.

CONSTANTS

$MODE_STRING_RE

Regular expression to match mode string (without ^$).

FUNCTIONS

is_mode_string_valid( $string )

Returns true if argument matches mode string pattern.

$type = mode_to_typechar( $mode )

Returns file type character of binary mode, ? on unknown file type.

$string = mode_to_string( $mode )

Converts binary mode value to string representation. ? in file type field on unknown file type.

$mode = string_to_mode( $string )

Converts string representation of file mode to binary one.

Audio::File::AudioProperties is a Perl module that can abstract an audio files audio properties.

Audio::File::AudioProperties is the base class for other file format independant audio property classes like Audio::File::Flac::AudioProperties or Audio::File::Ogg::AudioProperties. You should not use this class yourself exept youre writing an own file format dependant subclass.

METHODS

new

Constructor. Creates new Audio::File::AudioProperties object. You shoud not use this method yourself. Its called by the filetype-dependant subclasses of Audio::File::Type automatically.

init

Initializes the object. Its called by the constructor and empty by default. Its ought to be overwritten by subclasses.

length

Returns the length of the audio file in seconds.

bitrate

Returns the bitrate of the file.

sample_rate

Returns the sample rate of the audio file.

channels

Returns the number of channels the audio file has.

all

Get all audio properties.

File::Drawing release, revise and retrieve contents to/from a drawing program module.

SYNOPSIS

##########
# Subroutine interface
#
use File::Drawing qw(
dod_date dod_drawing_number number2pm pm2number obsolete
broken backup);

$date = dod_date($sec, $min, $hour, $day, $month, $year);
$drawing_number = dod_drawing_number( );

$pm = number2pm($drawing_number, $repository);
$drawing_number = pm2number($drawing_number, $repository);

$old_value = config( $option );
$old_value = config( $option => $new_value);
(@all_options) = config( );

obsolete($drawing_number, $repository);
broken($drawing_number, $repository);
($file, $backup_file) = backup($drawing_number, $repository, $dir);

######
# Class Interface
#
use File::Drawing;

$default_options = defaults(@options);

$old_value = $default_options->config( $option );
$old_value = $default_options->config( $option => $new_value);
(@all_options) = $default_options->config( );

$drawing = new File::Drawing($contents, $white_tape, $pod, $file_contents, $drawing_number, $repository);

$drawing = File::Drawing->retrieve($drawing_number, @options);

$error = $drawing->release(@options);

$error = $drawing->revise(@options);

$date = $drawing->dod_date($sec, $min, $hour, $day, $month, $year);
$drawing_number = $$drawing->dod_drawing_number( );

$pm = $drawing->number2pm($drawing_number, $repository);
$drawing_number = $drawing->pm2number($drawing_number, $repository);

$drawing->obsolete($drawing_number, $repository);
$drawing->broken($drawing_number, $repository);
($file, $backup_file) = $drawing->backup($drawing_number, $repository, $dir);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

The File::Drawing program module uses American National Standards for drawings as a model for storing data. Commercial, governement and casual orgainizations have stored information over the centuries as drawings. Drawings probably evolved from the census that the Romans rulers, started back when Rome was a little frontier town. In other words, the practices of the drafting displines have evolved over time and have stood the test of time.

Any deviation must be a crystal clear advantage. Many of the practices are in place to avoid common and costly human mistakes that obviously a computerize drafting system will not make. A good approach is to make the computerized data structure optimum for computers and have the computer render the computerized data into a form that meets the drafting standards.

The File::Drawing program module, uses the Perl program module name as a drawing repository, drawing number combination. The contents of the drawing is contained in the program module file. The < File::Drawing > program module established methods to retrieve contents from a program module drawing file, create an Perl drawing object with the contents, and methods to release and revise the contents in a program module drawing file from a Perl drawing object. Other popular methods for computerize date are the SQL and XML. Perl has a wide range of program modules using these approach.

In this time in history, the Drawings are highly standardize and even subject to Internationl standarization agreements. The Drawing Sheet Size and Format conform to ANSI Y14.1-1975 or its successor. The drawing has a box with zone numbers running right to left alon the top and bottom, and zone letters running bottom to top along the sides. There is a section inside the box, lower right corner with the blocks for such things as the title, drawing number, current revision, authoriztion, and sheet number. There is an expandable four column table in the top right corner to record the revision history.

Audio::TagLib::File is a file class with some useful methods for tag manipulation.

This class is a basic file class with some methods that are particularly useful for tag editors. It has methods to take advantage of ByteVector and a binary search method for finding patterns in a file.

DESTROY()

Destroys this File instance.

PV name()

Returns the file name in the local file system encoding.

Tag tag() [pure virtual]

Returns this files tag. This should be reimplemented in the concrete subclasses.

AudioProperties audioProperties() [pure virtual]

Returns this files audio properties. This should be reimplemented in the concrete subclasses. If no audio properties were read then this will return undef.

BOOL save() [pure virtual]

Save the file and its associated tags. This should be reimplemented in the concrete subclasses. Returns true if the save succeeds.

ByteVector readBlock(UV $length)

Reads a block of size $length at the current get pointer.

void writeBlock(ByteVector $data)

Attempts to write the block $data at the current get pointer. If the file is currently only opened read only -- i.e. readOnly() returns true -- this attempts to reopen the file in read/write mode.

IV find(ByteVector $pattern, IV $fromOffset = 0, ByteVector $before = ByteVector::null)

Returns the offset in the file that $pattern occurs at or -1 if it can not be found. If $before is set, the search will only continue until the pattern $before is found. This is useful for tagging purposes to search for a tag before the synch frame.

Searching starts at $fromOffset, which defaults to the beginning of the file.

This has the practial limitation that $pattern can not be longer than the buffer size used by readBlock(). Currently this is 1024 bytes.

IV rfind(ByteVector $pattern, IV $fromOffset = 0, ByteVector $before = ByteVector::null)

Returns the offset in the file that $pattern at or -1 if it can not be found. If $before is set, the search will only continue until the pattern $before is found. This is useful for tagging purposes to search for a tag before the synch frame.

Searching starts at $fromOffset and proceeds from the that point to the beginning of the file and defaults to the end of the file.

This has the practial limitation that $pattern can not be longer than the buffer size used by readBlock(). Currently this is 1024 bytes.

void insert(ByteVector $data, UV $start = 0, UV $replace = 0)

Insert $data at position $start in the file overwriting $replace bytes of the original content.

This method is slow since it requires rewriting all of the file after the insertion point.

void removeBlock(UV $start = 0, UV $length = 0)

Removes a block of the file starting a $start and continuing for $length bytes.
This method is slow since it involves rewriting all of the file after the removed portion.

BOOL readOnly()

Returns true if the file is read only (or if the file can not be opened).

BOOL isOpen()

Since the file can currently only be opened as an argument to the constructor (sort-of by design), this returns if that open succeeded.

BOOL isValid()

Returns true if the file is open and readble and valid information for the Tag and / or AudioProperties was found.

void seek(IV $offset, PV $p = "Beginning")

Move the I/O pointer to $offset in the file from position $p. This defaults to seeking from the beginning of the file.

void clear()

Reset the end-of-file and error flags on the file.

IV tell()

Returns the current offset withing the file.

IV length()

Returns the length of the file.

BOOL isReadable(PV $file) [static]

Returns true if $file can be opened for reading. If the file does not exist, this will return false.

BOOL isWritable(PV $file) [static]

Returns true if $file can be opened for writing.

%_Position

Position in the file used for seeking. C<<less