Free page layout program software for linux

Page Curl plug-in does the well-known page curl effect (a la KPT).

It is likewhen you curl one of the corners of a sheet of paper.

Page Title Eraser is a Firefox extension which provides more privacy at your workplace by hiding the title and icon of a selected tab.

I always open several tabs in a Firefox window, but I would not like other people see some of tabs labels. So I wrote the PTE extension which helps me to have such feature. I hope that it can be useful for office people.

The Page Title Eraser adds menu item to the page context menu and "Tools" menu items. "Right-click" menu includes a "Hide title" menu item now. Using this item you can hide/show tab and window titles and tab icon. Each tab has its independent instance of this item.

Since version 0.3.0 you can hide or show all tabs labels using "Hide all titles" menu item. Using the "Options" window you can tell PTE to hide/show the icons of tabs as well as the titles of tabs (see screenshots).

Toolbar button and hot key combination (Ctrl + Shift + H) are also available.

Translations included: Arabic, Arabic (Saudi Arabia), Chinese (Traditional), Croatian, Dutch (NL), English, French, Italian, Persian, Polish, Portuguese (Brazilian), Russian, Slovak, Spanish (Spain).

Tired of clicking the reload button? Page Update Checker (aka PUC -- pronounced "Puke" is a FireFox extension that automatically checks to see if web pages have changed.

How to Use:

Once installed, you will be able to right-click on any page in Firefox and select "Monitor for Updates". The PUC options will open up and you can select how often you would like PUC to download the webpage and see if it has changed. To return to the options menu later, select "Tools" -> "Page Update Checker Options..."

Click the homepage link to find the PUC Wiki and share your Update Checkers!

Gtk2::Ex::FormFactory::Layout can do layout in a FormFactory framework.

SYNOPSIS

package My::Layout;

use base qw/Gtk2::Ex::FormFactory::Layout/;

sub build_form { ... }
sub add_widget_to_form { ... }
...

package main;

$ff = Gtk2::Ex::FormFactory->new (
layouter => My::Layout->new(),
...
);

This class implements the layout of Containers and their Widgets in a Gtk2::Ex::FormFactory framework. "Layout" means, how are the widgets aligned to each other, how much space is between them, how are titles rendered, how labels, etc.

The idea behind Gtk2::Ex::FormFactory::Layout is to have a unique point in a GUI application which actually implements these things. The advantage of this approach is obvious: the implementation is very generic and if you want to change layout things you subclass from Gtk2::Ex::FormFactory::Layout and implement your changes there, and not at hundreds of spots distributed over the source code of your application.
The natural result: a consistent looking GUI.

g-page is a client/server application for Unix designed to send text messages to alphanumeric pagers or PCS phones with short messaging, SMS, capabilities.

It supports the SNPP, WCTP, and SMTP (email) protocols, and works on a stand-alone workstation or across a network.

PLplot is a library of functions that are useful for making scientific plots.
PLplot can be used from within compiled languages such as C, C++, FORTRAN and Java, and interactively from interpreted languages such as Octave, Python, Perl and Tcl.
The PLplot library can be used to create standard x-y plots, semilog plots, log-log plots, contour plots, 3D surface plots, mesh plots, bar charts and pie charts. Multiple graphs (of the same or different sizes) may be placed on a single page with multiple lines in each graph.This program wants to offer interactive plotting using the Tcl programming language with plotting extensions.
A variety of output file devices such as Postscript, png, jpeg, LaTeX and others, as well as interactive devices such as xwin, tk, xterm and Tektronics devices are upported. New devices can be easily added by writing a small number of device dependent routines.There are almost 2000 characters in the extended character set. This includes four different fonts, the Greek alphabet and a host of mathematical, musical, and other symbols. Some devices supp
Many different output device drivers are available, including postscript, tektronix, HP laserjet, HP pen plotters, XFig, xterm, X-windows, and a portable metafile format, among others. The Tk driver under Unix/X provides a full user interface based on the plframe plotting widget (see below). The metafile renderer (plrender) supports all of the standard operations as well as seeking operations (backward, forward, or to any specified page) when interactively viewing metafile output.
Part of the PLplot package is a Tcl-based interpreter (pltcl).
Also part of PLplot is a Tk-based plotting widget, called a plframe. This widget is based on the Tk frame widget, and supports a variety of user options such as zoom, scrolls, save to a variety of devices, print, resize, page layout, orientation change, and palette manipulation. Direct plotting to the widget may be done by calls to the underlying library using either C or Fortran bindings, and a large number of operations can be interpreted directly (in Tcl) by the widget.
Enhancements:
- * Commit (with a few changes) C++ interface upgrade (at least 13 new PLplot library calls are now available) donated by Andrew Ross under the LGPL. The Plplot initialization has now been separated which allows plplot commands that are supposed to be done before init (such as command-line option processing) to work for the first time. This constitutes a backwards-incompatible change that will be signalled by a new
- libplplotcxx library major version number.
-
- Commit (with a few changes) extended set of C++ examples donated by Andrew Ross under the LGPL. These examples test the interface by attempting to mimic the results of the corresponding C examples.
-
- x01cc.c: Change this one old (but still interesting) C++ example to use the updated interface.
- examples/c++/Makefile.am: extend the install to the new examples, create symlink for lena.pgm (so x20 works), and use install-hook (no more .samename) for post-install changes.

Data::Page::Viewport is a Perl module to scroll thru data a page, or just an item, at a time.

Synopsis

This is a complete, tested, runnable program.
#!/usr/bin/perl

use strict;
use warnings;

use Data::Page::Viewport;

# -----------------------------------------------

my(@data) = (qw/zero one two three four five six
seven eight nine ten eleven twelve thirteen fourteen/);
my($page) = Data::Page::Viewport -> new
(
data_size => scalar @data,
page_size => 4
);

print "Data bounds: 0 .. $#data. n";
print "Data: ", join(, , @data), ". n";
print "Page bounds: 0 .. 3. n";
print "Page data: ", join(, , @data[0 .. 3]), ". n";
print "n";

my(@bound);

for (-2, 1, 4, 4, 1, 3, 3, -2, 1, 2, 1, -4, -4,
-1, 1, 2, -1, -2, -2, -1, -4, 4, 4, 4)
{
print "Offset: $_. n";

@bound = $page -> offset($_) -> bounds();

print "Page bounds: $bound[0] .. $bound[1]. n";
print Page data: ,
join(, , @data[$bound[0] .. $bound[1] ]),
". n";
print - x 50, "n";
}

Data::Page::Viewport is a pure Perl module.

This module keeps track of what items are on the current page, when you scroll forwards or backwards within a data set.

Similarly to Data::Page, you can call sub offset(N), for + or - N, to scroll thru the data a page at a time.

And, like Set::Window, you can call sub offset(N), for + or - 1, to scroll thru the data an item at a time.

Clearly, N does not have to be fixed.

The viewport provides access to the current page, and the code shifts indexes into and out of the viewport, according to the parameter passed to sub offset().

Note that the data is not passed into this module. The module only keeps track of the indexes within the viewport, i.e. indexes on the current page.

You call sub bounds() on the object (of type Set::Window) returned by sub offset(), to determine what indexes are on the current page at any particular point in time.

Also note that, unlike Set::Window, the boundaries of the viewport are rigid, so that changes to the indexes caused by sub offset() are limited by the size of the data set.

This means, if you do this:

my($page) = Data::Page::Viewport -> new
(
data_size => $#data, # 0 .. $#data.
page_size => $page_size, # 1 .. N.
);

my(@bound) = $page -> offset(- 1) -> bounds();

the call to sub offset(- 1) will have no effect.

That is, when trying to go back past the beginning of the data set, the bounds will be locked to values within 0 .. data_size.

Similarly, a call which would go beyond the other end of the data set, will lock the bounds to the same range.

In short, you cant fall off the edge by calling sub offset().

This in turn means that the values returned by sub bounds() will always be valid indexes within the range 0 .. data_size.

The module implements this by building 2 objects of type Set::Window, one for the original data set (which never changes), and one for the current page, which changes each time sub offset() is called (until the boundaries are hit, of course).

Note: No range checking is performed on the parameters to sub new().

Note: It should be obvious by now that this module differs from Data::Page, and indeed all such modules, in that they never change the items which are on a given page. They only allow you to change the page known as the current page. This module differs, in that, by calling sub offset(+ or - N), you are effectively changing the items which are deemed to be on the current page.