Free golden hawk software for linux

goldenmean is a GIMP plugin. Will create a new image. You enter the shortest side, select portrait or landscape orientation and it will automagically calculate the longest side according to the Golden Mean. The plug-in is tested with 1.1.3.

KoalaMud Game Engine project is a multithreaded MUD server.
KoalaMud is a MUD source base designed around multithreading and stability. On top of this platform, Shadow of the Wheel is evolving to demonstrate its capabilities.
Enhancements:
- Tons of new stuff done here.
- We now have basic rooms support completed, though there are still some additional pieces to be flushed out.
- We also have the first part of the skills system outlined and language support is more flushed out now.
- The network code has been completely rewriten to extract Qt from that loop.
- All input is now processed in the thread pool via ZThread tasks.
- Overall the system seems to be even more responsive now and I have not had nearly as many problems with stability since this code conversion.
- Split commands into multiple command trees that are searched as needed.
- Currently we have standard commands and immortal commands.
- All of the OLC editors have been moved under the olc command tree for simplicity and consistancy as well.
- This also paves the way for aliases later on.
- Also added color marker support.

gdReklaManager System is a banner management system.
gdReklaManager System supports simple banners, a tower of banners, and logging of clicks on banners.
If you need your own banner managment you have come to the right place. As you can see on my site it works. It is still under development, but so far a lot of important things are done.
In this stage of development the script still doesnt have administration panel where you can add or edit banners you have included, and also only way to randomizing banners is simple function RAND, but that will change in time.
The archive with this script contains example and you can see for yourself how easy is to add the script to your own website. Also, info about installing and using is also included.
Enhancements:
- A logo image was created for this project.
- Script comments were updated and reduced.
- The help file had some minor features upgraded.
- Some functions were adjusted and optimized.
- Some smaller bugs were fixed.
- Parsing the bot engines now should work.

Pod::WikiDoc is a Perl module to generate Pod from inline wiki style text.
SYNOPSIS
In a source file, Pod format-block style:
=begin wikidoc
= POD FORMAT-BLOCK STYLE
Write documentation with *bold*, ~italic~ or {code}
markup. Create a link to [Pod::WikiDoc].
Substitute for user-defined %%KEYWORD%%.
Indent for verbatim paragraphs
- bullet
- point
- list
0 sequentially
0 numbered
0 list
= end wikidoc
In a source file, wikidoc comment-block style:
### = WIKIDOC COMMENT-BLOCK STYLE
###
### Optionally, [Pod::WikiDoc] can extract from
### specially-marked comment blocks
Generate Pod from wikidoc, programmatically:
use Pod::WikiDoc;
my $parser = Pod::WikiDoc->new( {
comment_blocks => 1,
keywords => { KEYWORD => "foo" },
} );
$parser->filter(
{ input => "my_module.pm", output => "my_module.pod" }
);
Generate Pod from wikidoc, via command line:
$ wikidoc -c my_module.pm my_module.pod
Pod works well, but writing it can be time-consuming and tedious. For example, commonly used layouts like lists require numerous lines of text to make just a couple of simple points. An alternative approach is to write documentation in a wiki-text shorthand (referred to here as wikidoc) and use Pod::WikiDoc to extract it and convert it into its corresponding Pod as a separate .pod file.
Documentation written in wikidoc may be embedded in Pod format blocks, or, optionally, in specially marked comment blocks. Wikidoc uses simple text-based markup like wiki websites to indicate formatting and links. (See "WIKIDOC MARKUP", below.)
Pod::WikiDoc processes text files (or text strings) by extracting both existing Pod and wikidoc, converting the wikidoc to Pod, and then writing the combined document back to a file or standard output.
Summary of major features of Pod::WikiDoc:
- Extracts and converts wikidoc from Pod format blocks or special wikidoc comment blocks
- Extracts and preserves existing Pod
- Provides bold, italic, code, and link markup
- Substitutes user-defined keywords
- Automatically converts special symbols in wikidoc to their Pod escape equivalents, e.g. E< lt >, E< gt >
- Preserves other Pod escape sequences, e.g. E< euro >
In addition, Pod::WikiDoc provides a command-line utility, wikidoc, to simplify wikidoc translation.
See the Pod::WikiDoc::Cookbook for more detailed usage examples, including how to automate .pod generation when using Module::Build.

