Free dog ramps software for linux

Sawdog (Simple Active Watch-DOG) is a suite of scripts that informs the system operators of mission critical servers in the case of a failure.

A set of small executables (i.e. expect scripts) are executed, and if one executable fails, it sends an email or an SMS to the sysop. There are 3 states known to sawdog: alive, unknown, and dead. Only certain state transitions trigger a notification.

On a Web interface, the states of all hosts are visible. So far, there are scripts to check for DNS, FTP, HTTP, HTTPS, ICMP, IMAP, MS SQL, MySQL, Notes, NTP, POP3, PostgreSQL, SMB, SMTP, SNMP, SSH, telnet, TWS, VNM, and Webmin.

Image Repository provides a centralized image repository capable of holding thousands of images with keyword/tag-based browsing.
Image Repository is a centralized image repository capable of holding thousands of images with keyword/tag-based browsing and filtering.
Main features:
- Its goal is to provide you with an easy way to have a centralized image library with thousands of images categorized by keywords, dates, etc.
- It has special handling that lets you browse the keyword space like it was a collection of nested folders. Example: Browse to keyword "Carnivores", you will get the available keywords "Cats", "Dogs", and the selection will narrow down, applying all the keywords you have selected on your path through the keyword space.
- It comes complete with a Kupu "library", meaning you can browse the keywords through the Kupu image insertion dialog to make it easy to locate images even in a large collection of images.
- It has a tagging interface that lets you tag images with a thumbnail like view, and apply keywords to multiple images at once.
- It uses whatever image type you have installed (it does need to be added as an addable type and be able to supply thumbnails like the default Plone image type, though).
Enhancements:
- Added action to register the repository in Kupu. [fschulze]
- Using interfaces, views and adapters in various places to make this more flexible. [fschulze]
- Removed unused code. [fschulze]

CeaMuS is a simple, powerful way to build a web site. CeaMuS project is a light weight Content Management System to help you edit web pages and build image galleries.
Who Can Benefit From CeaMuS
- Web Designers who want to make maintaining client sites faster and easier
- Web Site Owners who want to maintain their own web sites
- Bloggers who want a site that doesnt look like every other blog on the net
- Churchs and non-profit organizations who need to update sites frequently, often with whatever labor happens to be available
- Dog, horse and cat breeders, who need to update photos and breeding information regularly
- Families who want to share photos and vacation experiences with family and friends
- Small Businesses selling their products on the web

Games::Irrlicht is a Perl module that use the Irrlicht 3D Engine in Perl.

SYNOPSIS

package MyGame;
use strict;

use base Games::Irrlicht;

use Games::Irrlicht::Constants; get EDT_SOFTWARE etc

# override methods:

The Why

When building a game or screensaver displaying some continously running animation, a couple of basics need to be done to get a smooth animation and to care of copying with varying speeds of the system. Ideally, the animation displayed should be always the same, no matter how fast the system is.

This not only includes different systems (a PS/2 for instance would be slower than a 3 Ghz PC system), but also changes in the speed of the system over time, for instance when a background process uses some CPU time or the complexity of the scene changes.

In many old (especial DOS) games, like the famous Wing Commander series, the animation would be drawn simple as fast as the system could, meaning that if you would try to play such a game on a modern machine it we end before you had the chance to click a button, simple because it wizzes a couple 10,000 frames per second past your screen.

While it is quite simple to restrict the maximum framerate possible, care must be taken to not just "burn" surplus CPU cycles. Instead the application should free the CPU whenever possible and give other applications/thread a chance to run. This is especially important for low-priority applications like screensavers.

Games::Irrlicht makes this possible for you without you needing to worry about how this is done. It will restrict the frame rate to a possible maximum and tries to achive the average framerate as close as possible to this maximum.

Games::Irrlicht also monitors the average framerate and gives you access to this value, so that you can, for instance, adjust the scene complexity based on the current framerate. You can access the current framerate, averaged over the last second (1000 ms) by calling current_fps.

