Free insert into select software for linux

Inline::Select contains dynamic selection of ILSM for a package.

SYNOPSIS

use Inline::Select::Register (
PACKAGE => Calc,
Inline => [ Perl => sub {require t/Calc.pm} ]
) ;
use Inline::Select::Register (
PACKAGE => Calc,
Inline => [ CPP => t/Calc.cpp ]
) ;
use Inline::Select::Register (
PACKAGE => Calc,
Inline => [ Java => t/Calc.java ]
) ;
use Inline::Select::Register (
PACKAGE => Calc,
Inline => [ Python => t/Calc.py ]
) ;

use Inline::Select (
PACKAGE => Calc,
Inline => $ARGV[0] # one of Perl, CPP, Java, Python
) ;

my $c = new Calc() ;
ok($c->add(2, 3), 5) ;

USAGE

Usage of Inline::Select is pretty simple. For each programming language, you must speficy a use Inline::Select::Register (or Inline::Select->register() at runtime) statement to register the use of Inline for that language. All the Inline parameters are saved and that Inline block will only be evaluated if that language is selected later on.

When you are done registering Inline blocks, you then spefify a use Inline::Select (or Inline::Select->bind() at runtime) to actually load (in the caller package) the Inline block for the selected language.

mrtg-select allows the flexible display of MRTG graphs, chosen by keyword and time span.

I use MRTG to graph all kinds of stuff, and looking at those graphs on the same page helps me detect correlations. ("Say, Professor -- that spike in CPU temperature came right when the Rapture Index hit a three-year high!")

mrtg-select lets me pick a subset of graphs to be displayed on the same page, based on keyword and time span.

And the best part is that it figures out the keywords automagically just by being pointed at the directory where the graphs live -- theres no config file to update. Licensed under the GPL.

PSPL Multi Select Box is an enhanced implementation of the HTML form input element for selecting multiple items from a list.

Users can select multiple choices without having to press the ALT button like a normal "select multiple" box. It is easy to customize, and you can easily modify the visual style of PSPL Multi Select Box to match your Web site design or theme.

The project is also compliant to W3C standards, and has been tested with most recent browsers. Unlike normal "select multiple" boxes, PSPL Multi Select Box follows the layer design in IE.

Dino is a MIDI sequencer for GNU/Linux. Dino is a pattern-based sequencer, which means that you write small patterns of MIDI events that you can repeat and arrange to create a whole song.

Each track has its own patterns, so you can for example play the same drum pattern over and over again while you play different lead synth patterns and basslines.

The arrangement editor

The GUI is divided into three tabs. The first tab, "Arrangement" is where you
add new tracks, arrange patterns, and edit the tempo map. When you first
start Dino there will be no tracks and all you will see is the "BPM" track.
Here you can add new tempo changes with the left button, remove them with
the right button (except the first one - if you removed it the BPM for the
whole song would be undefined, so Dino will not let you remove it) and change
their BPM by middle-clicking and dragging up and down. This mousing pattern
is used in most places in Dino - left adds, middle modifies, right removes.

If you click the + button in the arrangement tab you will add a track. When
you add a track you can choose a name for it, which MIDI port it should connect
to, and the MIDI channel it should send events to. You can edit all these
properties later too by clicking the Properties button (the one with the
tool). The selected track (the one that has a dark blue background for its
name) can be removed by clicking the trashcan button.

Each track is shown as a strip of blocks, where each block represents a beat.
When you have created patterns for your track (see the text about the "Patterns"
tab below) you can use the left mouse button to click on a track and bring up
a popup menu listing all patterns for that track. The one you select will be
added to the track at the beat you clicked. You can modify its length with
the middle mouse button and delete it with the right (this does not affect
the actual pattern at all, just how this instance of it is played).

The pattern editor

In the pattern editor you can add, edit, and remove patterns for the different
tracks. Look at the tooltips for the buttons in the upper row and it should
be fairly obvious how to add and delete patterns. When you have added a pattern
you can also add and delete controllers in it. Controllers are e.g. pitchbend
and MIDI CC controllers. The active controller can be edited in the box at the
bottom of this tab.

The main box here is the note editor, where you edit the notes in the active
pattern. You add new notes with Ctrl-left button, change their length with the
middle button, change their velocity with Ctrl-middle button and delete them
with Ctrl-right button. You can also use the left mouse button to select,
unselect, and drag notes around - clicking a note will select it, shift-clicking
will unselect or select it depending on whether it was selected or not, clicking
and dragging notes will move the selected notes around on the grid.

There are also basic clipboard commands, you can cut, copy, paste and delete
the current selection. When you paste you will have to click where you want
the clipboard content to appear. You can also middle-click outside all notes to
insert a copy of the current selection there without affecting the clipboard
content.

The info editor

The third tab simply has entry fields for the songs title, author, and info. It should be obvious how to use them.

An annoying thing on flickr is that you never know where people that visit your photo have found it.

Flickr: Add referrer into comments a small script that will add a small text at the end of your comment saying where you come from. If everyone starts using this script, then it will be easy to see where the people have found your photos and how they got to comment on it.

Installation:

Get Firefox
Install GreaseMonkey
restart Firefox

Click on the following icon and select Install greasemonkey - 12 kb

Usage:

the comments will be added automatically to the end of your message.

SQL::Interpolate is a Perl module to interpolate Perl variables into SQL statements.

SYNOPSIS

use SQL::Interpolate qw(:all);

# Some sample data to interpolate:
my $s = blue; my @v = (5, 6);

