Free skin conditions software for linux

CSS::SAC::ConditionFactory Perl module contains the default ConditionFactory.

SYNOPSIS

my $cf = CSS::SAC::ConditionFactory->new;
my $cond1 = $cf->create_foo_condition;
my $cond2 = $cf->create_bar_condition;

This is the default ConditionFactory for CSS::SAC. It creates conditions of all types defined in SAC. You may wish to subclass or replace the default ConditionFactory in order to get your own condition objects.

I plan on adding more flexibility to this factory so that one could tell it the classes to use for various conditions, that would avoid enforcing subclassing/recoding for people that only want to replace a family of factory methods.

I know that some of the method names are quite lengthy, but given the great number of possible conditions it helps to have descriptive names.

METHODS

These define the interface that must be adhered to by ConditionFactories. The Java names (given in parens) work too, though the Perl ones are recommended.

CSS::SAC::ConditionFactory->new or $cf->new
Creates a new condition factory object.
$cf->create_and_condition($first,$second) (createAndCondition)
creates a combinator condition of type and
$cf->create_attribute_condition($lname,$ns,$specified,$value) (createAttributeCondition)
creates an attr condition
$cf->create_begin_hyphen_attribute_condition($lname,$ns,$specified,$value) (createBeginHyphenAttributeCondition)
creates a attr condition of type bh
$cf->create_class_condition($ns,$value) (createClassCondition)
creates a attr condition of type class
$cf->create_content_condition($data) (createContentCondition)
creates a content condition
$cf->create_id_condition($value) (createIdCondition)
creates a attr condition of type id
$cf->create_lang_condition($lang) (createLangCondition)
creates a lang condition
$cf->create_negative_condition($cond) (createNegativeCondition)
creates a negative condition
$cf->create_one_of_attribute_condition($lname,$ns,$specified,$value) (createOneOfAttributeCondition)
creates a attr condition of type id
$cf->create_only_child_condition() (createOnlyChildCondition)
creates a only-child condition
$cf->create_only_type_condition() (createOnlyTypeCondition)
creates a only-type condition
$cf->create_or_condition($first,$second) (createOrCondition)
creates a combinator condition of type or
$cf->create_positional_condition($position,$type_node,$same_type) (createPositionalCondition)
creates a positional condition
$cf->create_pseudo_class_condition($ns,$value) (createPseudoClassCondition)
creates a attr condition of type pseudo class

EZ Red Skin Fix is a script-fu based on a technique by lylejk of dpreview.com that can be used to improve skin that has a reddish tint.

SAM is a program to monitor (in real-time) the number of alerts generated by Snort. Having recently set up Snort and ACID I felt like there was something missing.

Snort was great for identifying suspicous traffic and ACID was great for digging in to the details but I needed something that was a little higher overview and able to sounds alarms if certain conditions were met.

For instance if I was attacked 100 times in a 5 minutes period. SAM does not replace Snort or ACID but rather it compliments them.

syncekonnector is a konnector-plugin for SynCE-KDE, which provides the functionality to synchronize Appointments, Contacts, and Todos between a Windows-CE device and a KDE-equipped desktop/laptop.

This konnector is based on the kitchensync framework.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Silver Shield PM Control for Linux (formerly known as sispm_ctl) is an application enabling the use of the GEMBIRD SiS-PM device under Linux.

The SiS-PM is an itelligent advanced surge protector with unique features: 4 sockets are manageable from the PC via USB port (GEMBIRD LTD).

Silver Shield PM Control for Linux software comes with ABSOLUTELY NO WARRANTY; for details see the LICENCE file. This is free software, and you are welcome to redistribute it under certain conditions; see the LICENCE file for details.

Thanks go out to Gembird for the kind support, the libusb project, the USB snoopy team, Andreas Neuper and the other contributors.

This software is also included in the driver package from Gembird and available from the Gentoo/Portage tree (courtesy Wolfram Schlich).

Installation:

You need libusb-0.15 or newer installed on your system (if you have an older version of libusb it MIGHT work, youll have to tweak configure.in though and call scripts/bootstrap. Nevermind if this is just glibberish for you.

sis_pmctl is only available as sourcecode distribution. To install on your system run:

tar xzvf sispm_ctl-2.1.tar.gz
cd sispm_ctl-2.1
./configure
make
make install

Note: The compiled application is named sispmctl since 2.0 without the underscore!

This installs the applicationsis pmctl in /usr/local/bin. If you want to install the application to a different directory,

call ./configure --prefix=/your/preferred/dir.

The web-interface skins are installed under $prefix/httpd/sispm_ctl/skin?; the default skin is pre-selected with the doc symbolic link in the $prefix/httpd/sispm_ctl directory.

Options:

-h Print usage information
-s Scan all universal serial buses for devices with the ID 04B4:FD11.

-l stay listening on network port for http protocol.

-p IP network port (default: 2638) for listener. There is no authentication implemented yet.

-u give the directory path where pages lay, that are served (default: /usr/local/httpd/pmctl ). The Web path component is completely ignored for security reasons.

-b switch the buzzer on and off (I was not able to test it, mine does not hat it)

-o switch the named outlet to "ON"

-f switch the named outlet to "OFF"

-g show the status of the named outlet

-d Choose not the first but the named one in the sequence of detected devices (see scan option)

-n do not print "ON" and "OFF", but "1" and "0" instead

-q do neither print explanations nor disclaimers except it is requested

-v print version & copyright

Shed Skin is an experimental Python-to-C++ compiler. Shed Skin accepts pure Python programs, and generates optimized C++ code. This means that, in combination with a C++ compiler, it allows for translation of Python programs into highly efficient machine language. For a set of 16 non-trivial test programs, measurements show a typical speedup of 2-40 over Psyco, about 12 on average, and 2-220 over CPython, about 45 on average (see Section 5 of my Masters Thesis on the right). Shed Skin also outputs annotated source code.
The high performance and elegant approach of Shed Skin (it is only 6000 lines!) come at a cost. First, it currently only accepts programs that are statically typed. This simply means that variables can only ever have a single type. So e.g. a = 1; a = 1 is not allowed. Of course, a single type can be abstract or generic (as in C++), so that e.g. a = A(); a = B(), where A and B have a common base class, is allowed.
Second, Python programs cannot currently freely use the Python standard library. However, some common imports are supported (see *_.py), and many others can be easily added. The problem is a practical one, since in theory it is possible to create bindings for most library modules. A simple work-around can be to only compile critical parts of a Python program, and communicate with it through e.g. files and standard in- and output. This way, the main program can use the full Python dynamics and standard library, and the whole program is written in pure Python.
Shed Skin is still alpha software, and there are some other minor, mostly temporary, limitations. Please read the Limitations section carefully, before trying to compile a program. The only thing I ask in return for making the software available under the GPL, is that you send me an email when you encounter a problem, that is not listed among these limitations. This is the fastest way to getting your program supported, since I typically do not fix problems I do not know about. Please also let me know if you would like me to implement certain library calls.
Enhancements:
- Support for __iadd__, __imul__, and such was added (but not for __ipow__ and __imod__).
- The set implementation was optimized.
- A string formatting problem was fixed (%% did not always work).
- Some bugs were fixed in generating extension modules.
- A particular inheritance problem was fixed.

spkg project is a reimplementation of Slackware package manager (pkgtools). Dependencies are not handled as they are supposed to be resolved at the higher level.
Main features:
- Extreme symplicity. Just like pkgtools.
- Fast installation (approx. 10% faster than tar xzf)
- Fast unistallation (faster than rm -rf)
- Robust implementation. (nearly all error conditions are checked)
- Rollback functionality. (no file left behind policy ;-))
- Full compatibility with legacy Slackware package database.
- Everything is libified. (see docs) You can implement new commands easily.
- Easy access to the package database thanks to libification.

Class::Contract - Design-by-Contract OO in Perl.

SYNOPSIS

package ClassName
use Class::Contract;

contract {
inherits BaseClass;

invar { ... };

attr data1;
attr data2 => HASH;

class attr shared => SCALAR;

ctor new;

method methodname;
pre { ... };
failmsg Error message;

post { ... };
failmsg Error message;

impl { ... };

method nextmethod;
impl { ... };

class method sharedmeth;
impl { ... };

# etc.
};

Background

Design-by-contract is a software engineering technique in which each module of a software system specifies explicitly what input (or data or arguments) it requires, and what output (or information or results) it guarantees to produce in response.

These specifications form the "clauses" of a contract between a module and the client software that uses it. If the client software abides by the input requirements, the module guarantees to produce the correct output. Hence by verifying these clauses at each interaction with a module, the overall behaviour of the system can be confidently predicted.
Design-by-contract reinforces the benefits of modular design techniques by inserting explicit compile-time or run-time checks on a contract. These checks are most often found in object-oriented languages and are typically implemented as pre-conditions and post-conditions on methods, and invariants on classes.

Note that these features differ from simple verification statements such as the C assert statement. Conditions and invariants are properties of a class, and are inherited by derived classes.

An additional capacity that is often provided in design-by-contract systems is the ability to selectively disable checking in production code. This allows the contractual testing to be carried out during implementation, without impinging on the performance of the final system.

Adding design-by-contract to Perl

The Class::Contract module provides a framework for specifying methods and attributes for a class (much like the existing class definition modules Class::Struct, Class::MethodMaker, and Class::Generate). Class::Contract allows both per-object and per-class methods and attributes to be defined. Attributes may be scalar-, array-, hash-, or object-based.

Class::Contract differs from other class-specification modules (except Class::Generate) in that it also provides the ability to specify invariant conditions on classes, and pre- and post-conditions on methods and attributes. All of these clauses are fully inheritable, and may be selectively disabled. It differs from all other modules in that it has a cleaner, simpler specification syntax, and -- more importantly -- it enforces encapsulation of object attributes, thereby ensuring that the class contract cannot be subverted.

Defining classes

Class::Contract provides an explicit syntax for defining the attributes, methods, and constructors of a class. The class itself is defined using the contract subroutine. contract takes a single argument -- a subroutine reference or a block. That block is executed once and the results used to construct and install the various components of the class in the current package:

package Queue;
contract {
# specification of class Queue attributes and methods here
};