Free maple story 0.16 software for linux

svplus is a SchemaView Plus GUI for drawing database schemas.
FORMAT
svplus [file]
SYNOPSIS
svplus
svplus example.svp
SchemaView Plus is a GUI for retrieve, drawing and printing database schema.
Schema can be retrieved using DBIx::SystemCatalog (currently supported basicly all current DBD drivers, some better support for PostgreSQL and quite well support for Oracle).
Program use XML for storing and retrieving data in text files. You can write any filters to modify these XML files for add new functionality based on your projects (e.g. droping off some relationships etc.). You can specify one filename on command line for autoloading it after GUI start up.
Schema can be printed to PostScript file.
Version restrictions:
- Problem with manipulating of dragpoint in smooth coords based connection method, retrieving only updates from database -- now forgot all new informations, I retrieve always all relationships (e.g. for 1 table in large schema - slow), many tables in create relationship dont allow selection, selecting object on canvas dont click_repository(), dnd object from object repository rollback in object repository listbox and filter dont work.

fastdep is a preprocessor which generates dependency information suitable for Makefile inclusion from C or C++ source files. Meant to run on slower hardware, it is several orders of magnitude faster than gcc.
Enhancements:
- Implement boolean operators in #if [Pete Gonzalez]
- Adds support for Windows MinGW GCC and MS VisualC++.NET [Jack T. Goral]
- Adds Jamfile for compilation with Jam [Jack T. Goral]
- Make gcc style predefined symbols defined as in -DPARAMETER=3 [Pierric Descamps]
- Fix unportable configure sh for NetBSD [Julio M. Merino Vidal]
- Set object filename extension through a command line [Arne Varholm]
- Man page [Zenaan Harkness]
- Compilation fixes + makefile for MS VC6 [Alexander Bartolich]

Xmldoom package contains the XML Document Object-Oriented Model.

Xmldoom is what is commonly refered to as an Object Persistence Framework or an Object-Relational Mapping [1]. Basically, it is a framework that allows you to create an automatic mapping between the tables in your relational database and the code objects you use to manipulate it. Any large database bound application will eventually create a code abstraction over the database as opposed to writting SQL manually for every database access. Xmldoom does this automatically and makes it possible to avoid writting any SQL.

This is not a new concept, however, there are a few things that make Xmldoom unique:

Programming language agnostic

This implementation is a Perl module. However, there exists an actively maintained JavaScript and an inactive Python implementation. This means you can setup your object and database definitions once, and be able to access your database via Xmldoom with roughly the same interface from any programming language that has an Xmldoom implementation.

Heavy abstraction

While the standard in the Perl world is to be as light as possible, Xmldoom is a heavy abstraction, and we treat that as an advantage in this context. The objects provided by Xmldoom have a very consistant and well thought-out interface, that attempts to handle as many possible "object-like" interactions as possible. The thinking is that the more Xmldoom does for you, the less you have to do. This is provided in an extensible object-oriented fashion.

Adapts to your database

Even though it is a very heavy abstraction, it doesnt hide the database from you, or force your database to operate in some set way. It can be made to adapt to almost any way you have set up your database to operate, and still provide the same consistant object interface regardless.

Object meta-data

Aside from simply connecting your database to objects, it allows you specify domain specific meta-data about each object and each of its properties. This meta-data is available anywhere in code, such that you can provide generic functions that can take any object, and perform some action on it based on the stored meta-data, without regard to the actual type of the object. For example, you can create a generic mechanism to generate reports, which can generate a report for any object, without needing to be special cased for each type of object you want to report on.

Flexible searches

Xmldoom provides you with a mechanism to search for any object based on any property, whether its a property of that object or any other, so long as it can find a keys relating the objects together. This allows to find any information in your database, without ever having to write an SQL.

Exporter::Easy is a Perl module that takes the drudgery out of Exporting symbols.

SYNOPSIS

In module YourModule.pm:
package YourModule;
use Exporter::Easy (
OK => [ $munge, frobnicate ] # symbols to export on request
);
In other files which wish to use YourModule:
use ModuleName qw(frobnicate); # import listed symbols
frobnicate ($left, $right) # calls YourModule::frobnicate

Exporter::Easy makes using Exporter easy. In its simplest case it allows you to drop the boilerplate code that comes with using Exporter, so

