foobar

Foobar plugin will set the status to the current playing song. on foobar.

Tired of using expensive, bloated software to get through your work day? Try FooBar, our award-winning collection of fifteen FAST, easy-to-use, tools that help you stay organized and increase your productivity! FooBars tools include Reminders, To-Do List, Sticky Notes, Time Tracker, Contact Manager, Password Keeper, Favorite Folders, Documents and Programs and more, all nicely integrated into a highly customizable toolbar. Windows 95, 98, ME, NT and 2000. An unregistered copy of FooBar doesnt expire, display nag screens or contain disabled features. However, an unregistered copy limits the number of items you can store in its lists.

Foobar Controls is a Firefox extension that allows you to easily control the Foobar2000 Mp3 player from the Firefox window.

The main Foobar buttons (Stop, Pause, Play, Previous, Next, Random) are added to the Toolbar Customisation Palette for you to drag wherever you like.

Foobar description
The full version of a very recommendable media player Foobar2000 Media Player is a very very recommendable player. It is developed by Peter Pawlowski who is or used to work on Winamp3.

FB2000 uses a plain and simple UI - no skins, no fuss. Filesize is 200 kb, while in playback mode the player approximately consumes 1.9 Mbyte of your RAM which is so much less compared to Winamp or MS Media Player.

Foobar2000 is an advanced audio player for the Windows platform.8

Here are some key features of "Foobar":

· Open component architecture allowing third-party developers to extend functionality of the player
· Audio formats supported "out-of-the-box": WAV, AIFF, VOC, AU, SND, Ogg Vorbis, MPC, MP2, MP3, MPEG-4 AAC
· Audio formats supported through official addons: FLAC, OggFLAC, Monkeys Audio, WavPack, Speex, CDDA, TFMX, SPC, various MOD types; extraction on-the-fly from RAR, 7-ZIP & ZIP archives
· Full Unicode support on Windows NT
· ReplayGain support
· Low memory footprint, efficient handling of really large playlists
· Advanced file info processing capabilities (generic file info box and masstagger)
· Highly customizable playlist display
· Customizable keyboard shortcuts
· Most of standard components are opensourced under BSD license (source included with the SDK)

Requirements:

· CPU: 200 MHz, AMD K5 or Pentium or equivalent (500MHz Athlon or Pentium III recommended)
· RAM: 32 MB
· Display: 800x600 screen resolution

Rsync::Config::Renderer is a Perl module for rsync config rendering.

SYNOPSIS

use Rsync::Config::Renderer;
my $renderer = Rsync::Config::Renderer->new(
indent => 1, indent_char => "t" );
print $renderer->indent_string, q{foobar};
# prints: " foobar";

$renderer->indent(4)->indent_char(q{.});
print $renderer->indent_string, q{foobar};
# prints: "....foobar";

print $renderer->render( foobar, 22, baz );
# prints:
# ....foobar
# ....22
# ....baz

Module::Reload::Selective can reload Perl modules during development.

SYNOPSIS

Instead of:

use Foobar::MyModule;

Do this:

use Module::Reload::Selective;
&Module::Reload::Selective->reload(qw(Foobar::MyModule));
Or, if you need the "import" semantics of "use", do this:

use Foobar::MyModule (@ImportArgs);

Do this:

use Module::Reload::Selective;
Module::Reload::Selective->reload(qw(Foobar::MyModule));

import Foobar::MyModule (@ImportArgs);

... then configure your server or other runtime environment settings to trigger Module::Reload::Selective to only kick in when you need.

For example: you could have it kick in only when the web server is running on a particular port number or particular (development) host.

Config::Sofu is a simple Sofu configuration file parser.

SYNOPSIS

use vars qw/%CONFIG/;
use Config::Sofu "config.sofu";
if ($CONFIG{FOOBAR}) {
...
}
if ($CONFIG{Bar}->[7]->{Foo} eq "Foobar") {
...
}
Save the new configuration:
$CONFIG{FOOBAR}="Bar times Foo";
Config::Sofu::save;
or
Config::Sofu::save(%CompletlyNewConfig)

SYNTAX

This class exports the hash %CONFIG by default which contains all the information of the file which is given to the use statement.

Tie::CharArray module can access Perl scalars as arrays of characters.

SYNOPSIS

use Tie::CharArray;
my $foobar = a string;

tie my @foo, Tie::CharArray, $foobar;
$foo[0] = A; # $foobar = A string
push @foo, !; # $foobar = A string!
print "@foon"; # prints: A s t r i n g !

tie my @bar, Tie::CharArray::Ord, $foobar;
$bar[0]--; # $foobar = @ string!
pop @bar; # $foobar = @ string
print "@barn"; # prints: 64 32 115 116 114 105 110 103
Alternative interface functions
use Tie::CharArray qw( chars codes );
my $foobar = another string;

my $chars = chars $foobar; # arrayref in scalar context
push @$chars, ?; # $foobar = another string?