Frame-rate Independend Clock

Now that our application is drawing frames (via the method draw_frame, which you should override in a subclass), we need a method to decouple the animation speed from the framerate.
If we would simple put put an animation step every frame, we would get some sort of Death of the Fast Machine" effect ala Wing Commander. E.g. if the system manages only 10 FPS, the animation would be slower than when we do 60 FPS.

To achive this, SDL::App::FPS features a clock, which runs independed of the current frame rate (and actually, independend of the systems clock, but more on this in the next section).
You can access it via a call to current_time, and it will return the ticks e.g. the number of milliseconds elapsed since the start of the application.

To effectively decouple animation speed from FPS, get at each frame the current time, then move all objects (or animation sequences) according to their speed and display them at the location that matches the time at the start of the frame. See examples/ for an example on how to do this.

Note that it is better to draw all objects according to the time at the start of the frame, and not according to the time when you draw a particular object. Or in other words, treat the time like it is standing still when drawing a complete frame. Thus each frame becomes a snapshot in time, and you dont get nasty sideeffects like one object beeing always "behind" the others just because it gets drawn earlier.

Time Warp

Now that we have a constant animation speed independend from framerate or system speed, lets have some fun.

Since all our animation steps are coupled to the current time, we can play tricks with the current time.

The function time_warp lets you access a time warp factor. The default is 1.0, but you can set it to any value you like. If you set it, for instance to 0.5, the time will pass only half as fast as it used to be. This means instant slow motion! And when you really based all your animation on the current time, as you should, then it will really slow down your entire game to a crawl.

Likewise a time warp of 2 lets the time pass twice as fast. There are virtually no restrictions to the time warp.

For instance, a time warp greater than one lets the player pass boring moments in a game, for instance when you need to wait for certain events in a strategy game, like your factory beeing completed.

Try to press the left (fast forward), right (slow motion) and middle (normal) mousebuttons in the example application and watch the effect.

If you are very bored, press the b key and see that even negative time warps are possible...

Ramping Time Warp

Now, setting the time war to factor of N is nice, but sometimes you want to make dramatic effects, like slowly freezing the time into ultra slow motion or speeding it up again.

For this, ramp_time_warp can be used. You give it a time warp factor you want to reach, and a time (based on real time, not the warped, but you can of course change this). Over the course of the time you specified, the time warp factor will be adapted until it reaches the new value. This means it is possible to slowly speeding up or down.

You can also check whether the time warp is constant or currently ramping by using time_is_ramping. When a ramp is in effect, call ramp_time_warp without arguments to get the current parameters. See below for details.

The example application uses the ramping effect instead instant time warp.

Event handlers

This section describes events as external events that typically happen due to user intervention.
Such events are keypresses, mouse movement, mouse button presses, or just the flipping of the power switch. Of course the last event cannot be handled in a sane way by our framework.

All the events are checked and handled by Games::Irrlicht automatically. The event QUIT (which denotes that the application should shut down) is also carried out automatically. If you want to do some tidying up when this happens, override the method quit_handler.

The event checking and handling is done at the start of each frame. This means no event will happen while you draw the current frame. Well, it will happen, but the action caused by that event will delayed until the next frame starts. This simplifies the frame drawing routine tremendously, since you know that your world will be static until the next frame.

Ruby on Rails SubList Plugin makes it easy to have dynamic lists of related models on a single editing page.

The plugin is designed for models with one or more has_many relationship with other models.

By using AJAX for adding and removing "sub-forms" one can present the user with a single edit page that creates/edits the parent model as well as all of the children.

Usage:

Place the sub_list directory in the vendor/plugins dir of your application.

In the controller which you wish to have a sub list displayed, add the following lines:

include UIEnhancements::SubList
helper :SubList

sub_list SubModel, parent do |new_research_student|
#Place any construction (ie. defaults) required here
end

Replace SubModel with the class name of the sub model you wish to make available.

Replace parent with the parent object.