require Exporter;
use base qw( Exporter );
use vars qw( @EXPORT );
@EXPORT = ( init );
becomes
use Exporter::Easy ( EXPORT => [ init ] );
and more complicated situations where you use tags to build lists and more tags become easy, like this
use Exporter::Easy (
EXPORT => [qw( init :base )],
TAGS => [
base => [qw( open close )],
read => [qw( read sysread readline )],
write => [qw( print write writeline )],
misc => [qw( select flush )],
all => [qw( :base :read :write :misc)],
no_misc => [qw( :all !:misc )],
],
OK => [qw( some other stuff )],
);

This will set @EXPORT, @EXPORT_OK, @EXPORT_FAIL and %EXPORT_TAGS in the current package, add Exporter to that packages @ISA and do a use vars on all the variables mentioned. The rest is handled as normal by Exporter.

TinyFCK integrates the TinyMCE rich text editor with FCKEditors file manager and uploader.
TinyFCK package contains:
- TinyMCE release (absolutely not patched, this is the original TinyMCE)
- patched version of FCKEditor file manager/uploader for PHP
- an example documenting configuration
At the moment tinyFCK works only with PHP, porting to other languages may come but help is needed, write us if you can contribute!
Enhancements:
- TinyMCE updated to 2.0.8

LRpt::XMLReport is a Perl module for converting outputs generated by LReport tools to XML format.

SYNOPSIS

lrptxml.pl --selects=selects.txt --keys_file=keys.txt data

lrptxml.pl --diffs --selects=selects.txt --keys_file=rkeys.txt diffs.txt

LRpt::XMLReport is a part of LRpt (LReport) library. It used to convert outputs generated by other tools from LReport suite to XML format. You should not call this class directly from your code. Instead you should use lrptxml.pl tool, which is a simple wrapper around this module. It looks like this:

use strict;
use LRpt::XMLReport;

create_report( @ARGV );

COMMAND LINE SWITCHES

--selects=file

Optional. Name of a selects file (see doc). They are included in the report for a select of corresponding name. If selects are not given, report will not contain selects.

--diffs

Switches working mode to read output of lcsvdiff.pl. If not given the working mode is reading csv files from a directory

--keys_file=keys_file

File name containing row key definitions.

Geo::Spline is a Perl module to calculate geographic locations between GPS fixes.

SYNOPSIS

use Geo::Spline;
my $p0={time=>1160449100.67, #seconds
lat=>39.197807, #degrees
lon=>-77.263510, #degrees
speed=>31.124, #m/s
heading=>144.8300}; #degrees clockwise from North
my $p1={time=>1160449225.66,
lat=>39.167718,
lon=>-77.242278,
speed=>30.615,
heading=>150.5300};
my $spline=Geo::Spline->new($p0, $p1);
my %point=$spline->point(1160449150);
print "Lat:", $point{"lat"}, ", Lon:", $point{"lon"}, "nn";

my @points=$spline->pointlist();
foreach (@points) {
print "Lat:", $_->{"lat"}, ", Lon:", $_->{"lon"}, "n";
}

This program was developed to be able to calculate the position between two GPS fixes using a 2-dimensional 3rd order polynomial spline.

f(t) = A + B(t-t0) + C(t-t0)^2 + D(t-t0)^3 #position in X and Y
f(t) = B + 2C(t-t0) + 3D(t-t0)^2 #velocity in X and Y

I did some simple Math (for an engineer with a math minor) to come up with these formulas to calculate the unknowns from our knowns.

A = x0 # when (t-t0)=0 in f(t)
B = v0 # when (t-t0)=0 in f(t)
C = (x1-A-B(t1-t0)-D(t1-t0)^3)/(t1-t0)^2 # solve for C from f(t)
C = (v1-B-3D(t1-t0)^2)/2(t1-t0) # solve for C from f(t)
D = (v1(t1-t0)+B(t1-t0)-2x1+2A)/(t1-t0)^3 # equate C=C then solve for D

Stratego/XT is a development environment for creating stand-alone transformation systems.
It combines Stratego, a language for implementing transformations based on the paradigm of programmable rewriting strategies, with XT, a collection of reusable components and tools for the development of transformation systems.
In general, Stratego/XT is intended for the analysis, manipulation, and generation of programs, though its features make it useful for transforming any structured documents.
In practice, it has been used to build many types of transformation systems including compilers, interpreters, static analyzers, domain-specific optimizers, code generators, source code refactorers, documentation generators, and document transformers.
Enhancements:
- The compiler was restructured.
- Some old language features were removed.
- Man pages for all tools were completed.
- A new introductory tutorial with examples was co-released, and more.