XML::RDB is a Perl extension to convert XML files into RDB schemas and populate, and unpopulate them. Works with XML Schemas too.

SYNOPSIS

use XML::RDB;

# Give our DBs DSN & username/password
my $rdb = new XML::RDB(config_file => db_config);

# Generate RDB Schema
$rdb->make_tables("my_xml_file.xml", "db_schema_output_file");

#
# Now import the generated db_schema_output_file into your DB
# (see t/1.t for an automated way to do this)
#

# Now populate our RDB
my($root_table_name, $primary_key) =
$rdb->populate_tables("my_xml_file.xml");

#
# Your XML file is now in your RDB!!!! Play as desired & when ready:
#
$rdb->unpopulate_tables($root_table_name, $primary_key,
new_xml_file.xml);


#
# Thats all fine & dandy but what if youve got an XML Schema???
#
# the first 2 calls are the same:
$rdb->make_tables("my_xsd_file.xsd", "db_schema_output_file");

#
# dont forget to put db_schema_output_file into your DB!
# then:
my($root_table_name, $primary_key) =
$rdb->populate_tables("my_xsd_file.xsd");

# note we only need the primary key for this next call
$rdb->unpopulate_schema($primary_key, fully_formed.xml);

#
# Now youve got fully_formed.xml - pass THAT to make_tables
# & yer golden:
#

$rdb->make_tables("fully_formed.xml", "REAL_RDB_schema");

#
# Now insert REAL_RDB_schema into yer DB & now any XML documents
# conforming to your original XML Schema (my_xsd_file.xsd) can be
# imported into your schema:
my ($rt, $pk) =
$rdb->populate_tables("xml_doc_conforming_to_my_xsd_file.xml");

# See the README file for a LOT more information...

ABSTRACT

XML::RDB - Perl extension to convert XML files into RDB schemas and populate, and unpopulate them. Works with XML Schemas too. Analyzes relationships within either an XML file or an XML Schema to create RDB tables to hold that document (or any XML document that conforms to the XML Schema).

