Free gsxr 1000 software for linux

pgk is a Perl Gimp Kit, a OO perl gtk interface.

pgk::Widget

new ($name,$type)

pre: $name is the name of this widget.
$type is the type of this widget.
post: base class pgk::Widget created, that implements base
functions for all derived pgk classes.

add($widget)

pre: $widget is a derivative of pgk::Widget.
post: $widget has been added to the widgetlist of $self.

setHandle($handle)

pre: Got $handle from pgk_xs C-function and is a pointer
to a GTK widget.
post: $widget is associated with $handle.

$handle=getHandle()

pre: setHandle(..)
post: =the GTK widget pointer associated with this pgk widget.
Can be used in calls to pgk_xs.

setEvent($eventFunc,$eventType, ...)

pre: $eventType setEvent(main::LabelEvent, clicked, $dlg);

In case of a clicked event for the $lab label, main::LabelEvent
will be called with argument $dlg. E.g., fields in $dlg can be updated.

setTimer($millisecs,$timerFunc, ...)

pre:
post: Timer is set for $millisecs for this widget. After $millisecs,
&$timerFunc is called with arguments ....
Note: timerFunc returns 1 for continues calling.
timerFunc returns 0 for one shot calling.
smpl:
my $dlg=new pgk::Dialog(my_dialog, My title, 2, 2);
$dlg->setTimer(1000, main::updateTime, $dlg);

package main;

sub updateTime {
my $window=shift;
my $time=ctime();
$window->setValue($time);
return 1;
}

addTimer($millisecs, $timerFunc, ...)

pre:
post: Timer is added to the current widget. After $millisecs,
&$timerFunc is called with arguments $this, ....
Note: timerFunc returns 1 for continues calling.
timerFunc returns 0 for one shot calling.

smpl: my $dlg=new pgk::Dialog(my_dialog, My title, 2, 2);
$dlg->addTimer(1000, main::updateTime, "My extra argument");

package main;

sub updateTime {
my $self=shift;
my $txt=shift;
my $time=ctime();
$self->setValue($time." $txt");
return 1;
}

setProp($prop,$value|@value)

post: Property $prop of $widget has been set to $value.
smpl: $widget->setProp(myprop,"My Value");

getProp($prop)

post: = value of property $prop of $widget.
smpl: my $t=$widget->getProp(myprop);

setWidget($widget)

post: sets property widget.$widget->name() to $widget.

getWidget($name)

post: =widget of $name, if setWidget has been called before.
=undef, otherwise

setValue($value)

post: pgk::Widget base class implements this method by calling
setProp(value,$value).

getValue()

post: pgk::Widget base class implements this method by calling
getProp(value).

show()

post: shows all PGK widgets associated with the current
widget, including this one.

Quit()

post: Quits the application, destroying all pgk windows opened.

name()

post: =name of widget.

bbs100 is a BBS in the style of DOC and/or YAWC. DOC is a style that remotely resembles Citadel.
Whats special about bbs100, is that its a single process daemon that handles all connections at once, while consuming very low cpu resources ( < 1%). It can handle over a thousand simultaneous users.
It is highly customizable, is easy to setup, and has many configurable features. bbs100 is almost a must-have for people that want to run a DOC-style BBS.
Main features:
- over 1000 simultaneous users
- automatic name extension (press Tab)
- customizable login/logout notification messages
- colorized messages
- multiple recipients in messages and Mail>
- chat rooms
- personal chat rooms
- auto-reply functionality
- large friendlists (customizable)
- large profile info
- sorted Who-list (customizable)
- infinite number of rooms
- infinite number of room aides per room
- infinite number of sysops
- long passwords (80 characters)
- protection of users privacy
- easy configuration through menus
- advanced statistics
- an internal file cache
- single process BBS; uses < 1.0% CPU time even with lots of users online
- free and portable source code
- many more
Enhancements:
- This release fixes a couple of bugs that could crash the program.
- There is also a new Help menu.

Shttp is a partial implementation of HTTP/1.1. The project does not conform to the RFC but works well enough to serve static content in a experimental/educational context.

The module consists of well under 1000 LoC making it an excellent example of what can be done with ServerKit with little effort and a great learning tool for those getting started with ServerKit programming.

Usage:

It is advised that you read the ServerKit documentation before trying to use this module, as most of the basic usage is simply using ServerKit, nothing specific to this module.

Due to the simple nature of this module it does not include a personality template and it is not expected that you would use it under daemontools.

Instead, the module sources include a simple startup script to run it "in-tree" without installing it in the system. There is still a c11n file included which gets used "in-tree" as well. See below for the configuration options.

Pcb is a handy tool for the X Window System to design printed circuit boards. All coordinate units are 1/1000 inch. A layout consists of lines, arcs, polygons, elements (lines, pins and arcs), vias, and text information seperated into several layers.

Each of them is identified by a unique name and color (if supported by your display). SMD circuits are also supported. Eight layers are supported, in addition to a silkscreen layer. Visibility of pins and SMD pads and vias is controllable.

All files are 7-bit ASCII, and can be preprocessed with any Unix command that writes its results to stdout (GNU m4 is required). Zooming, unlimited undo, and unlimited redo are supported.

Pcb is intended to be a simple tool without memory and time consuming features like autorouter and autoplacement. Layout related settings are saved together with the data.