# Variable references are transformed into bind parameters.
# The most basic usage involves scalarrefs (as well as arrayrefs
# preceeded by "IN").
my ($sql, @bind) = sql_interp
SELECT * FROM table WHERE x = , $s, AND y IN, @v;
# RESULT:
# $sql = SELECT * FROM mytable WHERE x = ? AND y IN (?, ?)
# @bind = ($s, @v);

# In certain contexts, an arrayref or hashref acts as a single tuple:
my ($sql, @bind) = sql_interp
INSERT INTO table, {x => $s, y => 1};
# RESULT:
# $sql = INSERT INTO mytable (x, y) VALUES(?, ?);
# @bind = ($s, 1);
my ($sql, @bind) = sql_interp
UPDATE table SET, {x => $s, y => 1}, WHERE y , 2;
# RESULT:
# $sql = UPDATE mytable SET x = ?, y = ? WHERE y ?;
# @bind = ($s, 1, 2);

# In general, a hashref provides a shortcut for specifying
# a logical-AND construction:
my ($sql, @bind) = sql_interp
SELECT * FROM table WHERE, {x => $s, y => @v};
# RESULT:
# $sql = SELECT * FROM mytable WHERE (x = ? AND y IN (?, ?));
# @bind = ($s, @v);

# In general, an arrayref acts as a result set or reference to
# a temporary table:
my ($sql, @bind) = sql_interp
[[1, 2], [4, 5]], UNION, [{x => 2, y => 3}, {x => 5, y => 6};
# RESULT:
# $sql = (SELECT ?, ? UNION ALL SELECT ?, ?) UNION
# (SELECT ? AS x, ? AS y UNION ALL SELECT ?, ?);
# @bind = (1,2,4,5, 2,3,5,6);
my ($sql, @bind) = sql_interp
SELECT * FROM, [[1, 2], [4, 5]]
# RESULT:
# $sql = SELECT * FROM (SELECT ?, ? UNION ALL SELECT ?, ?) AS tbl0;
# @bind = (1,2,4,5);

# Each result above is suitable for passing to DBI:
my $res = $dbh->selectall_arrayref($sql, undef, @bind);

# Besides these simple techniques shown, SQL-Interpolate includes
# various optional modules to further integrate SQL::Interpolate with
# DBI and streamline the syntax with source filtering and macros (see
# the L section):

use DBIx::Interpolate FILTER => 1;
...
my $rows = $dbx->selectall_arrayref(sql[
SELECT thid, date, title, subject
FROM threads
WHERE date > $x AND subject IN @subjects
]);

Fast Logging Project for Snort is designed to gather alerts with payload from distributed snort sensors on a central server and to store them in a database (MySQL and PostgreSQL are supported).
On the sensor, the output is written to a process called sockserv. This process is threaded; one thread receives and buffers the alert packets, and the other thread forwards them to a central server.
The output is decoupled from snort, which can proceed in sniffing instead of waiting for the output plugins. At the central server, a process called servsock gathers all alerts from the remote sensors and feeds them to the database.
A short description of alerts with high priority together with the database ID can be sent via email to a list of recipients.
Main features:
- Decoupling of the output from snort. Snort can work on new packets instead of processing the output.
- Buffering of alerts on the sensor. This is useful if you have a shortage on your network to the central server or the servsock process on the central server is not running (maybe it will be restarted due to a change to a newer version...)
- Buffering of alerts on the central server. It is not uncommon that the database (especially MySQL) is hanging during a high input rate or the rate is faster than the database is able to store.
- Fast writing to the database via an unix domain socket.
- E-Mail alerting on high priority alerts.
- Drop feature for the worst case. At least the basic alert informations are still available either via E-Mail or on stdout/syslog.
- Since version 1.0.6 the alerts which should be dropped on the central server if servsock exits are written to a swap file. So this data is still availabe.
- If alerts have to been dropped because the high water mark was reached then these data are not written to the swap file.
Enhancements:
- Several checks were added, the alert data from Snort got a tag, and a restart of Snort is now checked.
- getpacket now has base 64 support.
- The statistics are now generated via the control thread so some signals are no longer necessary.
- The exit handler was rewritten and a cache for signatures was added.
- This cache can accelerate the insert rate by up to a factor of two and is implemented as a red black tree.
- During runtime, the only SELECT statement is for the signature ID, and all other operations are INSERT statements.
- The idea is to cache all signatures that caused an alert.

STX B+ Tree project is a set of C++ template classes implementing a B+ tree key/data container in main memory. The classes are designed as drop-in replacements of the STL containers set, map, multiset and multimap and follow their interfaces very closely. By packing multiple value pairs into each node of the tree the B+ tree reduces heap fragmentation and utilizes cache-line effects better than the standard red-black binary tree.
The tree algorithms are based on the implementation in Cormen, Leiserson and Rivests Introduction into Algorithms, Jan Janninks paper and other algorithm resources. The classes contain extensive assertion and verification mechanisms to ensure the implementations correctness by testing the tree invariants.
The main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments btree.h.
Special interest was put into performing a speed comparison test between the standard red-black tree and the new B+ tree implementation. The speed test results are interesting and show the B+ tree to be significantly faster.
Enhancements:
- This release introduces the demonstration program wxBTreeDemo.
- This program draws illustrations of the B+ trees constructed by the STX B+ Tree template classes.
- It allows the user to select different types of B+ tree instantiations: integer or string keys and different slot numbers.
- The user may insert and erase key/data pairs from the tree and run different search operations.
- The demo program uses the cross-platform wxWidgets toolkit and can be compiled on Linux, Windows, and Mac OS X.