$_ += 2 for codes $foobar; # tied array in list context
# $foobar = cpqvjgt"uvtkpiA

my @array = chars $foobar; # WARNING: @array isnt tied!

In low-level programming languages such as C, and to some extent Java, strings are not primitive data types but arrays of characters, which in turn are treated as integers. This closely matches the internal representation of strings in the memory.

Perl, on the other hand, abstracts such internal details away behind the concept of scalars, which can be treated as either strings or numbers, and appear as primitive types to the programmer. This often better matches the way people think about the data, which facilitates programming by making common high-level manipulation tasks trivial.

Sometimes, though, the low-level view is better suited for the task at hand. Perl does offer functions such as ord()/chr(), pack()/unpack() and substr() that can be used to solve such tasks with reasonable efficiency. For someone used to the direct access to the internal representation offered by other languages, however, these functions may feel awkward. While this is often only a symptom of thinking in un-Perlish terms, sometimes being able to manipulate strings as character arrays really does simplify the code, making the intent more obvious by eliminating syntactic clutter.

This module provides a way to manipulate Perl strings through tied arrays. The operations are implemented in terms of the aforementioned string manipulation functions, but the programmer normally need not be aware of this. As Perl has no primitive character type, two alternative representations are provided:

foo_tunes is an UI Plugin for the audio player foobar2000. It greatly enhances the default foobar UI (check the screenshots)

Requirements
- Foobar2000 0.8.1 final or later
- Windows 2K/XP/2003
- For Windows2K you must install the GDI redistributable package from: this page

How to install
1. Extract contents of the zip file in the components folder of Foobar
2. Restart Foobar
3. Navigate menus to Foobar2000->Preferences->Display and choose "fooTunes" in the "User Interface Module" combobox.
4. Restart Foobar

More information
foobar version: 0.8.1
component version: 0.2

---- requires foobar2000 0.8.1 final

* minor fixes
* recompiled with SDK 0.8.1
* smaller size due to using GDI+ to handle images instead of extra library

------------------------------------------

foobar version: 0.8
component version: 0.1.2

---- requires foobar2000 0.8 final

* minor fixes
* added star system for rating (use e.g. quicktag plugin to rate songs)

------------------------------------------

foobar version: 0.8
component version: 0.1.1

---- requires foobar2000 0.8

* minor fixes
* optimized playlist drawing
* allowed format strings up to 2kB incl. newlines (not so comfortable, but it works)
* dimmed currently played song in playlist
* position and volume sliders moved to pane upon the playlist (more ergonomic)
* bass pulsing cool logo
* new buttons look (dark)
* double click in explorer view instanlty plays folder content

----------------------------------------

foobar version: 0.7.7b
component version: 0.1.0

* MILESTONE 0.1.0
* minor fixes
* better algorithm for sizing cover sheet images
* better looking (professional:) toolbar icons (old-style ones still in da package)

-------------------------------

foobar version: 0.7.7b
component version: 0.0.7 alpha

* minor fixes
* added background color of column
* stripes mode can be now turned off

-------------------------------

foobar version: 0.7.7b
component version: 0.0.6 alpha

* minor fixes
* flicking has been reduced on win2k
* synchro button on explorer toolbar/menu
* added configuration
* playlist font
* header on/off
* hotkeys on/off
* editable columns with any foobar string format

SQLitepp is a C/C++/Python wrapper to sqlite library for database management. It implements an object oriented way to manipulate the database in every supported language.

SQLitepp supports selfupdatable queries and a straight SQL code query system without using strange things for querying the database, letting you manipulate it directly in SQL but also exposing simple object oriented methods to manipulate the result of the queries and updating them.

Python EXAMPLE:

db = SQLDatabase("database.db")
q = db.query("Tablename", "SELECT Name,Id FROM %t")
if len(q):
tuple1 = q[0]
tuple1["Name"] = "Foobar"
tuple1.commit()
del db

C++ EXAMPLE:

SQLDatabase db("database.db");
SQLQuery *q = db.query("Tablename", "SELECT Name,Id FROM %t");
if(q->numberOfTuples()) {
SQLRow *tuple1 = q->getRow(0);
tuple1->set("Name", "Foobar");
tuple1->commit();
}
delete q;

C EXAMPLE:

void *db = new_SQLDatabase("database.db");
void *q = SQLDatabase_query(db, "Tablename", "SELECT Name,Id FROM %t");
if(SQLQuery_numberOfTuples(q)) {
void *tuple1 = SQLQuery_getRow(q, 0);
SQLRow_set(tuple1, "Name", "Foobar");
SQLRow_commit(tuple1);
}
delete_SQLQuery(q);
delete_SQLDatabase(db);

Convert::Wiki::Node::Para is a Perl module that represents a text paragraph node.

SYNOPSIS

use Convert::Wiki::Node::Para;

my $para = Convert::Wiki::Node->new( txt => Foo is a foobar., type => para );

print $para->as_wiki();

A Convert::Wiki::Node::Para represents a normal text paragraph.