PagePoker is a Perl package that defines a browser agent with many powerful features for monitoring and testing Web sites, including elaborate failure handling that can send email and trigger SNMP traps. The application comes with three scripts that implement it for different uses: poke.pl, for single agents; pokes.pl, for many parallel agents, and pokehard.pl, for loadtesting and benchmarking.

HOW-TO:

Run "poke.pl --help" for detailed help on using the package. Briefly, poke.pl creates a PagePoker object, accepting all sorts of options. It is designed for monitoring web pages to verify they are returning desired information or to dump the contents of web pages to a file (like fetch). It can loop on a variety of conditions and crawl a series of pages, posting and passing cookies. The other component, pokes.pl, is simply a forking variation that accepts as its parameters an agent id and the options for that agent. It can be used for monitoring many sites simultaneously or for load testing single sites. On a dual 400 mhz machine I was able to run about 120 concurrent agents.

Examples:

> poke.pl --url http://node.to

returns (first element is date):
20000225170507 SUCCESS: Page loaded by agent

> poke.pl --url http://node.to --no-status --print-response

returns the plain html

> pokes.pl agent1 "--url http://node.to --no-status --email-failures
--email-address who@node.to --iterations 1000 --interval 10"
agent2 "--urls http://node.to>>http://tiny.node.to
--no-status --email-failures --email-address "1@1.com 2@2.com""

will launch two agents, first agent will poll node.to for connection failures every 10 seconds 1000 times, emailing if a failure is encountered, second agent will hit node.to then tiny.node.to and exit, emailing two people if either one doesnt respond.

There is a lot of logic to control how often and under what conditions email is sent. You can search for desired in text the headers or the html response, and send email or snmp traps on certain failure conditions. To loadtest, you could launch looping batches of ten agents, adding ten more a minute later in a another process, etc.

More advanced load testing can be done with pokehard.pl. It gets its own README (README.pokehard).

Here is the output of poke.pl --help, minus the USAGE statement:

How to use it:

--url "http://host/page"

--urls "http://host/page1>>http://host/page2>>etc"

--urls-from-file "file_path"

--urls-delay "n"
Seconds between each request

--method {GET|POST}

--post-query "query string"

--basic-auth-name "agent login" (one per agent)

--basic-auth-pass "agent password"

--interval "n"
Loop with n seconds between pokes

--iterations "n"
Cycles to run loop (requires --interval)

--look-for "pattern to find in response text"

--resend-cookie "cookiename"

--resend-cookie-between-iterations
Allow cookie to be resent through all iterations

--use-verbose-response
Includes headers in response text

--print-response
Dump agent retrieved text to STDOUT

--disable-on-failure
Allow server disabling on failure

--disable-snmp-trap "snmp trap"
To disable in loadbalancer

--enable-on-recovery
Allow server re-enabling on recovery

--enable-snmp-trap "snmp trap"
To enable server after successful run

--email-failures
Turn on alarm emails

--email-addresses "address1 address2 etc"

--email-subject "override default with arbitrary text"

--failures-until-email "n"
Consecutive errors triggers email

--min-time-between-emails "seconds"

--die-after-date "yyyymmddhhmmss" (requires interval and iterations)

--benchmark
Store numbers used for performance measurement (by pokehard.pl)

--quiet
Output nothing (except email, if set)

--no-status
Do not output status info (ie SUCCESS, etc)

--print-to-file "file"
Write output to file

--help
Print this text and exit

DCSquares is an addictive, fast-paced game for Linux.

Using your mouse or analog stick, move your player around to collect points and avoid enemys!

How to play:

Basics

Player - This is what you use to interact with the various other objects in the game. Use your mouse or analog control stick to move it around the board.
Score - Collecting these gives you points! The amount of points you get per square depends on how long youve been playing the current round.
Enemy - Touching one of these will end your game!

Powerups

Invincibility - Makes you invincible for a short amount of time. While invinible, touching enemys will have no affect.
Slow motion - Temporarily decreases the speed of the squares.
+1000 Points - Gives you 1000 points!
Mini square - Shrinks the size of your player.

Powerdowns

Evil squares - Changes every square into an emey for a short amount of time.
Speed - Temporarily increases the speed of the squares.
-1000 points - Takes away 1000 points.
Big square - Increases the size of your player.

Mindy is a very simple, serial molecular dynamics program derived from NAMD source code. It currently uses xplor parameter and structure files. The program is written in very straightforward C++.

Installation

Unpack the distribution. A directory named "mindy" will be created. In the mindy directory are two subdirectories, "src" and "test". The "src" directory contains the source code and a Makefile to build mindy.

Typing "make" within the src directory shoud build mindy using g++. If you would like to build mindy using a different compiler or different compiler flags, use one of the build targets in the Makefile or add a new one.

The executable is named mindy_$ARCH, where ARCH is the platform. by default, this is "g++".

Using

The command line syntax for mindy is:

mindy nsteps pdbfile psffile paramfile

Nsteps specifies how many timesteps to take. pdbfile and psffile are the coordinate and structure files, respectively, of the system you want to simulate. paramfile is the name of your parameter file. Both the psf file and the parameter must be in X-Plor format.

The test directory contains two sets of files which can be used as inputs for mindy. "alanin" is a 66 atom polypeptide, and "brH" is a crystal structure of bacteriorhodopsin containing 3762 atoms. Run alanin by typing

mindy 1000 alanin.pdb alanin.psf alanin.params

at the command line.