For instance, if you wish to have a Person controller that has a sub list of Dogs for each person, the sub model would be Dog and the parent would be person. It is expected that @person would exist and that it contains a has_many relationship named dogs.

HELIOS PS3 Linux Server is a customized version of the Yellow Dog Linux for PlayStation3 gaming console.
The PS3 GameOS offers entertainment features such as video games, movies, and photos, and HELIOS simplified Yellow Dog Linux adds a powerful server OS. Together they provide a unique combination of entertainment and server system. Dedicated to making good things even better, HELIOS Software has prepared a stripped down version of Yellow Dog Linux for the purpose of providing a lightweight, low overhead server environment on the PS3, while offering an exciting test-drive platform for its file, print, PDF and image server software.
The HELIOS simplified YDL distribution comes on a CD disk image that installs in less than 6 minutes, and provides a high performance Linux server OS complete with DHCP network settings, support for Java 1.5 and AppleTalk enhanced kernel.
Main features:
- Free download from HELIOS web site
- Easy installation, ready to run in a few minutes
- Excellent Linux on PS3 documentation from HELIOS
- Dedicated server operating system with optimized performance (40% more memory available)
- Java 1.5 runtime is pre-installed
- Easy maintenance shell from CD
- HELIOS services are pre-installed as a test-drive
For Installation instruction and a nice video review, please go at the following link:
AVAILABLE IN A FEW MINUTES!
HELIOS on the PlayStation3: Installation and First Impressions
To download this file, you ave to login to the HELIOS server http://webshare.helios.de with the user tools and password tools, then you need to go the "HELIOS Linux for PS3" folder, select the "HELIOS Linux for PS3 v1.iso" file and click the Download button.

Stripes is a presentation framework for building web applications using the latest Java technologies. The main driver behind Stripes is that web application development in Java is just too much work! It seems like every existing framework requires gobs of configuration.
Struts is pretty feature-light and has some serious architectural issues. Others, like WebWork 2 and Spring-MVC are much better, but still require a lot of configuration, and seem to require you to learn a whole new language just to get started.
Goals:
- Make developing web applications in Java easy
- Provide simple yet powerful solutions to common problems
- Make the Stripes ramp up time for a new developer less than 30 minutes
- Make it really easy to extend Stripes, without making you configure every last thing
Main features:
- Zero external configuration per page/action (ActionBeans are auto-discovered, and configured using annotations)
- Powerful binding engine that will build complex object webs out of the request parameters
- Easy to use (and localized) validation and type conversion system
- Localization system that works even when you use direct JSP->JSP links
- Ability to re-use ActionBeans as view helpers
- Ridiculously easy to use indexed property support
- Built in support for multiple events per form
- Transparent file upload capabilities
- Support for incremental development (e.g. you can build and test your JSP before even thinking about your ActionBean)
- And a lot of built in flexibility that you only have to be aware of when you need to use it
Stripes aims to provide an experience similar to owning Apple hardware, Sony TVs and luxury German cars (without the price premium); things just work, they feel right and every now and again you get that "oh, it does that too? awesome!" feeling.
Enhancements:
- This release includes several minor bugfixes and improvements.

Relations::Query is a Perl Object for building queries with DBI/DBD::mysql.

SYNOPSIS

# Relations::Query Script that creates some queries.

use Relations::Query;

$query = new Relations::Query(-select => {fife => barney},
-from => {green_teeth => moogoo},
-where => "flotsam>jetsam",
-group_by => "denali",
-having => {fortune => cookie},
-order_by => [was,is,will],
-limit => 1);

$get_query = $query->get();

$query->set(-select => {clean => sparkle},
-from => {lean => book},
-where => "fighting is between courage and chaos",
-limit => 123);

$set_query = $query->get();

$get_add_query = $query->get_add(-select => {mean => dog},
-where => "running is null",
-having => {kitties=> on_tv},
-limit => [9678]);

$query = to_string({select => this,
from => that});