Added marker to specify, wether min/max-width references page or container

Added debugging-output (debugging can be turned on/off via options)

Fetch on resize: added resize-event that hides/shows banners accordingly

Removed obsolet default-value "cache"

Fetch on resize: "rendered" keeps track of already fetched banners

Fetch on resize: initial fetch considers min/max-widths

Fetch on resize: min/max-widths are collected from "class"

Fetch on resize: separated zone-analysis from fetching

Replaced doubled variable ads with queue

Both variables queue and ads served the same purpose. Hence, the doubled
variable was removed: queue now does the deal alone.

The selector for picking the DOM-elements is now configurable

Added special delivery-configuration-options

Fixed bug: missing "=" for parameter "target"

Zone-Names are now read from OA_zones, just like in the OpenX-code

The server- and delivery-settings are now fully configurable

The Plugin stops its work and logs an error, if a required option is missing

Added some more keywords in the jQuery-Manifest

Plugin shows configuration from first call, when its initialized twice

Switched configuration to an options-object

Appart from the server-name, one can configure the used protocol and the
port-numbers for the http- and the https-protocol now.

Added a jQuery-Manifest

Changed the script into a jquery-plugin

Added copyright- and license-information

Chained loading of /delivery/spc.php and /delivery/fl.js

Browsers, that load these two URL's scripts asynchronigly, might execute
the delivered banner-codes, before fl.js is loaded completely and, hence,
produce an error, if a banner-code referes code from fl.js.

Prevent an error, if OA_source is not defined

Fixed for banner-codes, that does not enclose the src-attribute in quotes

The HTML-standard allows, to write the attributes of an tag without
enclosing quotes. That was not considered in the regular expression, that
parses the <script>-tag.

Polishing the code...

Fixed errors with banner-codes, that assume unaltered URL's

jQuery by default appends a timestamp to every URL, that is called via
jQuery.getScript(), to prevent caching.

This alteration might confuse badly written third-party-ad-scripts, that
assume an explicit format, when parsing URL's.

Another fix to the render-order, for from document.write() collected output

If inline-code was executed directly via jQuery.globalEval(), the
collected output from calls to document.write() was not written
emidiately. Because of that, the ordering of the rendered output was
messed up.

Fixed an error in the ordering, output added via document.write is rendered

Because output added by an ad-script via document.write() was always
prepended to the unrendered rest of the banner-code, the order of the
markup was messed up, if an ad-script called document.write() more then
once!

Ad-banners are now fetched in the given order

Ad-banners are now fetched in the order, that is defined in the variable
"zones". The work-queue "ads" is now stored in an array, because it is not
guarantied, that the JavaScript-engine iterates over the attributes of an
object in the same order, they were added.

Only delivered ads will be shown

HTML-elements marked with "oa" can now be hidden via CSS. openx.js will
unhide them only, if OpenX really delivers a suitable ad-banner

Simplified code

 * Improved method-naming.
 * Simplified code in function render_ads(): instead of a recursive call,
   a while-loop is used now.

Minimized JavaScript: keyword "var" only once per scope

Fix for two errors, that only appear under IE 8

 * The Internet-Explorer stumbles, when feeded with JavaScript-code that
   includes the leading "<!--", that is often used to deter older browsers
   from executing the code. Therefore this markup is filtered from the code
   before it is executed via jQuery.globalEval(). The trailing "//-->" does
   not have to be filtered, because it is a valid JavaScript-comment.
 * A global variable "OA_output" is defined, because IE 8 would complain
   loudly otherwise.

Script-Code is now loaded and executed via $.getScript() and $.globalEval()

The script now utilizes jQuery.getScript(url,callback) and
jQuery.globalEval(code) when loading or executing the code of the detected
script-tags, because these functions work around several issues in older
browsers like IE 8 and Co.

TODO:
 * The gloabal variable OA_output, in which the OpenX-scirpt spc places the
   fetched banner-codes, is not defined under IE8, when the callback is
   called after loading the script. Does the jQuery-function getScript()
   not wait for the script, like suggested by the function-name?

The script overwrites document.write in order to serialize all rendering

The first version of openx.js had sometimes freezed the IE 8. The cause of
this probably was a race-condition while moving the nodes with the banner
to their final destination.

Because of that, the script serializes all modifications of the DOM
strictly now. Implementation-Details:
 * The HTML delivered by OpenX is parsed, in order to detect included
   script-tags.
 * HTML-code is written to the destination-node directly.
 * script-tags, that load additional code are loaded via a script-node,
   that is appended to the end of the page. The script waits, until the
   additional code is loaded, by adding an onload-event to the appended
   script-node.
 * script-tags with inline-code are executed directly via eval().
 * Calls to document.write() in the additional scripts are catched. To
   achieve that, openx.js overwrites document.write with its own
   implementation, that simply adds the code to an execution-queue, that
   is processed, when the onload-event fires or when the eval()-call
   returns.

TODO:
 * Not tested with IE!

Initial version of the script for asynchronous ad-fetching from OpenX

openx.js replaces the OpenX-script spcjs.php. It is modified in such a
way, that it can be called at the bottom of the HTML-page, just before the
closing </body>-tag, so that the ads are loaded, when the rendering of the
page is already completed and, thus, do not block the rendering of the
page.

Implementation-details:
 * openx.js searches via jQery for DOM-elements, that are marked with the
   CSS-class "oa". It fetches banners for all found elements (which banners
   are to fetch is encoded in a second CSS-class).
 * openx.js takes seperate steps to
   1. fetch the banners,
   2. render them in the page and
   3. show them.
   This is necessary, because most of the second-party ad-scripts work
   with document.write(), so that the created banners first become
   accessable via the DOM, when the script returns.
 * Banners are rendert first into a div-block marked with "display:none".
   They are moved to their final destination afterwards. This is necessary,
   because "document.write()" always writes to the actual position of the
   HTML-document, that is the position, where the browser found the
   openx.js-script he is just executing. Hence, all ad-scripts that call
   "document.write()" itself, would render their banner at the bottom of
   the page, albeit the script itself was appended to the right DOM
   -element. The Banners are renderd in a hidden div-block, because it has
   shown, that some ad-scripts produce errors, when they are moved, so that
   the ad was visible in two places afterwards: the div-block at the end of
   the page and at the intended position.

TODO:
 * Not tested with IE yet!