Free dvdsubedit user manual software for linux

GIMP User Manual project is a user manual for the GIMP. It is written for the GIMP Help Browser, but can produce help pages for other formats as well.
Enhancements:
- New content (incl. spelling and grammar fixes) for German, French, Italian, Norwegian, Russian, Spanish and Korean
- The PDF version of the manual is now generated using dblatex
- Lots of bug fixes

Kpum is a user manager for the pureftpd server. You can add, modify and delete users of the pureftpd server.
Currently only the pureftpd.pdb database is supported. Kpum is a application for the KDE environment.
Installation:
make -f admin/Makefile.common
./configure
make
su
make install
exit
Enhancements:
- toolbar + statusbar added
- double click on user opens user edit dialog
- userdefinied remove of fields from listview
- User ID
- Group ID
- max. Upload
- max. Download
- max. Files
- max. Size
- Up/Down Ratio
- Time
- Restrictions
- max. Connections
- user must not longer be root
- storing of window position and size
- default user/group/home directory option added
- KDE 3.1.x build fix

OpenInteract2::Manual::I18N is an internationalization in OpenInteract2.

SYNOPSIS

This part of the manual will describe i18n efforts in OpenInteract2, how to create message bundles to distribute with your application, and how you can customize the process.

CAVEATS

Im a newbie at i18n/l10n efforts. The main purpose is to find the path I think most web applications will trod and make that as simple as possible to navigate. The hooks in the framework to enable localization should be sufficiently unobtrusive so as not to preclude other efforts you may have in this area.

So if you have ideas about how things can be done better or more flexibly, please join the openinteract-dev mailing list and chime in. (See "SEE ALSO" for more info on the mailing list.)

WRITING LOCALIZED APPLICATIONS

100% localization is hard

Localizing every aspect of your application is extremely difficult. There are the easy things like translating words on the screen, date/time formats and money. Then there are the tough things: what does this shade of yellow mean in China versus Saudi Arabia? What happens if someone reads this sequence of graphics from right-to-left instead of left-to-right? And on and on for many more items you couldnt have even thought up yet.

OpenInteract wont presume to take care of all these for you. Instead we try to make the most common operations as simple as possible. Hopefully that will be sufficient for your needs.

OpenInteract2::Manual::Widgets Perl module contains template widgets in OpenInteract.

OpenInteract2 supports using templates as a simple graphical widget. A widget is a common element into which you can just plug in text or parameters to customize it. For example, an INPUT element of type TEXT is a particular type of widget -- you can customize its size, name, and default value. (Some widget implementations will maintain state for you across requests, have validation, etc. These dont do that.)

Widgets can also include other widgets. Such as a row that uses the INPUT TEXT widget described above to create a labeled input field, with a label on the left and the input widget on the right.

One of the main benefits of using these over HTML is centralization -- a change in one place enacts changes throughout your site. All column headers can look a certain way and be changed easily, all textboxes can be consistent and you can create widgets specific to your site and needs -- such as for inputting dates or money, or displaying addresses-- for a consistent user interface.

Heres an example:

[%########################################
form_text( name, value, size, maxlength, field_label )
Generate a simple text field.

Defaults:
size = 20
maxlength = 50
########################################-%]

[%- DEFAULT size = 20;
DEFAULT maxlength = 50; -%]
[%- field_pre_label -%]
< input type="text" name="[% name %]" value="[% value %]"
size="[% size %]" maxlength="[% maxlength %]" >
[%- field_label -%]

And you would reference this like:

[% INCLUDE form_text( name = "batting_average",
value = ".389" size = 5 ) -%]

And when the template is processed, get in return:

< input type="text" name="batting_average" value=".389"
size="5" maxlength="50" >

Calling widgets from other widgets is just as simple:

[%########################################
label_form_text_row( label, count, name, value,
field_label )
Display a row to input text: label on left,
text input on right.

Defaults:
colspan = 2
########################################-%]

[%- DEFAULT colspan = 2; -%]
[%- INCLUDE label_row_begin( colspan = 1 ) -%]
[%- INCLUDE data_cell_begin %][% INCLUDE form_text %]
< /td >< /tr >

Here we call three separate items, two of which (label_row_begin and data_cell_begin) arent really widgets but rather just named areas for common code. This might be called:

[% INCLUDE label_form_text_row( label = Batting Average,
name = batting_average,
value = .389, size = 5 ) -%]

And result in:

< tr valign="middle" >
< td align="right" >< b >Batting Average< /b >< /td >
< td align="right" >
< input type="text" name="batting_average" value=".389"
size="5" maxlength="50" >
< /td >
< /tr >

And youre not restricted to simple fill-in elements either. You can represent a common data-oriented widget -- such as a drop-down box representing countries your company services -- in this manner as well. Heres how such a call might look:

[%# Use USA as default, antagonizing the rest of the world...-%]
[%- picked_country = user.country || United States -%]
[% INCLUDE label_form_country_select( label = Countries,
name = country,
picked = picked_country ) -%]

Using this, the page designer doesnt care how many countries the company services, whether a new one has been added to the list, etc. Just make the call and the graphic element will be created the same way every time.

Using these template widgets you can build a library of display elements very quickly.

OpenInteract2::Manual::Tutorial is a Perl module that will teach learn you how to create and modify a package.

SYNOPSIS

This tutorial will show you the different methods for creating a package and how to maintain them.

CREATING THE PACKAGE

A word on the example

For our example were going to create a book package. This will keep track of all our books and allow us to search our library, add new books, update existing ones and remove old ones. It wont be the backbone for a massive e-commerce website to make you lots of money. It does not attempt to best model the relationships for all the data about a book.

Looking for shortcuts?

If you want to get something running in the fastest manner possible we can generate a simple CRUDS application for you. (CRUDS: CReate Update Delete Search) Just run something like the following:

$ oi2_manage easy_app --package=book --table=book
--dsn=DBI:Pg:dbname=mylibrary --username=foo --password=bar

This will create a simple application built off a table book with templates and objects for searching, creating, updating and removing objects. (More at OpenInteract2::Manage::Package::CreatePackageFromTable.)
Since this is a tutorial well assume you want to read to learn, so on we go.

Generating the skeleton

OpenInteract comes with tools to create a skeleton package -- we dont want to do all this from scratch! The skeleton package has the directory structure, metadata and a number of files to get you going on your new package. Heres how to create one -- be sure to first go to the directory under which the package will be created:

$ oi2_manage create_package --package=book

And heres what youll see:

PROGRESS: Starting task
PROGRESS: Task complete
ACTION: Create package book
OK: Package book created ok in /path/to/my/book

And now lets see what it created:

$ find book/
book/
book/conf
book/conf/spops.ini
book/conf/action.ini
book/data
book/doc
book/doc/book.pod
book/struct
book/template
book/template/sample.tmpl
book/script
book/html
book/html/images
book/OpenInteract2
book/OpenInteract2/Action
book/OpenInteract2/Action/Book.pm
book/OpenInteract2/SQLInstall
book/OpenInteract2/SQLInstall/Book.pm
book/package.ini
book/MANIFEST.SKIP
book/Changes
book/MANIFEST

These files and directories are explained in OpenInteract2::Manual::Packages.

You will normally need to edit/add the following:

book/package.ini # Add name, version, author information
book/MANIFEST # Add names of distribution files
book/conf/spops.ini # Describe the objects your package uses
book/conf/action.ini # Map URLs to handlers in your package
book/data # Specify the initial data and security
book/struct # Describe the tables used to store your objects
book/template # HTML to display and manipulate your objects
book/OpenInteract2 # Optional Perl modules defining object behavior
book/OpenInteract2/Action # Manipulate objects for desired functionality
book/OpenInteract2/SQLInstall # Tell the installer about your tables, data, security
book/doc/book.pod # Last but not least, tell the world about it

Short sidebar: Creating a MANIFEST

Notice that we create a MANIFEST file for you when the package is created. As you add more files to your package youll need to add them to your book/MANIFEST. Fortunately, it can be created automatically:

$ cd /path/to/mypackage
$ perl -MExtUtils::Manifest -e ExtUtils::Manifest::mkmanifest()

Thats it! If you have an old MANIFEST file in the directory it will be copied to MANIFEST.bak. Also note that files matching patterns in the book/MANIFEST.SKIP file will not be included.

Bio::Phylo::Manual is a Perl module that contains a Bio::Phylo v.0.14 user guide.

This is the manual for Bio::Phylo. Bio::Phylo is a perl5 package for phylogenetic analysis. For installation instructions, read the README file in the root directory of the distribution. The stable URL for the most recent distribution is http://search.cpan.org/~rvosa/Bio-Phylo/

dtRdr::User.pm is a user class as a Perl module.

Constructor

new

$user = dtRdr::User->new($username);

Methods

init_config

$user->init_config($filename);