A MySQL Storage Engine for AWS S3 project is a plugin storage engine that allows MySQL to access Amazon Web Services Simple Storage Service (AWS S3) buckets and items.
You need a MySQL source tree, and you need to have it built.
Figure out where the source tree is.
In my case its /home/mark/mysql/mysql-5.1-arch
Figure out where the target install tree is.
In my case its /home/mark/mysql/builds/example
Figure out where the MySQL build puts storage engine plugins.
Its probably in lib/mysql under the install tree
Or its /usr/lib/mysql
Or its /usr/local/lib/mysql
For me its /home/mark/mysql/builds/example/lib/mysql
Then run:
./config/bootstrap
./configure --with-mysql=/path/to/mysql-source --libdir=/path/to/mysql-plugins
make && make install
You can optionally copy the "src" directory here into storage/ in the
MySQL server source, rebuild MySQL, and things should compile.
Next, you should probably install the S3 command line tools.
They depend on you having Python.
Get them at http://www.hanzoarchives.com/development-projects/s3-tools/
If you dont have one yet, you need an Amazon AWS account, and then
request that they enable S3. Go to http://amazonaws.com/ to do that.
You will need to get your "AWS Access Key Identifiers".
Assume they are
FV8CY5793BC7CY32YOSN
W9oQxQNJizGgjxNc82giE9/ipefQW19tuO2xpC9G
(I just made those up with a random number generator.)
Put this in your .bashrc file
AWS_ACCESS_KEY_ID=FV8CY5793BC7CY32YOSN
AWS_ACCESS_KEY_SECRET=W9oQxQNJizGgjxNc82giE9/ipefQW19tuO2xpC9G
export AWS_ACCESS_KEY_ID AWS_ACCESS_KEY_SECRET
This isnt used by the storage engine, but it makes using the s3 command
line tools easier.
Use s3mkbucket to create a bucket. Remember that buckets are in a
global namespace, and there are advantages to having them look lik a
domain name. I suggest you snap up "s3.example.com", where
"example.com" is your own domain name.
s3mkbucket s3.example.com
s3put -k solfege/Do -s "a deer, a female deer" s3.example.com
s3put -k solfege/Re -s "a drop of golden sun" s3.example.com
s3put -k solfege/Mi -s "a name I call myself" s3.example.com
s3put -k solfege/Fa -s "a long long way to run" s3.example.com
s3put -k solfege/So -s "a needle pulling thread" s3.example.com
s3put -k solfege/La -s "a note to follow So" s3.example.com
s3put -k solfege/Ti -s "a drink with jam and bread" s3.example.com
Then at the mysql> prompt
create table s3notes (s3id varchar(255) not null primary key, s3val blob)
engine=AWSS3
connection=awss3 s3.example.com FV8CY5793BC7CY32YOSN W9oQxQNJizGgjxNc82giE9/ipefQW19tuO2xpC9G;
select * from s3notes where s3id=solfege/Re;
insert into s3notes (s3id, s3val) values (color/Red, ff 00 00);
select * from s3notes where s3id=color/Red;
delete from s3notes where s3id=color/Red;
You can name the table anything you want, but the fields must be named s3id and s3val, and s3id must be the primary key.
Enhancements:
- More flexible schema, CREATE SERVER, and SELECT without WHERE are supported.

File::pushd is a Perl module to change directory temporarily for a limited scope.

SYNOPSIS

use File::pushd;

chdir $ENV{HOME};

# change directory again for a limited scope
{
my $dir = pushd( /tmp );
# working directory changed to /tmp
}
# working directory has reverted to $ENV{HOME}

# tempd() is equivalent to pushd( File::Temp::tempdir )
{
my $dir = tempd();
}

# object stringifies naturally as an absolute path
{
my $dir = pushd( /tmp );
my $filename = File::Spec->catfile( $dir, "somefile.txt" );
# gives /tmp/somefile.txt
}

File::pushd does a temporary chdir that is easily and automatically reverted, similar to pushd in some Unix command shells. It works by creating an object that caches the original working directory. When the object is destroyed, the destructor calls chdir to revert to the original working directory. By storing the object in a lexical variable with a limited scope, this happens automatically at the end of the scope.

This is very handy when working with temporary directories for tasks like testing; a function is provided to streamline getting a temporary directory from File::Temp.
For convenience, the object stringifies as the canonical form of the absolute pathname of the directory entered.

Humai Trader is a free, open source stock technical analysis tool built on pure java. Humai Trader will also be a platform for custom indicators and charts. The main interest will be W.D. Ganns approach.
Main features:
- Indicators:
- MACD
- OBV
- ROC
- KD
- BIAS
- DMI
- RSI
- MTM
- WMS
- GANN IMPORTANT DATES
- Drawing lines:
- LINE
- PARALLEL LINE
- GANN ANGLE
- FIBONACCI LINE
- PERCENT
- GOLDEN RATE
- PERIODS
- GANN IMPORTANT PERIODS
- Retrieves quote data in parallel from Yahoo! Finance, or CSV files.
- Historical Chart
- Intra-Day Chart
- Real-Time Chart
- Ticker Board
- Candle/Bar/Line
- Changes indicators parameters
-
- Natural date / Trading date view
- Move left, right by [left], [right] key
- Zoom in, Zoom out by [up], [down] key
- Fast moving cursor / day by day moving cursor
- Save/restore parameters and drawing
- Carefully design for writing your own indicator easy, but in java (maybe will support scripts some day)
- Supports multi platforms, includes windows, linux, macos, solaris, etc. (Java JRE 1.5 required)
- More to be come ...