Free web objects tutorial software for linux

Rose::DB::Object::Tutorial is a guided tour of the basics of Rose::DB::Object.

INTRODUCTION

This document provides a step-by-step introduction to the Rose::DB::Object module distribution. It demonstrates all of the important features using a semi-realistic example database. This tutorial does not replace the actual documentation for each module, however. The "reference" documentation found in each ".pm" file is still essential, and contains some good examples of its own.

This tutorial provides a gradual introduction to Rose::DB::Object. It also describes "best practices" for using Rose::DB::Object in the most robust, maintainable manner. If youre just trying to get a feel for whats possible, you can skip to the end and take a look at the completed example database and associated Perl code. But I recommend reading the tutorial from start to finish at least once.

The examples will start simple and get progressively more complex. You, the developer, have to decide which level of complexity or abstraction is appropriate for your particular task.

CONVENTIONS

Some of the examples in this tutorial will use the fictional My:: namespace prefix. Some will use no prefix at all. Your code should use whatever namespace you deem appropriate. Usually, it will be something like MyCorp::MyProject:: (i.e., your corporation, organization, and/or project). Ive chosen to use My:: or to omit the prefix entirely simply because this produces shorter class names, which will help this tutorial stay within an 80-column width.

For the sake of brevity, the use strict directive and associated "my" declarations have also been omitted from the example code. Needless to say, you should always use strict in your actual code.

Similarly, the traditional "1;" true value used at the end of each ".pm" file has been omitted from the examples. Dont forget to add this to the end of your actual Perl module files.

Although most of the examples in this tutorial use the base.pm module to set up inheritance, directly modifying the @ISA package variable usually works just as well. In situations where there are circular relationships between classes, the use base ... form may be preferable because it runs at compile-time, whereas @ISA modification happens at run-time. In either case, its a good idea to set up inheritance as early as possible in each module.

package Product;

# Set up inheritance first
use base qw(Rose::DB::Object);

# Then do other stuff...
...

Web Business Pro is a Web application designed for everyday business activities. The project includes support for customer lists, inventory, receipt printing, and accounting. Fully featured search functions and filters make it easy to find what you need quickly.

Tkx::Tutorial Perl module contains a tutorial about how to use Tkx.

Tk is a toolkit that allows you to create applications with graphical interfaces for Windows, Mac OS X and X11. The Tk toolkit is native to the Tcl programming language, but its ease of use and cross-platform availability has made it the GUI toolkit of choice for many other dynamic languages as well.

Tkx is a Perl module that makes the Tk toolkit available to Perl programs. By loading the Tkx module Perl programs can create windows and fill them with text, images, buttons and other controls that make up the user interface of the application.

Hello World

Lets start with the mandatory exercise of creating an application that greats the world. Here we make the application window contain a single button which will shut down the application if clicked. The code to make this happen is:

use Tkx;

Tkx::button(".b",
-text => "Hello, world",
-command => sub { Tkx::destroy("."); },
);
Tkx::pack(".b");

Tkx::MainLoop()

Save this to a file called hello.pl and then run perl hello.pl to start up the application. A window with the text "Hello, world" should appear on your screen.
After the Tkx module has been loaded by the use Tkx statement the application will show an empty window called ".". We create a button with the name ".b" and tell the window to display the button with the call to Tkx::pack(). After the layout of the window has been set up we need to pass control back to Tk so that it can draw the window and invoke our callback if the button is clicked. This is achieved by the Tkx::MainLoop() call at the end. Clicking the button will invoke the subroutine registered with the -command option of the button. In this case the callback simply destroys the window, which in turn will terminate the application.

Bigtop::Docs::Tutorial is a simple case study of building a web app with bigtop.
Many (not all) applications are mostly data managers. That is, they are really intermediaries between users and various tables in a database. A bigtop file is meant to be a single place to describe all (or practically all) facits of the data in an application. This includes at least:
- The name and special features of each controller.
- The name of each table in the database.
- A description of each column (field) in each table in the database. This includes at least:
- its name and SQL type
- the label the user sees for it when it appears on the screen
- what type of html form element the user uses to enter or update it
- how the data is validated and filtered on its way into and out of the database (filtering yet supported)
- which table the field refers to if it is a foreign key
- etc.
All of these things, and more, are described in a Bigtop file. That file can be given to bigtop to build the application. Once it is built, it can be safely rebuilt so that only the generated bits are changed (this is accomplished by maintaining a clean separation between generated and hand edited files, and by config options in the bigtop file).
Notice that nothing in the above has committed you or me to any particular web application framework, data modeling scheme, templating system, or web server. Bigtop is neutral (think big tent), at least for Perl apps delivered via the web.

Album::Tutorial is a Perl module on how to use the Album program.

SYNOPSIS

This tutorial describes the basic use of the Album program to create and maintain browser based photo albums.

Getting started

To get started, create a new directory and cd to it. Create a subdirectory large and put some pictures there. If you have installed the album tool in your execution path, you can now execute it as follows:

$ album -v
No info.dat, adding images from large
info.dat: Cannot update (does not exist)
Number of entries = 7 (7 added)
mkdir thumbnails
mkdir icons
mkdir css
Creating icons: first-gr.png first.png ... sound.png movie.jpg
Creating style sheets: common.css index.css ... journal.css
im023.jpg: thumbnail OK
im024.jpg: thumbnail OK
im025.jpg: thumbnail OK
im026.jpg: thumbnail OK
im027.jpg: thumbnail OK
im028.jpg: thumbnail OK
im029.jpg: thumbnail OK
Creating pages for 7 images
(Needed to write 7 image pages)
Creating pages for 1 index
(Needed to write 1 index page)

Your results will vary, but be similar to this example run. What you can see is that album found 7 images in the large directory, created thumbnails, icons and css directories, created thumbnails by resizing the images, and finally created the HTML pages. You can inspect your first photo album by opening file index.html with your favorite browser. You can click on any image to see the larger version. Navigation buttons are provided to the left of the image.

It is interesting to run album again:

$ album -v
No info.dat, adding images from large
info.dat: Cannot update (does not exist)
Number of entries = 7 (7 added)
.......[7]
Creating pages for 7 images
(No image pages needed updating)
Creating pages for 1 index
(No index pages needed updating)

album tries to avoid doing unnecessary work as much as possible. In this case, all thumbnails and image and index pages are up to date. The line of periods shows progress, one period for each image processed.

Test::Unit::Tutorial is a Perl module that contains a tutorial on unit testing.

SYNOPSIS

perldoc Test::Unit::Tutorial

Here should be extensive documentation on what unit testing is, why it is useful, and how to do it with the Test::Unit collection of modules.

Sorry for not implementing this yet.

Please have a look at the examples in the examples directory and read the README file that came with this distribution.

A short tutorial on how to use the unit testing framework is included in Test::Unit::TestCase.

Further examples can be found by looking at the self test collection, starting in Test::Unit::tests::AllTests.

RiveScript::Tutorial is a beginners guide to creating their first RiveScript brain.

This tutorial outlines the various capabilities of the RiveScript specification and offers some recommended pointers for creating a well-formed RiveScript brain. What you do with this knowledge is up to you; be creative!

Be sure to skim over the RiveScript manpage first, because this tutorial jumps right in to using the various RiveScript commands without always explaining what each of them do.

A Simple RiveScript Interpreter

Here is a simple Perl script for running a RiveScript interpreter. This assumes that the brains RS files will be stored in a directory called "tutorial", local to the Perl script. Youd want to edit certain parameters in this code if you see fit.

#!/usr/bin/perl -w

use strict;
use warnings;
use RiveScript;

# Create the RiveScript interpreter.
my $rive = new RiveScript();

# Load the RS tutorial brain.
$rive->loadDirectory ("./tutorial");

# Sort them.
$rive->sortReplies;

# Go into a chatting loop.
while (1) {
print "User> ";
my $msg = ;
chomp $msg;

# Grab a reply.
my @reply = $rive->reply (user,$msg);
print " Bot> $_n" foreach(@reply);
}

KDE Simple Programming Tutorial is a tutorial for developing a KDE application.

With the only requirement of a little C++ knowledge, and using the latest KDE snapshots, the reader will learn how to build his/her first KDE application from a simple "Hello world" button to a Web browser with a DCOP interface that communicates with a bookmark application running in a separate process.

Theres also a spanish and a romanian version of the documentation.